Algoritmien lajittelu Java - Erityyppiset Java-lajittelualgoritmit

• Johdanto Java-algoritmien lajitteluun

Johdanto Java-algoritmien lajitteluun

Tietojen lajittelu tiettyyn järjestykseen, usein matriisimaisissa puitteissa, on järjestettävä ne. Voit käyttää erilaisia ​​järjestysvaatimuksia, suosittuja ovat numeroiden lajittelu pienimmästä suurimpaan tai päinvastoin tai leksikografisesti lajittelumerkit. Käytämme erilaisia ​​algoritmeja tehottomista mutta intuitiivisista vaihtoehdoista tehokkaisiin algoritmeihin, jotka toteutetaan tehokkaasti Java: lla ja muilla kielillä, jos olet kiinnostunut lajittelun toimivuudesta.

Erilaisia ​​Java-lajittelualgoritmeja

Lajittelualgoritmeja on erilaisia ​​ja kaikki eivät ole yhtä tehokkaita. Jotta voisimme vertailla niitä ja nähdä, mitkä suorittavat parhaiten, analysoimme heidän aikansa monimutkaisuutta.

1. Lisäyslajittelu
2. Kuplalajittelu
3. Valinta Lajittele
4. Yhdistä lajittelu
5. Kekojärjestäminen

1. Lisäyslajittelu

Lisäyslajittelun takana oleva käsite jakaa alueen alalajeihin, jotka on lajiteltu ja lajittelematon. Luokiteltu osa on keston 1 alussa ja vastaa taulukon ensimmäistä (vasenta puolta) komponenttia. Me siirrymme taulukon läpi ja laajennamme taulukon luokiteltua osaa yhdellä komponentilla jokaisen iteraation aikana. Laajentuessamme sijoitamme tuoreen elementin lajiteltuun alaryhmään. Teemme tämän siirtämällä kaikki elementit oikealle, kunnes huomaa, että meidän ei tarvitse muuttaa ensimmäistä komponenttia. Kun lihavoitu osa lajitellaan nousevassa järjestyksessä, esimerkiksi seuraavassa taulukossa, se tapahtuu:

1. 3 5 7 8 4 2 1 9 6: Harkitse 4 ja lisää tämä juuri tarvitsemme. Olemme siirtyneet vuodesta 8> 4
2. 2. 3 5 7 x 8 2 1 9 6
3. 3 5 x 7 8 2 1 9 6
4. 3 x 5 7 8 2 1 9 6
5. 3 4 5 7 8 2 1 9 6

Koodi:

