Csak annyit kell tudni a Quicksortról C ++ nyelven

Ez a cikk részletes és átfogó ismeretekkel szolgál a Quicksort C ++ rendszerben történő megvalósításáról példákkal.

Rengeteg rendezési algoritmus létezik. Az alkalmazásnak megfelelő illeszkedés megtalálása olyan feladat, amely megköveteli az olyan tényezők rövid megértését, mint egy adott algoritmus teljesítménye, időbonyolultsága, a kód hossza stb. Ebben a bejegyzésben a következő sorrendben vesszük szemügyre a Quicksort C ++ változatban történő megvalósításához szükséges összes alapvető fogalmat:



A Quicksort algoritmus megértése

Mint Egyesítés rendezés , A Quicksort követi a divide and conquer stratégiát. A divide and conquer stratégia használatával a problémát sok részproblémára osztjuk, és rekurzív módon oldjuk meg. Először lépésről lépésre meg fogjuk érteni az egész folyamatot, majd ezt követően egy példa segítségével mélyreható megértést fogunk kialakítani az egész folyamatról.



  1. Először a rendezetlen tömböt kérjük a felhasználótól.

  2. Miután megvan a nem rendezett tömbünk, ki kell választanunk egy pivot értéket a tömbből. Bármilyen értéket választhatunk.



  3. Miután kiválasztottuk az elfordulási pontot, el kell rendeznünk a tömb többi elemeit úgy, hogy az összes, a forgásértéknél kisebb elemet a pivot értékétől jobbra, és az összes elemet, amely nagyobb, mint a pivot értéket a forgóértéktől jobbra kell elhelyezni.

  4. Addig hajtjuk végre a 3. lépést, amíg meg nem kapjuk a rendezett tömböt.

Vegyünk egy példát, és valósítsuk meg az algoritmust, és nézzük meg, hogyan működik.



Helló [5, 4, 1, 11, 9, 6, 2, 3], ebben a példában mindig az elfordulást tekintjük a lista jobb szélső elemének.

Quicksort C ++ nyelven

Menjünk végig minden lépést, és értsük meg a logikát, amelyet a probléma megoldására használtunk.

  • Először a „3” -ot választottuk el forgópontunknak, és az összes elemet a „3” -nál kisebbre, a jobb oldalon pedig a „3-nál” nagyobb elemeket rendeztük.

  • Ezen a ponton 2 részproblémánk van. Először oldjuk meg a jobb oldali részproblémát. Kiválasztottunk egyet forgásunknak, és a „2” -t helyeztük jobbra.

  • A második részprobléma megoldásához a „6” -t választjuk el forgópontunknak, és az elemeket a korábban tárgyaltak szerint helyezzük el.

  • Van még 2 részproblémánk. Az elsőt úgy oldjuk meg, hogy a 4-et választjuk el forgásként, a másodikat pedig úgy, hogy a 9-et választjuk ki a forgáspontnak. Végül megvan a rendezett tömbünk az elemekkel az aláhúzási indexen.

Jegyzet- Az itt megértendő fontos szempont az, hogy az összes művelet ugyanabban a tömbben zajlik. Új tömbök nem jönnek létre.

Álkód a Quicksort számára C ++ nyelven

QuickSort (tömb [], start_index, end_index) {if (start_index

A Quicksort programja C ++ nyelven

Megértettük az algoritmust és mélyen megértettük az algoritmus működését. Vezessük be a Quicksort-ot C ++ nyelven, és írjunk programot egy tömb rendezéséhez.

#include névtér használatával stid void swap_elements (int * a, int * b) {int temp = * a * a = * b * b = temp} int partíció (int tömb [], int start_index, int end_index) {int pivot = tömb [end_index] int i = (start_index - 1) a (int j = start_index j<= end_index- 1 j++) { if (array[j] <= pivot) { i++ swap_elements(&array[i], &array[j]) } } swap_elements(&array[i + 1], &array[end_index]) return (i + 1) } void quickSort(int array[], int start_index, int end_index) { if (start_index < end_index) { int partition_index = partition(array, start_index, end_index) quickSort(array, start_index, partition_index - 1) quickSort(array, partition_index + 1, end_index) } } void printArray(int array[], int number) { int i cout<<'Sorted Array: ' for (i = 0 i < number i++) cout << array[i] << ' ' cout << endl } int main() { int Hello[30] int i int NumberofElements cout<>Elszámolási költségek száma<<'Enter the elements one by one: ' for(i=0i>Hello [i]} quickSort (Hello, 0, Elemek száma-1) printArray (Helló, Elemek száma) return 0}

Kimenet:

Idő komplexitás

Beszéljünk minden rendezési algoritmus legfontosabb aspektusáról, vagyis az idő bonyolultságáról. Elmondja az algoritmus teljesítményét különböző forgatókönyvekben. Ezek az értékek segíthetnek abban, hogy eldönthessük, alkalmazhatjuk-e ezt az algoritmust alkalmazásunkhoz.

  • Legjobb eset- Tovább)
  • Átlagos eset- (nlogn)
  • Legrosszabb esetben- Tovább2)

Ezzel véget értünk ennek a Quicksortnak a C ++ cikkben. Ha többet szeretne megtudni, nézze meg a Edureka, egy megbízható online tanulási társaság. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát arra tervezték, hogy mind az alapvető, mind a fejlett Java koncepciókra kiképezzen különféle Java keretrendszereket, például a Hibernate & Spring.

Van egy kérdésünk? Kérjük, említse meg a blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.

hogyan kell használni az iterator java-t