Menu

Flet sortering i C ++ med eksempler

merge sort c with examples

Prøv Vores Instrument Til At Fjerne Problemer

C ++ Flette sorteringsteknik.

Flettsorteringsalgoritme bruger “ del og erobre ”Strategi, hvor vi opdeler problemet i underproblemer og løser disse underproblemer individuelt.

Disse underproblemer kombineres eller flettes derefter sammen for at danne en samlet løsning.

=> Læs gennem den populære C ++ træningsserie her.

Flet sortering

Hvad du vil lære:

bedste software til at rense pc 2015

Oversigt

Flettsortering udføres ved hjælp af følgende trin:

# 1) Den liste, der skal sorteres, er opdelt i to arrays af samme længde ved at opdele listen på det midterste element. Hvis antallet af elementer på listen enten er 0 eller 1, betragtes listen som sorteret.

#to) Hver underliste sorteres individuelt ved hjælp af flettsorter rekursivt.

# 3) De sorterede underlister kombineres eller flettes derefter sammen for at danne en komplet sorteret liste.

Generel algoritme

Den generelle pseudokode for fusionssorteringsteknikken er angivet nedenfor.

Erklær en matrix Arr med længde N
Hvis N = 1, er Arr allerede sorteret
Hvis N> 1,
Venstre = 0, højre = N-1
Find midten = (venstre + højre) / 2
Ring til merge_sort (Arr, venstre, midten) => sorter første halvdel rekursivt
Ring til merge_sort (Arr, midten + 1, højre) => sorter anden halvdel rekursivt
Kald fletning (Arr, venstre, midten, højre) for at flette sorterede arrays i ovenstående trin.
Afslut

Som vist i den ovennævnte pseudokode opdeler vi i flettsorteringsalgoritme arrayet i halvdelen og sorterer hver halvdel ved hjælp af merge sort rekursivt. Når underarrays er sorteret individuelt, flettes de to underarrays sammen for at danne et komplet sorteret array.

Pseudokode til flettsortering

Følgende er pseudokoden til flettsorteringsteknik. For det første har vi en procedureflettsortering for at opdele arrayet i halvdele rekursivt. Så har vi en fletningsrutine, der fletter de sorterede mindre arrays for at få et komplet sorteret array.

procedure mergesort( array,N ) array – list of elements to be sorted N – number of elements in the list begin if ( N == 1 ) return array var array1 as array = a(0) ... a(N/2) var array2 as array = a(N/2+1) ... a(N) array1 = mergesort(array1) array2 = mergesort(array2) return merge( array1, array2 ) end procedure procedure merge(array1, array2 ) array1 – first array array2 – second array begin var c as array while ( a and b have elements ) if ( array1(0) > array2(0) ) add array2 (0) to the end of c remove array2 (0) from array2 else add array1 (0) to the end of c remove array1 (0) from array1 end if end while while ( a has elements ) add a(0) to the end of c remove a(0) from a end while while ( b has elements ) add b(0) to the end of c remove b(0) from b end while return c end procedure

Lad os nu illustrere sammenlægningssorteringsteknikken med et eksempel.

Illustration

flet sort Illustration

Ovenstående illustration kan vises i nedenstående tabelform:

PassereUsorteret listedeleSorteret liste
1{12, 23,2,43,51,35,19,4}{12,23,2,43}
{51,35,19,4}		{}
to{12,23,2,43}
{51,35,19,4}		{12.23} {2.43}
{51.35} {19.4}		{}
3{12.23} {2.43}
{51.35} {19.4}		{12.23} {2.43}
{35.51} {4.19}		{12.23} {2.43}
{35.51} {4.19}
4{12.23} {2.43}
{35.51} {4.19}		{2,12,23,43}
{4,19,35,51}		{2,12,23,43}
{4,19,35,51}
5{2,12,23,43}
{4,19,35,51}		{2,4,12,19,23,35,43,51}{2,4,12,19,23,35,43,51}
6{}{}{2,4,12,19,23,35,43,51}

Som vist i ovenstående repræsentation er arrayet opdelt i to underarrays med længde 4. Hver underarray er yderligere opdelt i yderligere to underarrays med længde 2. Hver underarray er derefter yderligere opdelt i en underrække af et element hver. Hele denne proces er 'Opdel' -processen.

Når vi har opdelt arrayet i underarrays af hvert enkelt element, skal vi nu flette disse arrays i sorteret rækkefølge.

Som vist i illustrationen ovenfor betragter vi hvert underarray af et enkelt element og kombinerer først elementerne for at danne underarrays af to elementer i sorteret rækkefølge. Dernæst sorteres de sorterede underarrangementer med længde to og kombineres for at danne to underarrangementer med længde fire hver. Derefter kombinerer vi disse to underarrays for at danne et komplet sorteret array.

