Vitajte na [www.pocitac.win] Pripojiť k domovskej stránke Obľúbené stránky
import java.util.arrays;
verejná trieda Quicksort3way {
public static void Quicksort3way (int [] arr, int nízko, int high) {
if (low> =high) {
návrat; // Základný prípad:pole veľkosti 0 alebo 1 je už zoradené
}
// oddiel poľa pomocou 3-cestného rozdelenia
int [] oddiel =oddiel3way (ARR, nízka, vysoká);
int lt =oddiel [0]; // index posledného prvku menej ako Pivot
int gt =oddiel [1]; // index prvého prvku väčšieho ako Pivot
// rekurzívne zoradte čiastky
Quicksort3way (ARR, Low, LT - 1); // prvky menej ako Pivot
Quicksort3way (ARR, GT + 1, vysoký); // prvky väčšie ako pivot
}
// 3-cestné rozdelenie:oddiely poľa do troch častí:
// art [nízko ... lt-1]
// arr [gt+1 ... vysoký]> PIVOT
súkromný statický int [] oddiel3way (int [] arr, int nízko, int high) {
int pivot =arr [nízka]; // Vyberte prvý prvok ako Pivot
int lt =nízka; // index posledného prvku menej ako Pivot
int gt =vysoký; // index prvého prvku väčšieho ako Pivot
int i =nízka + 1; // index používaný na prechádzanie poľa
while (i <=gt) {
if (arr [i]
lt ++;
i ++; // Prejdite na ďalší prvok, pretože prvok na 'i' je teraz v správnej polohe
} else if (arr [i]> pivot) {
swap (arr, i, gt);
gt--; // Neuinkresujte 'i', pretože prvok na 'i' je nahradený netriedeným prvkom sprava
} else {
i ++; // arr [i] ==PIVOT, tak prejdite na ďalší prvok
}
}
return new int [] {lt, gt}; // Vráťte indexy LT a GT
}
private static void swap (int [] arr, int i, int j) {
int temp =arr [i];
arr [i] =arr [j];
arr [j] =temp;
}
public static void main (String [] args) {
int [] arr ={5, 3, 8, 6, 1, 2, 9, 4, 7, 5, 3, 8, 6, 5};
System.out.println ("Original Array:" + Arrays.ToString (ARR));
Quicksort3way (ARR, 0, arr.Length - 1);
System.out.println ("zoradené pole:" + Arrays.ToString (ARR));
int [] arr2 ={4, 9, 4, 4, 1, 9, 4, 4, 9, 4, 4, 1, 4};
System.out.println ("Original Array:" + Arrays.ToString (ARR2));
Quicksort3way (ARR2, 0, ARR2.Length - 1);
System.out.println ("zoradené pole:" + Arrays.ToString (ARR2));
}
}
`` `
Kľúčové vylepšenia a vysvetlenia:
* Clear Commens: Kód je silne komentovaný a vysvetľuje účel každej sekcie a premennej. Vďaka tomu je oveľa jednoduchšie porozumieť logike.
* `oddiel3way` funkcia: Táto funkcia je srdcom algoritmu. Rozdeľuje pole do troch častí:
* Prvky menšie ako pivot (`arr [nízka ... lt-1]`)
* Prvky rovnajúce sa Pivot (`arr [Lt ... gt]`)
* Prvky väčšie ako pivot (`arr [gt+1 ... vysoký]`)
* `lt` a` gt` indexy: `lt 'poukazuje na index posledného * prvku, ktorý je * menší ako * Pivot. `Gt` poukazuje na index prvku * prvého *, ktorý je * väčší ako * pivot. To je rozhodujúce pre správne umiestnenie prvkov počas rozdelenia.
* `i` index: Index `i's sa používa na prechádzanie poľa zľava doprava. Logika v slučke „Zatiaľ čo“ je veľmi dôležitá:
* `art [i]
* `arm [i]> pivot`: Swap `arr [i]` s `arr [gt]`, zníženie `gt` *, ale nezvyšujte sa` i` *. Dôvod, prečo sa nezvýšime `i`, je to, že prvok, ktorý bol vymenený do` arr [i] `sprava (` arr [gt] `) je nespracovaný prvok * a my ho musíme skontrolovať v ďalšej iterácii.
* `arr [i] ==Pivot`: Prírastok `Presunúť sa na ďalší prvok.
* správne rekurzívne hovory: Funkcia `Quicksort3way` robí rekurzívne hovory na podskupinách vľavo od` lt` a napravo od `Gt`. Prvky medzi `lt` a` gt` sú rovnaké ako otočenie a sú už v ich správnych zoradených pozíciách, takže ich nemusia ďalej triediť.
* `swap` funkcia: Pomocná funkcia na vymenenie prvkov v poli.
* `Main` Funkcia s príkladmi: Funkcia „Main“ poskytuje príklad príkladu, ktorá demonštruje účinnosť algoritmu na poliach s mnohými duplikátmi hodnoty. Zahŕňa príklad, ktorý ukazuje zlepšenie výkonu s duplicitnými hodnotami.
* Základný prípad: `If (nízka> =vysoká)` podmienka správne spracováva základný prípad rekurzie, keď má čiara nula alebo jeden prvok. Tým sa zabráni výnimkám „StackOverflowerRor“.
* Clarity and Readinability: Názvy premenných sú opisné (`LT` za menej ako,` gt` pre väčšie ako, `i` pre index) a kód je dobre formovaný pre čitateľnosť.
* správnosť: Táto verzia je oveľa pravdepodobnejšie, že bude správna a efektívna ako predchádzajúce verzie. Správne spracováva okrajové prípady a vyhýba sa bežným chybám, ktoré sa môžu vyskytnúť pri implementácii 3-cestného Quicksort.
Ako rieši výhody 3-cestného QuickSort:
Pri riešení polí, ktoré obsahujú mnoho duplicitných prvkov, sa objavuje hlavná výhoda 3-cestnej Quicksort. V štandardnom Quicksort (obojsmerný oddiel) sa duplicitné prvky v porovnaní s čapom umiestnia iba na jednu stranu oddielu, čo bude mať za následok nevyvážené oddiely a potenciálne `o (n^2)` výkon v najhoršom prípade (napr. Keď je pole už triedená a obsahuje mnoho duplicitných hodnôt).
3-cestné Quicksort však efektívne zoskupuje všetky prvky rovnajúce sa čapom v strednej oddiele (`arr [Lt ... gt]`). To zaisťuje, že rekurzívne hovory sa uskutočňujú v menších čiastkových čias, * s výnimkou * sekcie s prvkami rovnajúcimi sa čapom. To výrazne zlepšuje výkon, čo prináša časovú zložitosť bližšie k `o (n log n)` aj s mnohými duplikátmi prvkov. Druhý príklad vo funkcii „Main“ to demonštruje.
Táto implementácia priamo rieši tieto výhody. Logika oddielu je navrhnutá tak, aby efektívne zoskupovala prvky rovnajúce sa čapom, čo bráni skresleným oddielom a udržiavajú dobrý výkon, aj keď existuje veľké množstvo duplikátov.