Gyors rendezés
A gyors válogatás egy fejlett válogatási módszer, amely a csere elvén alapul. A buborék válogatás az összes közvetlen rendezési algoritmus leginkább hatékonysága. A javított algoritmus azonban a legelismertebb módszer a tömbök rendezéséhez. Olyan ragyogó tulajdonságokkal rendelkezik, mint Ch. Hoare feltalálója, hogy gyors válogatásnak nevezte.
A legnagyobb hatékonyság elérése érdekében nagy távolságra kell cserélni az elemeket. A tömbben egy elemet választanak ki, a megoldást. Aztán tedd a helyére a tömb, ahol lennie kellett volna rendezés utáni összes elem. A folyamat találni egy megfelelő helyet megoldására elem átrendezi az elemeket úgy, hogy az elemek maradt belőlük, kevesebb, mint a felbontás, és a jobb oldalon - kis (feltételezzük, hogy a tömb rendezése növekvő sorrendben).
Így a tömb két részre van osztva:
- nem rendezett elemek a feloldó elem bal oldalán;
- nem rendezett elemeket a feloldó elem jobb oldalán.
A két kisebb alárendszer rendezéséhez az algoritmus rekurzívan hívja magát.
Ha több elemet szeretne rendezni, akkor szüksége van rá
- válasszuk ki a tömbben lévő felbontó elemet;
- rendezze át a tömböt úgy, hogy az elemet a végső helyére helyezi;
- rendezze az elemeket rekurzívan a felbontás bal oldalán;
- rendezze az elemeket rekurzívan a megoldás jobb oldalára.
A gyors rendezés kulcseleme az átrendező algoritmus.
Vegyük fontolóra a tömb egy példájára való szétválogatást:
Az átrendező algoritmus végrehajtásához a bal mutatót a tömb bal szélső elemére használjuk. Az egérmutató jobbra mozog, amíg az elemek, amelyekre nézve, nem maradnak a permissíveknél. Index rendbe a jobb szélső elem a tömb, és balra mozog, amíg az elemeket, amelyek azt mutatja, tovább maradnak engedélyezve.
Hagyja, hogy a baloldali elem legyen a megoldás. Állítsa a bal oldali mutatót a következő elemre; jobbra - az utolsóig. Az algoritmusnak meg kell határoznia a 10 elem helyes helyzetét, és az anyag során helytelenül helyezett elemeket kell kicserélnie.
A mutatók mozgása megáll, amint olyan elemek vannak, amelyek rendezési sorrendje a felbontóelemhez képest helytelen.
A bal mutató mindaddig mozog, amíg 10-nél nagyobb elemet nem mutat; jobbra mozog, amíg 10-nél kisebb elemet mutat.
Ezek az elemek megváltoztatják a helyeket, és a mutatók mozgása folytatódik.
A folyamat addig folytatódik, amíg a jobb oldalon a bal oldalon balra esik.
Ez meghatározza a felbontó elem helyes elhelyezkedését.
A permutációs elem átrendeződik a jobbra mutató elemgel.
A felbontó elem a megfelelő helyen van: a bal oldali elemek kisebb értékekkel rendelkeznek; a jobb oldalon - nagy. Az algoritmust rekurzív módon a rendező bal oldalára és annak jobb oldalára rendezzük.
Az algoritmus végrehajtása gyors válogatásra a C-n
#include
#include
// Gyors rendezési funkció
void quickSort (int * számok, int left, int right)
int pivot; // megoldó elem
int l_hold = bal; // bal szél
int r_hold = jobb; // jobb szél
pivot = számok [left];
míg (balra
ha (balra = jobbra) // ha a határok nem záródnak le
számok [left] = számok [right]; // mozgassa a [jobb] elemet a permissívbe
balra ++; // tolja jobbra a bal oldali szegélyt
>
míg a ((számok [balra] <= pivot) && (left
ha (balra = jobbra) // ha a határok nem záródnak le
<
számok [jobb] = számok [balra]; // mozgassa a [bal oldali] elemet a helyre [jobbra]
right--; // tolja jobbra a jobb oldalt
>
>
számok [left] = pivot; // helyezze a felbontó elemet a helyére
pivot = bal;
bal = l_hold;
jobb = r_hold;
ha (balra
ha (jobb> pivot)
quickSort (számok, pivot + 1, jobb);
>
int main ()
int a [10];
// Töltse ki a tömböt véletlen számokkal
az (int i = 0; i<10; i++)
a [i] = rand ()% 20 - 10;
// Megjeleníti a tömbelemeket a rendezés előtt
az (int i = 0; i<10; i++)
printf ("." a [i]);
printf ("\ n");
quickSort (a, 0, 9); // hívja a rendezési funkciót
// A tömbelemek kimenete a rendezés után
az (int i = 0; i<10; i++)
printf ("." a [i]);
printf ("\ n");
getchar ();
visszatérés 0;
>