Iterativ flettsortering

Algoritmen eller teknikken til flettsortering, som vi har set ovenfor, bruger rekursion. Det er også kendt som “ rekursiv fusion sortering ”.

Vi ved, at rekursive funktioner bruger funktionskaldestak til at gemme den mellemliggende tilstand af opkaldsfunktionen. Det gemmer også andre bogføringsoplysninger til parametre osv. Og udgør overhead med hensyn til lagring af aktiveringsregistrering for at ringe til funktionen samt genoptage udførelsen.

Alle disse omkostninger kan slettes, hvis vi bruger iterative funktioner i stedet for rekursive. Ovenstående flette sorteringsalgoritme kan også let konverteres til iterative trin ved hjælp af sløjfer og beslutningstagning.

Ligesom rekursiv flettsortering har iterativ flettsortering også O (nlogn) kompleksitet og dermed præstationsmæssigt, de udfører på niveau med hinanden. Vi er simpelthen i stand til at sænke omkostningerne.

I denne vejledning har vi koncentreret os om rekursiv flettsortering, og derefter implementerer vi rekursiv fletningssortering ved hjælp af C ++ og Java-sprog.

Nedenfor er en implementering af fusionssorteringsteknik ved hjælp af C ++.

#include using namespace std; void merge(int *,int, int , int ); void merge_sort(int *arr, int low, int high) { int mid; if (low num; cout<<'Enter '<myarray(i); } merge_sort(myarray, 0, num-1); cout<<'Sorted array '; for (int i = 0; i < num; i++) { cout<

Produktion:

Indtast antallet af elementer, der skal sorteres: 10

Indtast 10 elementer, der skal sorteres: 101 10 2 43 12 54 34 64 89 76

Sorteret matrix

2 10 12 34 43 54 64 76 89101

I dette program har vi defineret to funktioner, flet_sort og gå . I funktionen merge_sort deler vi arrayet i to lige store arrays og kalder merge-funktion på hver af disse underarrays. I fletningsfunktion udfører vi den faktiske sortering på disse underarrays og fletter dem derefter sammen i et komplet sorteret array.

Dernæst implementerer vi Merge Sort-teknikken på Java-sprog.

class MergeSort { void merge(int arr(), int beg, int mid, int end) { int left = mid - beg + 1; int right = end - mid; int Left_arr() = new int (left); int Right_arr() = new int (right); for (int i=0; i

Produktion:

Input Array

101 10 2 43 12 54 34 64 89 76

Array sorteret ved hjælp af flettsortering

2 10 12 34 43 54 64 76 89101

Også i Java-implementering bruger vi den samme logik som vi brugte i C ++ implementering.

Flettsortering er en effektiv måde at sortere lister på og bruges hovedsagelig til sortering af sammenkædede lister. Da den bruger en opdeling og erobring tilgang, fungerer flettsorteringsteknik lige så effektiv til mindre såvel som større arrays.

Kompleksitetsanalyse af fusioneringsalgoritmen

Vi ved, at for at udføre sortering ved hjælp af flettsortering deler vi først arrayet i to lige store halvdele. Dette er repræsenteret af 'log n', som er en logaritmisk funktion, og antallet af trin er højst log (n + 1).

Næste for at finde det midterste element i arrayet kræver vi et enkelt trin, dvs. O (1).

Derefter tager vi O (n) løbetid for at flette underarrangementerne i en række n-elementer.

Således vil den samlede tid til at udføre flettesortering være n (log n + 1), hvilket giver os tidskompleksiteten af ​​O (n * logn).

Værst tilfælde tidskompleksitetO (n * log n)
Kompleksitet i bedste tilfældeO (n * log n)
Gennemsnitlig tidskompleksitetO (n * log n)
RumkompleksitetPå)

Tidskompleksiteten for flettsortering er den samme i alle tre tilfælde (værste, bedste og gennemsnitlige), da den altid opdeler arrayet i underarrays og derefter fletter underarrayerne under lineær tid.

Flettsortering tager altid lige meget plads som usorterede arrays. Derfor, når listen, der skal sorteres, er en matrix, skal flettsortering ikke bruges til meget store arrays. Flettsortering kan dog bruges mere effektivt til sortering af sammenkædede lister.

Konklusion

Flettsortering bruger strategien 'opdele og erobre', der opdeler arrayet eller listen i adskillige underarrays og sorterer dem individuelt og derefter flettes i et komplet sorteret array.

Flettsortering fungerer hurtigere end andre sorteringsmetoder og fungerer også effektivt til mindre og større arrays.

Vi vil udforske mere om hurtig sortering i vores kommende tutorial!

=> Hold øje med begyndere C ++ træningsvejledning her.

Anbefalet læsning

^