Paano Maipatupad ang QuickSort sa Java?

Ang QuickSort ay isang paghati at pagsakop sa algorithm. Sa Divig & Conquer algorithm disenyo ng paradigm, hinati namin ang mga problema sa mga sub-problema nang paulit-ulit pagkatapos malutas ang mga sub-problema at sa wakas ay pagsamahin ang mga solusyon upang mahanap ang huling resulta. Sa artikulong ito ay magtutuon kami sa QuickSort In

Saklaw ang artikulong ito sa artikulong ito,

• QuickSort sa Java
• Pag-andar ng QuickSort
• Partition Code
• QuickSort Java Code

Magsimula tayo!

Ang isang bagay na dapat tandaan habang hinahati ang mga problema sa mga sub-problema ay ang istraktura ng mga sub-problema ay hindi nagbabago tulad ng orihinal na problema.
Ang Divide & Conquer algorithm ay may 3 mga hakbang:

• Hatiin: Paghiwalayin ang problema sa mga subproblems
• Mananakop: Recursively paglutas ng mga subproblems
• Pagsamahin: Pagsasama-sama ng mga solusyon upang makuha ang pangwakas na resulta

Mayroong iba't ibang mga algorithm batay sa paradahan ng paghati at pagsakop. Ang mabilis na pag-uuri at pagsamahin ang uri ay kabilang sa kanila.

Bagaman ang pinakapangit na pagkakumplikado ng oras ng QuickSort ay O (n2) na higit sa maraming iba pang mga algorithm sa pag-uuri tulad ng Merge Sort at Heap Sort, ang QuickSort ay mas mabilis sa pagsasanay, dahil ang panloob na loop ay maaaring mabisang ipatupad sa karamihan ng mga arkitektura, at sa karamihan data sa totoong mundo.

Pag-usapan natin ang tungkol sa pagpapatupad ng Quick sort algorithm. Ang mga algorithm ng Quicksort ay kumukuha ng isang elemento ng pivot at hinahati ang array sa paligid ng pivot elememt. Mayroong bilang ng mga pagkakaiba-iba ng Quicksot na nakasalalay sa kung paano mo pipiliin ang elemento ng pivot. Mayroong maraming mga paraan upang piliin ang elemento ng pivot:

• Ang pagpili ng unang elemento
• Piliin ang huling elemento
• Pagpili ng isang random na elemento
• Pagpili ng median na elemento

Susunod na mahalagang bagay na dapat maunawaan ay, ang pagkahati () na pag-andar sa Mabilis na pag-uuri ng algorithm. Ang pag-andar ng pagkahati upang kumuha ng isang elemento ng pivot, inilalagay ito sa tamang posisyon, inililipat ang lahat ng mga elemento na mas maliit kaysa sa elemento ng pivot sa kaliwa nito at lahat ng mga elemento na mas malaki sa kanan nito. Ang Quicksort ay tumatagal ng linear na oras upang magawa ito.
Pagkatapos ang array ay nahahati sa dalawang bahagi mula sa elemento ng pivot (ibig sabihin, mga elemento na mas mababa sa pivot at mga elemento na mas malaki kaysa sa pivot) at pareho ang mga arrays ay recursively na pinagsunod-sunod gamit ang Quicksort algorithm.

Ngayon na nauunawaan namin ang pagtatrabaho ng QuickSort algorithm. Unawain natin kung paano i-apply ang Quicksort algorithm sa Java.

QuickSort Pag-andar:

/ * Kailangan ng Quicksort Function ang array upang maayos ayon sa pinakamababa at pinakamataas na index * /

kung paano gumamit ng semaphores sa java

void sort (int arr [], int lowIndex, int highIndex) {// Hanggang lowIndex = highIndex kung (lowIndex
Ngayon tingnan natin ang code ng pagkahati upang maunawaan kung paano ito gumagana.
Paghati Code 
Sa code ng pagkahati, pipiliin namin ang huling elemento bilang elemento ng pivot. Daanan namin ang kumpletong array (ibig sabihin, gumagamit ng variable j sa aming kaso). Sinusubaybayan namin ang huling pinakamaliit na elemento sa array (ibig sabihin, gumagamit ng variable i sa aming kaso). Kung makakita kami ng anumang elemento na mas maliit kaysa sa pivot, inililipat namin ang pagpapalit ng kasalukuyang elemento ng isang [j] kasama ang arr [i], kung hindi man ay patuloy kaming dumadaan.
int partition (int arr [], int lowIndex, int highIndex) {// Paggawa ng huling elemento bilang pivot int pivot = arr [highIndex] // Paggamit ng i upang subaybayan ang mas maliliit na mga elemento mula sa pivot int i = (lowIndex-1) para sa (int j = lowIndex j
Ngayon na naintindihan mo ang pagpapaandar ng Quicksort at pagkahati, ipaalam sa amin nang mabilis ang kumpletong code
QuickSort Java Code 
klase QuickSort {// Partition Method int partition (int arr [], int lowIndex, int highIndex) {int pivot = arr [highIndex] int i = (lowIndex-1) para sa (int j = lowIndex j
// Pamamaraan ng Pagsunud-sunurin
walang bisa na pag-uuri (int arr [], int lowIndex, int highIndex) {kung (lowIndex
// Paraan upang mai-print ang array
static void printArray (int arr []) {int n = arr.length para sa (int i = 0 i
// Pangunahing Pamamaraan
public static void main (String args []) {int arr [] = {101, 37, 68, 29, 11, 5} int n = arr.length QuickSort ob = bagong QuickSort () ob.sort (arr, 0, n-1) System.out.println ('inayos na array') printArray (arr)}}
 Output: 
 
Ngayon pagkatapos maipatupad ang nasa itaas na programa ng Java ay naiintindihan mo kung paano gumagana ang QuickSort at kung paano ito ipatupad sa Java.Sa gayon ay natapos na kami sa artikulong ito sa 'Quicksort in Java'. 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.