Bubble Sordi algoritm sisse Java: massiivi sortimisprogramm ja näide

Mis on Bubble Sorteerida?

Bubble Sort on lihtne võrdlusel põhinev sortimisalgoritm, mis võrdleb massiivi esimest elementi järgmisega. Kui massiivi praegune element on arvuliselt suurem kui järgmine, vahetatakse elemendid. Samuti läbib algoritm kogu massiivi elemendi.

Algoritm on saanud oma nime selle järgi, kuidas sorteerimata piirkonna suurim väärtus tõuseb järk-järgult oma lõpppositsioonile, sarnaselt mulli tõusuga veepinnale. Pärast esimest täielikku läbimist hõivab suurim element viimase indeksi. Pärast teist läbimist lukustatakse suuruselt teine ​​element oma kohale ja protsess kordub, kuni massiiv on täielikult järjestatud.

Selles artiklis loome Java rakendamiseks mõeldud programm BubblSorteeri. Kontrolli koodi väljundit, mis aitab sul programmi loogikast aru saada, ning seejärel vaata üle optimeeritud versiooni ja sellele järgneva keerukusanalüüsi.

Kuidas BubblKas sortimisalgoritm töötab?

BubblSorteerimine toimib massiivi korduvate käikude kaudu. Iga käik liigub esimesest indeksist hetkel sortimata piirkonna lõppu, võrreldes naaberväärtusi ja vahetadesping neid alati, kui need vales järjekorras ilmuvad. Kuna suurim allesjäänud väärtus liigub alati sortimata piirkonna parempoolsesse serva, kahaneb piirkond iga läbimise järel täpselt ühe positsiooni võrra.

Kogu protsessi saab jagada neljaks korduvaks sammuks:

1. Võrdlema: Võrdle elementi indeksiga j-1 elemendiga indeksiga j.
2. Vahetus: Kui vasakpoolne element on suurem kui parempoolne element, vahetage need kaks väärtust ajutise muutuja abil.
3. Avanss: Liigu ühe positsiooni võrra paremale ja korda, kuni jõutakse sortimata piirkonna lõpuni.
4. Korda: Alusta uut käiku piirkonna peal, mis on ühe elemendi võrra lühem, ja lõpeta pärast n-1 käiku või kui käik ei teosta vahetusi.

Allolev tabel traces näidismassiiv {860, 8, 200, 9}, mida kasutatakse programmis hiljem sellel lehel. See näitab täpselt, milline väärtus iga käigu lõpus oma lõpppositsioonile stabiliseerub.

Pane tähele, et kolmas käik teostab võrdluse, aga mitte vahetust. Optimeeritud rakendus tuvastab selle tingimuse ja peatab kohe, mis on selle algoritmi kõige väärtuslikum täiustus.

BubblSorteerimisalgoritmi pseudokood

Enne kirjutamist Java süntaksi puhul aitab see loogikat väljendada keeleneutraalses pseudokoodis. Allolev versioon sisaldab varajase väljumise lippu, seega hõlmab see nii klassikalist kui ka optimeeritud käitumist.

procedure bubbleSort(array A, integer n)
    for i from 0 to n - 2 do
        swapped := false
        for j from 1 to n - i - 1 do
            // compare the adjacent pair
            if A[j - 1] > A[j] then
                swap A[j - 1] and A[j]
                swapped := true
            end if
        end for
        // no swap in a full pass means the array is sorted
        if swapped = false then
            break
        end if
    end for
end procedure

Välimine tsükkel kontrollib läbimiste arvu ja sisemine tsükkel kontrollib ühe läbimise jooksul tehtavaid võrdlusi. Sisemise tsükli ülempiir on n – i – 1, kuna viimased i positsioonid hoiavad juba oma lõppväärtusi.

Java Rakendatav programm Bubble Sorteeri

Järgnev programm sorteerib täisarvude massiivi kasvavas järjekorras. Tsüklite sisse on meelega jäetud lisaprindilauseid, sest pass-by-pass lugemine trace on algajale kiireim viis aru saada, kuidas vahetustehingud kogunevad.

package com.guru99;

public class BubbleSort {

    public static void main(String[] args)
    {
        int arr[] = {860, 8, 200, 9};

        System.out.println("---Array BEFORE Bubble Sort---");

        printArray(arr);

        bubbleSort(arr); //sorting array elements using bubble sort

        System.out.println("---Array AFTER Bubble Sort---");

        printArray(arr);

    }

    static void bubbleSort(int[] array)
    {
        int n = array.length;
        int temp = 0;
        for(int i = 0; i < n; i++) // Looping through the array length
        {   System.out.println("Sort Pass Number " + (i + 1));
            for(int j = 1; j < (n - i); j++)
            {
                System.out.println("Comparing " + array[j - 1] + " and " + array[j]);
                if(array[j - 1] > array[j])
                {
                    //swap elements
                    temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                    System.out.println(array[j] + " is greater than " + array[j - 1]);
                    System.out.println("Swapping Elements: New Array After Swap");
                    printArray(array);
                }

            }
        }

    }

    static void printArray(int[] array){

        for(int i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + " ");
        }
        System.out.println();

    }
}

Väljund:

---Array BEFORE Bubble Sort---
860 8 200 9
Sort Pass Number 1
Comparing 860 and 8
860 is greater than 8
Swapping Elements: New Array After Swap
8 860 200 9
Comparing 860 and 200
860 is greater than 200
Swapping Elements: New Array After Swap
8 200 860 9
Comparing 860 and 9
860 is greater than 9
Swapping Elements: New Array After Swap
8 200 9 860
Sort Pass Number 2
Comparing 8 and 200
Comparing 200 and 9
200 is greater than 9
Swapping Elements: New Array After Swap
8 9 200 860
Sort Pass Number 3
Comparing 8 and 9
Sort Pass Number 4
---Array AFTER Bubble Sort---
8 9 200 860

Code selgitus: . mullide sortimine meetod saab massiivi viitena, seega näeb kutsuja sorteeritud tulemust ilma tagastusväärtuseta. Muutuja temp hoiab kolme rea vahetuse ajal ühte väärtust, mistõttu algoritm vajab ainult O(1) lisamälu. Avaldis n – i Sisemise tsükli tingimus garanteerib, et juba sorteeritud positsioone sabaosas ei külastata enam kunagi uuesti.

Optimaalne Bubble Sorteeri programm sisse Java

Ülaltoodud programm teeb alati n-1 käiku, isegi kui massiiv sorteeritakse varakult. Ühe Boole'i ​​lipu lisamine parandab selle ebaefektiivsuse. Kui täielik käik lõpeb ilma ühegi vahetuseta, on massiivi sorteerimine garanteeritud ja välimine tsükkel saab kohe peatuda.

package com.guru99;

public class OptimizedBubbleSort {

    public static void main(String[] args) {
        int arr[] = {5, 12, 33, 47, 58};
        bubbleSort(arr);
        System.out.println(java.util.Arrays.toString(arr));
    }

    static void bubbleSort(int[] array) {
        int n = array.length;
        int passes = 0;
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;
            for (int j = 1; j < n - i; j++) {
                if (array[j - 1] > array[j]) {
                    int temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                    swapped = true;
                }
            }
            passes++;
            // Early exit: the array is already sorted
            if (!swapped) {
                break;
            }
        }
        System.out.println("Passes executed: " + passes);
    }
}

Väljund:

Passes executed: 1
[5, 12, 33, 47, 58]

Sisendmassiiv oli juba sorteeritud, seega optimeeritud versioon valmis ühe, mitte nelja käiguga. Peaaegu sorteeritud andmete puhul muudab see muudatus ruutkoormuse peaaegu lineaarseks, mis on peamine põhjus Bubbl„Sort” ilmub ikka veel aeg-ajalt päriskoodis.

Ajaline keerukus ja ruumiline keerukus Bubble Sorteeri

Keerukus kirjeldab, kuidas sisendi suuruse kasvades jooksuaeg kasvab. BubblSorteerides on optimeerimata versioonis võrdluste arv fikseeritud väärtusele n(n-1)/2, mis paigutab selle kindlalt ruutklassi.

Kuna iga vahetus toimub algse massiivi sees ja kasutatakse ainult ühte ajutist muutujat, BubblSorteerimine on kohapealne algoritm O(1) abiruumiga. See on ka stabiilne sortimine, mis tähendab, et kaks sama võtmega kirjet säilitavad pärast sortimist oma algse suhtelise järjestuse.

Eelised ja puudused Bubble Sorteeri

Mõlema poole mõistmine aitab teil otsustada, millal on algoritm vastuvõetav valik ja millal see tuleks asendada.

Eelised

• Lihtsus: Loogika mahub umbes kümnesse ritta, mis teeb intervjuu tingimustes õigesti kirjutamise lihtsaks.
• Kohapealne toimimine: Abimassiivi ei eraldata, seega mälukasutus ei kasva sisendi suurusega.
• Stabiilsus: Võrdsed võtmed säilitavad oma algse järjekorra, mis on oluline kirjete sortimisel teisese välja järgi.
• Varajane väljumise tuvastamine: Vahetatud lipp identifitseerib juba ühe korraga sorteeritud massiivi.

Puudused

• Ruutkasv: 10 000 elemendi sorteerimine nõuab halvimal juhul ligi 50 miljonit võrdlust.
• Liigne kirjutab: Algoritm teeb palju rohkem vahetusi kui valiku sortimine, mis on mälukulukas ja aeglaste kirjutamisoperatsioonidega.
• Halb skaleeritavus: Tootmiskoormustes eelistatakse peaaegu alati kiirsortimist, ühendamissortimist või sisseehitatud Arrays.sort-meetodit.

Bubble-sortimine vs. muu sortimine Algorithms

Allolev tabel võrdleb BubblSorteeri algajatele mõeldud sorteerimistehnikatega, et näeksid täpselt, kus igaüks võidab.

BubblSorteerimisel ja sisestussortimisel on sama lineaarne parim juhtum, kuid sisestussortimine teeb osaliselt sorteeritud andmetel vähem vahetusi. Valiksortimine teeb alati täpselt n-1 vahetust, mis teeb selle parimaks.tracatiivne, kui kirjutamine on kulukas, kuigi see ohverdab stabiilsust. Massiivi puhul, mis on suurem kui paar sada elementi, on õige valik Quicksort või Heap Sort.

Kui olete siin kasutatavate massiivi läbimismustritega harjunud, esineb sama tsükli struktuur paljudes klassikalistes harjutustes, näiteks Fibonacci seeria Java ja Java palindroomi programm. Revvaatamine Java massiivid ja seda laiem Java juhendaja tugevdab põhialuseid, millele see algoritm tugineb.

KKK