Johdanto Java-nopeiden lajittelualgoritmien käyttöön

Nopea lajittelu Java-järjestelmässä, joka tunnetaan myös nimellä osionvaihtolaji, on jako- ja valloitus-lajittelualgoritmi. Pikalajittelu on hyvä esimerkki algoritmista, joka käyttää CPU-välimuistia parhaalla mahdollisella tavalla, koska se jakaa ja valloittaa luonteensa. Quicksort-algoritmi on yksi käytetyimmistä lajittelualgoritmeista, etenkin suurten luetteloiden lajittelua varten, ja suurin osa ohjelmointikieleistä on toteuttanut sen. Quicksort-algoritmissa alkuperäinen data jaetaan kahteen osaan, jotka lajitellaan erikseen ja yhdistetään sitten lajitellun datan tuottamiseksi.

Katsotaanpa, että taulukko (8, 6, 3, 4, 9, 2, 1, 7) on lajiteltava pikalajittelulla.

Vaiheet nopeiden lajittelualgoritmien toteuttamiseen

1. Valitse taulukosta elementti nimeltä pivot. Yleensä keskimmäinen elementti valitaan nivelksi. Otetaanpa 4: tä kääntölaitteena.

2. Järjestä taulukko kahteen osaan siten, että kääntöpistettä pienemmät elementit tulevat ennen kääntöpistettä ja kääntöpistettä suuremmat elementit näkyvät kääntöpisteen jälkeen. Seuraavat vaiheet suoritetaan:

  • Valitse vasemmanpuoleisin elementti eli 8, koska 4 on nivel ja 8 on enemmän kuin 4, 8 on siirrettävä 4: n oikealle puolelle. Oikealta vasemmalta jätämme 7, koska se on suurempi kuin 4 ja valitse 1 vaihtoa varten 8: lla, siis taulukon vaihtamisen jälkeen taulukosta tulee: 1, 6, 3, 4, 9, 2, 8, 7
  • Valitse seuraava vasen elementti eli 6, koska 4 on nivel ja 6 on enemmän kuin 4, 6 on siirrettävä 4: n oikealle, oikealta puolelta jätämme 7, 8, koska ne ovat yli 4 ja valitse 2 vaihtamiseksi 6: lla, joten taulukon vaihtamisen jälkeen seuraa: 1, 2, 3, 4, 9, 6, 8, 7
  • Nyt kun kaikki nivelten vasemmalla puolella olevat elementit ovat pienempiä kuin nivel ja kaikki nivelten oikealla puolella olevat elementit ovat suurempia kuin nivel, tehdään 4: n kanssa nivel.

3. Suorita rekursiivisesti vaiheet 1 ja 2 vasemmalle alaryhmälle (taulukko, jonka elementtejä on vähemmän kuin nivel) ja oikealle alaryhmälle (taulukko, jonka elementtejä on enemmän kuin nivel). Jos taulukko sisältää vain yhden tai nolla elementtiä, taulukkoa pidetään valikoimana.

Ohjelma nopeiden lajittelualgoritmien toteuttamiseen

Tässä on Java-ohjelma, jolla lajitellaan kokonaislukumäärä nopean lajittelualgoritmin avulla.

Koodi:

import java.lang.*;
import java.util.*;
public class Main (
private int array();
private int length;
public void sort(int() inputArrayArr) (
if (inputArrayArr == null || inputArrayArr.length == 0) (
return;
)
this.array = inputArrayArr;
length = inputArrayArr.length;
performQuickSort(0, length - 1);
)
private void performQuickSort(int lowerIndex, int higherIndex) (
int i = lowerIndex;
int j = higherIndex;
// calculate pivot number
// middle element taken as pivot
int pivot = array(lowerIndex+(higherIndex-lowerIndex)/2);
// Divide into two subarrays
while (i <= j) (
/**
* In each iteration, find an element from left side of the pivot which
* is greater than the pivot value, and also find an element
* From right side of the pivot which is less than the pivot value. Once the search
* is complete, we exchange both elements.
*/
while (array(i) < pivot) (
i++;
)
while (array(j) > pivot) (
j--;
)
if (i <= j) (
swapNumbers(i, j);
//move index to next position on both sides
i++;
j--;
)
)
// call performQuickSort() method recursively
if (lowerIndex < j)
performQuickSort(lowerIndex, j);
if (i < higherIndex)
performQuickSort(i, higherIndex);
)
private void swapNumbers(int i, int j) (
int temp = array(i);
array(i) = array(j);
array(j) = temp;
)
public static void main(String args())(
Main quickSort = new Main();
int() inputArray = (8, 6, 3, 4, 9, 2, 1, 7);
quickSort.sort(inputArray);
System.out.println("Sorted Array " + Arrays.toString(inputArray));
)
)

lähtö:

Nopeiden lajittelualgoritmien edut

Seuraavat ovat nopean lajittelualgoritmin etuja:

  • Erinomainen viitepaikka : Viitepaikka on prosessorin kyky päästä samaan muistipaikkaan toistuvasti lyhyen ajanjakson ajan. Nopea lajittelu Java-palvelussa tarjoaa erinomaisen referenssialueen erittäin pienen välimuistin puutteen vuoksi, mikä nykyaikaisissa arkkitehtuureissa on kriittinen suorituskyvyn kannalta.
  • Pikalajittelu on rinnakkaista: Kun taulukon osioinnin pienemmille alueille aloitusvaihe on valmis, kaikki yksittäiset alaryhmät voidaan lajitella itsenäisesti rinnakkain. Tästä syystä nopea lajittelu toimii paremmin.

Pikalajittelun monimutkaisuusanalyysi

Quicksort on nopea ja häntä rekursiivinen algoritmi, joka toimii jakaa ja valloita -periaatteella. Tässä on sen monimutkaisuusanalyysi parhaassa, keskimääräisessä ja pahimmassa tapauksessa:

  • Paras tapauksen monimutkaisuus: Jos taulukko tai luettelo sisältää n elementtiä, ensimmäinen ajo tarvitsee O (n). Nyt kahden jäljelle jäävän alaryhmän lajittelu vie 2 * O (n / 2). Tämä päättelee O (n logn) monimutkaisuus parhaassa tapauksessa.
  • Tapausten keskimääräinen monimutkaisuus: Pikatoiminnan keskimääräinen tapaus on O (n log n).
  • Pahimman tapauksen monimutkaisuus: Ensimmäisen tai viimeisen valitseminen aiheuttaisi huonoimmassa tapauksessa lähes lajiteltujen tai melkein käänteisesti lajiteltujen tietojen suorituskyvyn. Pikalajittelu suorittaa pahimmassa tapauksessa O (n 2).

Java, Arrays. Lajittelu () -menetelmä käyttää pikalajittelualgoritmia taulukon lajitteluun.

Suositellut artikkelit

Tämä on opas Java-sovellusten pikalajittelualgoritmeihin. Tässä keskustellaan vaiheista nopean lajittelualgoritmin toteuttamiseksi, eduista ja monimutkaisuusanalyysistä Java-ohjelmassa yhdessä ohjelman kanssa. Voit myös katsoa seuraavia artikkeleita saadaksesi lisätietoja -

  1. Lisäys Lajittele Java
  2. do-while-silmukka Java-sovelluksessa
  3. JComponent Java
  4. Ruudut Java
  5. Vaihtaminen PHP: ssä
  6. Lajittelu C #
  7. Lajittelu Pythonissa
  8. C ++ -algoritmi | Esimerkkejä C ++ -algoritmista

Luokka:

Ohjelmistokehitys