Ang Kailangan Mong Malaman Tungkol sa Quicksort sa C ++



Magbibigay sa iyo ang artikulong ito ng isang detalyado at komprehensibong kaalaman kung paano ipatupad ang Quicksort sa C ++ na may Mga Halimbawa.

Mayroong isang kalabisan ng mga pag-uuri ng mga algorithm. Ang paghahanap ng tamang akma para sa iyong aplikasyon ay isang gawain na nangangailangan ng isang maikling pag-unawa sa mga kadahilanan tulad ng pagganap, pagiging kumplikado ng oras, haba ng code, atbp ng isang partikular na algorithm. Sa post na ito, titingnan namin ang lahat ng mahahalagang konsepto na kinakailangan upang ipatupad ang Quicksort sa C ++ sa sumusunod na pagkakasunud-sunod:

Pag-unawa sa Quicksort Algorithm

Katulad ng Sumanib-uuri , Sinusundan ng Quicksort ang diskarte sa paghati at pagsakop. Sa pamamagitan ng paggamit ng diskarte sa paghati at pagwawagi nahahati natin ang problema sa maraming mga subproblems at malulutas ito nang paulit-ulit. Una, mauunawaan natin ang buong proseso ng hakbang-hakbang at pagkatapos nito, sa tulong ng isang halimbawa, magkakaroon kami ng malalim na pag-unawa sa buong proseso.





  1. Una, hihilingin namin ang unsortadong array mula sa gumagamit.

  2. Kapag mayroon na kaming unsortadong array kailangan naming pumili ng isang halaga ng pivot mula sa array. Maaari kaming pumili ng anumang halaga.



  3. Sa sandaling pinili namin ang pivot point pagkatapos nito kailangan naming ayusin ang iba pang mga elemento ng array sa isang paraan na, ang lahat ng mga elemento na mas mababa sa halaga ng pivot ay dapat na ilagay sa kanan ng halaga ng pivot at lahat ng mga elemento na mas malaki kaysa sa pivot ang halaga ay ilalagay sa kanan ng halaga ng pivot.

  4. Nagsasagawa kami ng hakbang 3 hanggang makuha namin ang aming pinagsunod-sunod na array.

Ngayon, isaalang-alang natin ang isang halimbawa at ipatupad ang algorithm at tingnan kung paano ito gumagana.



Kumusta [5, 4, 1, 11, 9, 6, 2, 3] para sa halimbawang ito palagi naming isasaalang-alang ang pivot bilang ang pinakamatuwid na elemento ng listahan.

Quicksort sa C ++

Dumaan tayo sa bawat hakbang at maunawaan ang lohika na ginamit namin upang malutas ang problema.

ano ang ginagawa ng .trim sa java
  • Una, pinili namin ang '3' bilang aming pivot at inayos ang lahat ng mga elemento na mas mababa sa '3' sa kanan at lahat ng mga elemento na mas malaki sa '3' hanggang sa kanan.

  • Sa puntong ito, mayroon kaming 2 subproblems. Malutas muna natin ang subproblem sa kanan. Pinili namin ang isa bilang aming pivot at inilagay ang '2' sa kanan.

  • Upang malutas ang pangalawang subproblem pipiliin namin ang '6' bilang aming pivot at ilagay ang mga elemento tulad ng tinalakay namin nang mas maaga.

  • Mayroon kaming 2 pang mga subproblems. Ang una ay nalulutas sa pamamagitan ng pagpili ng 4 bilang pivot at ang pangalawa ay nalulutas sa pamamagitan ng pagpili ng 9 bilang pivot. Sa wakas, Namin ang aming pinagsunod-sunod na array na may mga elemento na inilagay sa underline index.

Tandaan- Ang mahalagang puntong maiintindihan dito ay ang lahat ng mga pagpapatakbo na magaganap sa parehong array. Ang mga bagong array ay hindi nilikha.

Pseudocode para sa Quicksort sa C ++

QuickSort (array [], start_index, end_index) {kung (start_index

Programa ng Quicksort sa C ++

Naintindihan namin ang algorithm at bumuo ng isang malalim na pag-unawa sa pagtatrabaho ng algorithm. Ipatupad natin ang Quicksort sa C ++ at magsulat ng isang programa upang ayusin ang isang array.

java makakuha ng petsa mula sa string
# isama ang paggamit ng namespace std void swap_elements (int * a, int * b) {int temp = * a * a = * b * b = temp} int partition (int array [], int start_index, int end_index) {int pivot = array [end_index] int i = (start_index - 1) para sa (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<>NumberofElemen gastos<<'Enter the elements one by one: ' for(i=0i>Kumusta [i]} mabilisSort (Kumusta, 0, NumberofElemen-1) printArray (Kamusta, NumberofE Element) ibalik 0}

Output:

Pagiging kumplikado ng Oras

Pag-usapan natin ang pinakamahalagang aspeto ng anumang pag-uuri ng algorithm, iyon ang pagiging kumplikado ng oras. Sinasabi nito sa amin ang tungkol sa pagganap ng algorithm sa iba't ibang mga sitwasyon. Ang mga halagang ito ay maaaring makatulong sa amin sa pagpapasya kung maaari naming gamitin ang algorithm na ito para sa aming aplikasyon.

  • Pinakamagandang kaso- O (n)
  • Average na kaso- (nlogn)
  • Pinakamasamang kaso- O (n2)

Sa pamamagitan nito, natapos namin ang artikulong Quicksort na ito sa C ++. Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.