public class InsertionSortEx (
public static void insertionSort(int() arr) (
for (int x = 1; x < arr.length; x++) (
int current = arr(x);
int y = x - 1;
while(y >= 0 && current < arr(y)) (
arr(y+1) = arr(y);
y--;
)
arr(y+1) = current;
)
)
public static void main(String a())(
int() arr1 = (3, 5, 7, 8, 4, 2, 1, 9, 6);
System.out.println("Before Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
System.out.println();
insertionSort(arr1);//sorting array using insertion sort
System.out.println("After Insertion Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
)
)

lähtö:

Tämän menetelmän mukaisesti yksi komponentti laajensi lajiteltua osaa, meillä on nyt viisi neljän elementin sijasta. Jokainen iterointi tekee tämän ja koko taulukko lajitellaan loppuun mennessä.

Huomaa: Tämä johtuu siitä, että meidän on siirrettävä koko luokiteltu luettelo yksi kerrallaan jokaisessa iteraatiossa, joka on O (n). Jokaisen taulukon jokaiselle komponentille meidän on tehtävä tämä, mikä tarkoittaa, että se on O (n 2) -rajoitettu.2.

2. Kuplalajittelu

Jos kupla ei ole vaaditussa järjestyksessä, se toimii korvaamalla vierekkäiset komponentit. Tätä toistetaan, kunnes kaikki komponentit ovat kunnossa taulukon alusta. Tiedämme, että jos onnistumme tekemään koko iteraation ilman vaihtosopimuksia, kaikki kohteet vierekkäisiin elementteihin verrattuna olivat toivotussa järjestyksessä ja laajentaen koko joukko. Bubble Sort -algoritmin syynä on, että numerot, kuten "kuplivat" maahan. "Jos tietyn määrän jälkeen käydään uudelleen ilmentymän läpi (4 on hyvä esimerkki), huomaat, että luku hitaasti siirtyy oikealle.

Vaiheet kuplan lajitteluun ovat seuraavat:

1. 4 2 1 5 3: Tässä kaksi ensimmäistä numeroa eivät ole oikeassa järjestyksessä, joten meidän on järjestettävä molemmat numerot.
2. 2 4 1 5 3: Sen jälkeen myös seuraava numeropari ei ole oikeassa järjestyksessä. Joten lajittelu tapahtuu uudelleen.
3. 2 1 4 5 3: Nämä kaksi ovat oikeassa järjestyksessä, 4 <5, joten niitä ei tarvitse vaihtaa.
4. 2 1 4 5 3 : Jälleen kerran meidän on vaihdettava oikeaan järjestykseen.
5. 2 1 4 3 5: Tässä on tuloksena oleva taulukko yhden iterauksen jälkeen.
6. Meidän on toistettava tämä prosessi uudelleen, kunnes numerot ovat oikeassa järjestyksessä.

Koodi:

public class BubbleSortExample (
public static void bubbleSort(int() arr) (
int n = arr.length;
int tmp = 0;
for(int x=0; x < n; x++)(
for(int y=1; y < (nx); y++)(
if(arr(y-1) > arr(y))(
//swap elements
tmp = arr(y-1);
arr(y-1) = arr(y);
arr(y) = tmp;
)
)
)
)
public static void main(String() args) (
int arr() =(4, 2, 1, 5, 3);
System.out.println("Array Before Bubble Sort");
for(int x=0; x < arr.length; x++)(
System.out.print(arr(x) + " ");
)
System.out.println();
bubbleSort(arr);
System.out.println("Array After Bubble Sort");
for(int x=0; x < arr.length; x++)(
System.out.print(arr(x) + " ");
)
)
)

lähtö:

Huomaa: Se olisi saattanut päätyä äärettömään silmukkaan, jos käytin a (i)> = a (i + 1), koska tämä yhteys olisi edelleen voimassa vastaavien komponenttien kanssa ja vaihtaa siten ne aina elementistä toiseen.

3. Valintalajittelu

Valintalajittelu jakaa taulukon ryhmään luokituksia, joita ei ole lajiteltu. Tällä kertaa lajittelualijärjestelmä muodostetaan kuitenkin lisäämällä lajitellun ryhmän loppuun lajittelemattoman alaryhmän minimielementti vaihtamalla:

1. 3 5 1 2 4
2. 1 5 3 2 4
3. 1 2 3 5 4
4. 1 2 3 5 4
5. 1 2 3 4 5
6. 1 2 3 4 5

Koodi:

public class SelectionSortEx (
public static void selectionSort(int() arr)(
for (int x = 0; x < arr.length - 1; x++)
(
int indx = x;
for (int y = x + 1; y < arr.length; y++)(
if (arr(y) < arr(indx))(
indx = y;
)
)
int smallNumber = arr(indx);
arr(indx) = arr(x);
arr(x) = smallNumber;
)
)
public static void main(String a())(
int() arr1 = (3, 5, 1, 2, 4);
System.out.println("Before Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
System.out.println();
selectionSort(arr1);
System.out.println("After Selection Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
)
)

lähtö:

Huomaa: Minimi on O (n) taulukon koosta, koska kaikki komponentit on tarkistettava. Jokaiselle taulukon elementille on löydettävä minimimäärä ja koko prosessi O (n 2) rajattava.

4. Yhdistä lajittelu

Yhdistämislajittelu hyödyntää rekursiota jakaa- ja valloitusmenetelmän ongelman korjaamiseksi aiemmin kuvattuja algoritmeja tehokkaammin.

Tämä puu näyttää kuinka rekursiiviset puhelut toimivat. Alas nuolella merkityt taulukot ovat taulukot, joille me kutsumme toimintoa sulauttaessamme ylöspäin osoittavat nuolet. Seuraa sitten nuolta puun reunaan ja palaa sitten takaisin ja yhdistät. Meillä on 3 5 3 1 alue, joten jaamme sen 3 5 4 ja 2 1. Jaotimme ne osiinsa lajitellakseen ne. Aloitamme fuusioinnin ja lajittelun heille, kun menemme alaosaan.

Koodi:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class MergeSort (
static void merge(int() array, int lowval, int midval, int highval)(
int x, y, k;
int() c= new int(highval-lowval+1);
k = 0;
x=lowval;
y=midval+1;
while(x<=midval && y<=highval)(
if(array(x)<=array(y))(
c(k++) = array(x++);
)
else(
c(k++) = array(y++);
)
)
while(x<=midval)(
c(k++) = array(x++);
)
while(y<=highval)(
c(k++) = array(y++);
)
k=0;
for(x = lowval; x<=highval; x++)(
array(x) = c(k++);
)
)
static void mergeSort(int() array, int lowval, int highval)(
if(highval-lowval+1>1)(
int midval = (lowval+highval)/2;
mergeSort(array, lowval, midval);
mergeSort(array, midval+1, highval);
merge(array, lowval, midval, highval);
)
)
public static void main(String() args) (
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
int size;
System.out.println("Enter the array");
try (
size = Integer.parseInt(r.readLine());
) catch (Exception e) (
System.out.println("Please Enter valid Input");
return;
)
int() array = new int(size);
System.out.println("Enter array elements");
int x;
for (x = 0; x < array.length; x++) (
try (
array(x) = Integer.parseInt(r.readLine());
) catch (Exception e) (
System.out.println("An error Occurred");
)
)
System.out.println("After Sorting");
System.out.println(Arrays.toString(array));
mergeSort(array, 0, array.length-1);
System.out.println("Before Merge Sorting");
System.out.println(Arrays.toString(array));
)
)

Tässä ohjelmassa olemme pyytäneet käyttäjää syöttämään syötteen. Lähtö on lajiteltu järjestyksessä käyttäjän syötteiden perusteella.

lähtö:

5. Heap Sort

Ensin on tiedettävä kehys, jolla Heapsort toimii - kasa - ymmärtääksesi miksi se toimii. Puhumme erityisesti binaarikasasta, mutta voit yleistää tämän myös muille kasarakenteille. Kasa on puu, joka täyttää kasan ominaisuuden, eli että kaikilla sen lapsilla on suhteita kuhunkin solmuun. Kasa on myös melkein valmis. Lähes täydellisessä d-syvyyden binaarissa on d-1-alaosa, jolla on sama juuri, ja jokaisella solmulla on täysi, vasen alaosa, vasemman laskevan.

Toisin sanoen, saat pienemmän ja pienemmän määrän (min-kasa) tai suuremman ja suuremman (enimmäis-kasa) liikuttaessa puusta alas. Tässä on enimmäismäärä:

1. 6 1 8 3 5 2 4 : Tässä molemmat lapset ovat pienempiä kuin vanhempi, joten meidän ei tarvitse muuttaa mitään.
2. 6 1 8 3 5 2 4: Tässä, 5> 1, meidän on vaihdettava ne. Meidän täytyy kasvaa 5.
3. 6 5 8 3 1 2 4: Molemmat lasten lukumäärät ovat pienempiä, kaikki pysyvät samana.
4. 6 5 8 3 1 2 4: Tässä, 8> 6, joten meidän pitäisi vaihtaa ne.
5. 8 5 6 3 1 2 4: Tämän toiston jälkeen saamme tämän tuloksen.

Kun olet toistanut tämän prosessin uudelleen, saamme seuraavat tulokset:

• 8 5 6 3 1 2 4

1. 4 5 6 3 1 2 8 : Vaihtaminen
2. 6 5 4 3 1 2 8 : Heapify
3. 2 5 4 3 1 6 8 : Vaihtaminen
4. 5 2 4 2 1 6 8 : Heapify
5. 1 2 4 2 5 6 8 : Vaihtaminen

Koodi:

public class HeapSort
(
public void sort(int arr())
(
int n = arr.length;
for (int x = n / 2 - 1; x >= 0; x--)
heapify(arr, n, x);
for (int x=n-1; x>=0; x--)
int tmp = arr(0);
arr(0) = arr(x);
arr(x) = tmp;
heapify(arr, x, 0);
)
)
void heapify(int arr(), int n, int x)
(
int largest = x;
int L = 2*x + 1;
int r = 2*x + 2;
if (L arr(largest))
largest = L;
if (r arr(largest))
largest = r;
if (largest != x)
(
int swap = arr(x);
arr(x) = arr(largest);
arr(largest) = swap;
heapify(arr, n, largest);
)
)
static void printArray(int arr())
(
int n = arr.length;
for (int x=0; x System.out.print(arr(x)+" ");
System.out.println();
)
public static void main(String args())
(
int arr() = (6, 1, 8, 3, 5, 2, 4);
int n = arr.length;
System.out.println("Before Sorting:");
printArray(arr);
HeapSort ob = new HeapSort();
ob.sort(arr);
System.out.println("After Heap Sorting:");
printArray(arr);
)
) public class HeapSort
(
public void sort(int arr())
(
int n = arr.length;
for (int x = n / 2 - 1; x >= 0; x--)
heapify(arr, n, x);
for (int x=n-1; x>=0; x--)
int tmp = arr(0);
arr(0) = arr(x);
arr(x) = tmp;
heapify(arr, x, 0);
)
)
void heapify(int arr(), int n, int x)
(
int largest = x;
int L = 2*x + 1;
int r = 2*x + 2;
if (L arr(largest))
largest = L;
if (r arr(largest))
largest = r;
if (largest != x)
(
int swap = arr(x);
arr(x) = arr(largest);
arr(largest) = swap;
heapify(arr, n, largest);
)
)
static void printArray(int arr())
(
int n = arr.length;
for (int x=0; x System.out.print(arr(x)+" ");
System.out.println();
)
public static void main(String args())
(
int arr() = (6, 1, 8, 3, 5, 2, 4);
int n = arr.length;
System.out.println("Before Sorting:");
printArray(arr);
HeapSort ob = new HeapSort();
ob.sort(arr);
System.out.println("After Heap Sorting:");
printArray(arr);
)
)

lähtö:

Voit tarkastella sitä kuvaajan pistetasolta, vasemmalta oikealle. Tässä saavutimme sen, että kun taulukossa on k: nnen komponentin, sen lasten sijainti on 2 \ * k + 1 ja 2 \ * k + 2 (olettaen, että indeksointi alkaa arvosta 0). Sinä voit seurata tätä. Vanhemman sijainti on aina (k-1) / 2 k: nnen komponentin kohdalla. Voit helposti maksimoida minkä tahansa alueen, koska tiedät sen. Tarkista, onko jokin sen lapsista alempi kuin kunkin komponentin. Jos näin on, muodosta pari yksi vanhemmista ja toista tämä vaihe rekursiivisesti vanhemman kanssa.

Huomaa: Koska silmukoiden toistaminen koko taulukossa, tekee heapSort: sta (ilmeisesti O (N)), se tekisi Heapsort O: n kokonaisuuden (nlog n). Heapsortilla on paikalla -tyyppi, mikä tarkoittaa, että se vaatii O ( 1) enemmän tilaa kuin Merge Sort, mutta sillä on joitain haittoja, kuten kovat rinnat.

Johtopäätös - Algoritmien lajittelu Java-sovelluksessa

Lajittelu on erittäin yleinen menetelmä tietojoukkojen kanssa, joko jatkoanalyysejä varten, nopeuttamalla hakua tehokkaammilla algoritmeilla, jotka perustuvat lajiteltuihin tietoihin, tietojen suodattamiseen jne. Lajittelu on monien kielten hyväksymiä ja usein käyttöliittymät peittävät ohjelmoijan tekemän toiminnan.

Suositellut artikkelit

Tämä on opas algoritmien lajitteluun Java-sovelluksessa. Tässä keskustellaan Java-tyyppisistä lajittelutavoista niiden algoritmien kanssa. Voit myös käydä läpi muiden ehdottamiemme artikkeleidemme -

1. Yhdistä lajittelualgoritmit Java-sovellukseen
2. JComboBox Java
3. StringBuffer Java -sovelluksessa
4. JTextField Java
5. Heap Sort Pythonissa
6. Pikalajittelualgoritmit Java-sovelluksessa
7. Täydellinen opas lajitteluun C # -merkinnällä esimerkkeinä
8. Algoritmien lajittelu JavaScript
9. Opas esimerkkeihin C ++ -algoritmista
10. Täydellinen opas algoritmien lajitteluun Pythonissa