merge sort c with examples
Tècnica d'ordenació de combinació de C ++.
L’algorisme d’ordenació de combinació utilitza divideix i conquereix ”Estratègia en què dividim el problema en subproblemes i resolem aquests subproblemes individualment.
Aquests subproblemes es combinen o combinen per formar una solució unificada.
=> Llegiu aquí la popular sèrie de formació C ++.
Què aprendreu:
- Visió general
- Algorisme general
- Codi pseudo per ordenar la combinació
- Il·lustració
- Classificació de combinació iterativa
- Anàlisi de complexitat de l'algorisme de classificació de combinació
- Conclusió
- Lectura recomanada
Visió general
La classificació de combinació es realitza seguint els passos següents:
# 1) La llista a ordenar es divideix en dues matrius d'igual longitud dividint la llista a l'element central. Si el nombre d'elements de la llista és 0 o 1, la llista es considera ordenada.
# 2) Cada subllista s'ordena individualment mitjançant l'ús de la combinació de manera recursiva.
# 3) Les sublistes ordenades es combinen o combinen per formar una llista completa ordenada.
Algorisme general
A continuació es dóna el pseudocodi general per a la tècnica d’ordenació de combinació.
Com inverteix una matriu al lloc a Java?
Declareu una matriu Arr de longitud N
Si N = 1, Arr ja està ordenat
Si N> 1,
Esquerra = 0, dreta = N-1
Cerca mig = (esquerra + dreta) / 2
Truca a merge_sort (Arr, esquerra, mig) => ordena recursivament la primera meitat
Truca merge_sort (Arr, mig + 1, dreta) => ordena la segona meitat de manera recursiva
Fusió de trucades (Arr, esquerra, mig, dreta) per combinar matrius ordenats en els passos anteriors.
Surt
Com es mostra al pseudocodi anterior, en l'algorisme d'ordenació de combinació dividim la matriu en meitat i ordenem cada meitat mitjançant l'ordenació de combinació recursivament. Un cop les matrius secundàries s’ordenen individualment, les dues matrius secundàries es combinen per formar una matriu ordenada completa.
Codi pseudo per ordenar la combinació
A continuació es mostra el pseudocodi per a la tècnica d’ordenació de combinacions. En primer lloc, tenim un procediment de fusió per dividir la matriu en meitats recursivament. A continuació, tenim una rutina de combinació que combinarà les matrius més petites ordenades per obtenir una matriu ordenada completa.
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 procedureIl·lustrem ara la tècnica de classificació per combinació amb un exemple.
Il·lustració
La il·lustració anterior es pot mostrar en forma de taula a continuació:
| Passar | Llista no classificada | divideix | Llista ordenada |
|---|---|---|---|
| 1 | {12, 23,2,43,51,35,19,4} | {12,23,2,43} {51,35,19,4} | {} |
| 2 | {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} |
Com es mostra a la representació anterior, primer la matriu es divideix en dues sub-matrius de longitud 4. Cada sub-matriu es divideix en dos sub-matrius més de longitud 2. Cada sub-matriu es divideix en una sub-matriu. d’un element cadascun. Tot aquest procés és el procés 'Divideix'.
Un cop hem dividit la matriu en sub-matrius d'un element únic cadascun, ara hem de combinar aquests matrius en ordre ordenat.
Com es mostra a la il·lustració anterior, considerem cada subgrup d’un sol element i primer combinem els elements per formar subarranjaments de dos elements en ordre ordenat. A continuació, s’ordenen i combinen els subarrays ordenats de longitud dos i es formen dos subarrays de longitud quatre cadascun. A continuació, combinem aquestes dues sub-matrius per formar una matriu ordenada completa.
Classificació de combinació iterativa
L’algorisme o la tècnica de classificació de fusions que hem vist anteriorment utilitza la recursió. També es coneix com ' ordenació de combinació recursiva '.
Sabem que les funcions recursives utilitzen la pila de trucades de funció per emmagatzemar l’estat intermedi de la funció de trucada. També emmagatzema una altra informació de comptabilitat per a paràmetres, etc., i suposa despeses generals pel que fa a emmagatzemar el registre d'activació de la trucada a la funció, així com reprendre l'execució.
Totes aquestes despeses generals es poden eliminar si utilitzem funcions iteratives en lloc de funcions recursives. L'algoritme de classificació de fusions anterior es pot convertir fàcilment en passos iteratius mitjançant bucles i presa de decisions.
Igual que l’ordenació de combinació recursiva, l’ordenació de combinació iterativa també té complexitat O (nlogn), per tant, en funció del rendiment, funcionen a l’una amb l’altra. Simplement som capaços de baixar les despeses generals.
En aquest tutorial, ens hem concentrat en l'ordenació de combinació recursiva i, a continuació, implementarem l'ordenació de combinació recursiva mitjançant llenguatges C ++ i Java.
A continuació es mostra una implementació de la tècnica de classificació de combinacions mitjançant 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< Sortida:
Introduïu el nombre d'elements a ordenar: 10
Introduïu 10 elements per ordenar: 101 10 2 43 12 54 34 64 89 76
Matriu ordenada
2 10 12 34 43 54 64 76 89 101
En aquest programa, hem definit dues funcions, merge_sort i vaja . A la funció merge_sort, dividim la matriu en dues matrius iguals i anomenem la funció de fusió en cadascun d’aquests submatrius. A la funció de combinació, fem l’ordenació real en aquestes subconjunts i després les combinem en una matriu ordenada completa.
A continuació, implementem la tècnica Merge Sort en llenguatge Java.
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 Sortida:
Matriu d’entrada
101 10 2 43 12 54 34 64 89 76
Matriu ordenada mitjançant un ordre de combinació
2 10 12 34 43 54 64 76 89 101
També en la implementació de Java, fem servir la mateixa lògica que la que vam fer en la implementació de C ++.
La combinació d'ordenacions és una manera eficient d'ordenar llistes i s'utilitza principalment per ordenar llistes enllaçades. Com que utilitza un enfocament de divisió i conquesta, la tècnica de classificació de combinacions té un rendiment igualment eficaç per a matrius més petits i grans.
Anàlisi de complexitat de l'algorisme de classificació de combinació
Sabem que, per tal de realitzar l’ordenació mitjançant la combinació, dividim primer la matriu en dues meitats iguals. Això es representa per 'log n', que és una funció logarítmica i el nombre de passos realitzats és log (n + 1) com a màxim.
A continuació, per trobar l’element central de la matriu, necessitem un sol pas, és a dir, O (1).
A continuació, per combinar les sub-matrius en una matriu de n elements, prendrem O (n) la quantitat de temps d'execució.
D'aquesta manera, el temps total per realitzar l'ordenació de combinació serà n (log n + 1), la qual cosa ens dóna la complexitat temporal d'O (n * logn).
La pitjor complexitat temporal del cas O (n * registre n) Complexitat en el millor dels casos O (n * registre n) Complexitat temporal mitjana O (n * registre n) Complexitat espacial O (n)
La complexitat temporal per a la classificació de combinacions és la mateixa en els tres casos (pitjor, millor i mitjà), ja que sempre divideix la matriu en sub-matrius i després fusiona els sub-matrius prenent temps lineal.
La classificació de combinació sempre ocupa la mateixa quantitat d’espai que les matrius no classificades. Per tant, quan la llista a ordenar és una matriu, no s'hauria d'utilitzar l'ordenació de combinació per a matrius molt grans. Tanmateix, l’ordenació per combinació es pot utilitzar amb més eficàcia per a l’ordenació de llistes enllaçades.
Conclusió
La combinació d'ordenacions utilitza l'estratègia de 'dividir i conquerir', que divideix la matriu o la llista en nombrosos subconjunts i els ordena individualment i després es fusiona en una matriu ordenada completa.
La classificació de combinació funciona més ràpidament que altres mètodes d'ordenació i també funciona de manera eficient per a matrius cada vegada més grans.
Explorarem més informació sobre l’ordenació ràpida al nostre proper tutorial.
=> Mireu aquí la guia de formació per a principiants C ++.
Lectura recomanada
- MongoDB Sort () Mètode amb exemples
- Ordre d'ordenació Unix amb sintaxi, opcions i exemples
- Ordenació de shell en C ++ amb exemples
- Ordena en pila en C ++ amb exemples
- Selecció Ordena en C ++ amb exemples
- Classificació de bombolles en C ++ amb exemples
- Ordre d'inserció a C ++ amb exemples
- Ordena ràpidament en C ++ amb exemples