Sortare rapidă

Sortare rapidă

Sortarea rapidă este o metodă avansată de sortare bazată pe principiul schimbului. Selectarea cu bule este cea mai ineficientă dintre algoritmii de sortare directă. Cu toate acestea, algoritmul îmbunătățit este metoda cea mai cunoscută pentru sortarea matricelor. Are caracteristici atît de strălucite încât inventatorul său, Ch. Hoare, a numit-o o sortare rapidă.







Pentru a fi cel mai eficient, este de dorit să facă schimb de elementele pe distanțe lungi. În unele element de matrice selectat, numit permisiv. Apoi a pus în locul matrice, unde trebuia să fie după ordonarea tuturor elementelor. În procesul de a găsi un loc potrivit pentru rezolvarea elementului rearanjează elementele, astfel încât elementele sunt lăsate de ele, mai puțin decât rezoluția, iar pe dreapta - mic (se presupune că matricea este sortată în ordine crescătoare).

Astfel, matricea este împărțită în două părți:

  • elemente neasamblate în stânga elementului de rezolvare;
  • nu sunt sortate elemente în partea dreaptă a elementului de rezolvare.

Pentru a sorta aceste două submarine mai mici, algoritmul se numește recursiv.

Dacă doriți să sortați mai mult de un element, aveți nevoie

  • selectați elementul de rezolvare din matrice;
  • rearanjați o matrice prin plasarea elementului în locația sa finală;
  • sortați elementele recursiv în partea stângă a rezolvării;
  • sortați elementele recursiv în partea dreaptă a soluției.

Elementul cheie al sortării rapide este algoritmul de reordonare.

Să considerăm sortarea pe un exemplu de matrice:

Pentru a implementa algoritmul de reordonare folosind cursorul stânga la stânga element al matrice. Indicatorul se mișcă spre dreapta până când elementele pe care se arată mai puțin sunt permise. Indicele pus chiar la elementul de matrice din dreapta, și se deplasează spre stânga, până când elementele pe care le prezintă în continuare mai este permis.







Fie elementul din stânga pivotul de rezolvare. Setați indicatorul din stânga la elementul următor; dreapta - ultimul. Algoritmul ar trebui să determine poziția corectă a elementului 10 și, în cursul schimbului de materiale, elementele poziționate incorect.

Mișcarea indicatorilor se oprește de îndată ce există elemente ale căror ordine de aranjare față de elementul de rezolvare este incorectă.

Indicatorul stânga se mișcă până când acesta arată un element mai mare de 10; mută dreapta până când arată un element mai mic de 10.


Aceste elemente schimbă locurile și mișcarea indicatorilor reia.


Procesul continuă până când partea dreaptă se află în partea stângă a stângii.


Aceasta va determina poziția corectă a elementului de rezolvare.

Elementul de permutare este rearanjat cu elementul indicat de dreapta.

Elementul de rezolvare este în locul potrivit: elementele din partea stângă a acestuia au valori mai mici; pe dreapta - mare. Algoritmul este chemat în mod recursiv pentru a sorta subarrajele din stânga resolverului și din partea dreaptă a acestuia.

Implementarea algoritmului de sortare rapidă pe C

#include
#include
// Funcția de sortare rapidă
void quickSort (int * numere, int stânga, int dreapta)
int pivot; // element de rezolvare
int l_hold = stânga; // frontiera stanga
int r_hold = dreapta; // frontiera dreapta
pivot = numere [stânga];
în timp ce (stânga în timp ce ((numere [dreapta]> = pivot) (din stânga right--; // deplasați marginea din dreapta în timp ce elementul [right] este mai mare decât [pivot]
dacă (stânga! = dreapta) // dacă limitele nu se închid
numere [stânga] = numere [dreapta]; // mutați elementul [right] la permisiv
stânga ++; // deplasați marginea din stânga spre dreapta
>
în timp ce ((numerele [stânga] <= pivot) && (left stânga ++; // deplasați marginea din stânga în timp ce elementul [stânga] este mai mic [pivot]
dacă (stânga! = dreapta) // dacă limitele nu se închid
<
numere [dreapta] = numere [stânga]; // mutați elementul [stânga] în locul [dreapta]
right--; // mutați marginea dreaptă spre dreapta
>
>
numere [stânga] = pivot; / / puneți elementul de rezolvare în poziție
pivot = stânga;
left = l_hold;
right = r_hold;
dacă (stânga rapidSort (numere, stânga, pivot - 1);
dacă (dreapta> pivot)
quickSort (numere, pivot + 1, dreapta);
>
int main ()
int a [10];
// Completați matricele cu numere aleatorii
pentru (int i = 0; i<10; i++)
a [i] = rand ()% 20 - 10;
// Afișați elementele matricei înainte de sortare
pentru (int i = 0; i<10; i++)
printf ("."; a [i]);
printf ("\ n");
rapidSort (a, 0, 9); // apelați funcția de sortare
// Exportați elementele matrice după sortare
pentru (int i = 0; i<10; i++)
printf ("."; a [i]);
printf ("\ n");
getchar ();
retur 0;
>







Articole similare

Pagina anterioară

Pagina următoare

Trimiteți-le prietenilor: