Tip:
Highlight text to annotate it
X
[Powered by Google Translate] [BUBBLE Sortera]
[JACKSON Steinkamp Harvard University]
[DETTA ÄR CS50. CS50TV]
Bubble Sortera är ett exempel på en sorteringsanordning algoritm -
det är ett förfarande för sortering av en uppsättning element i
stigande eller fallande ordning.
Till exempel, om du ville sortera en array bestående av siffrorna
[3, 5, 2, 9], skulle en korrekt tillämpning av Bubble Sortera tillbaka
sorterade arrayen [2, 3, 5, 9] i stigande ordning.
Nu ska jag förklara i pseudokod hur algoritmen fungerar.
>> Låt oss säga att vi sorterar en lista på 5 heltal - 3, 2, 9, 6 och 5.
Algoritmen börjar med att titta på de första två delarna, 3 och 2,
och kontrollera om de är i ordning i förhållande till varandra.
De är - 3 är större än 2.
Att vara i stigande ordning, bör de vara tvärtom.
Så byta vi dem.
Nu listan ser ut så här: [2, 3, 9, 6, 5].
>> Därefter tittar vi på de andra och tredje element, 3 och 9.
De är i rätt ordning i förhållande till varandra.
Det vill säga, 3 mindre än 9, så att algoritmen inte byta dem.
Därefter tittar vi på 9 och 6. De är i ordning.
>> Så måste vi byta dem eftersom 9 är större än 6.
Slutligen tittar vi på de sista två heltal, 9 och 5.
De är ur funktion, så de måste bytas.
Efter den första fullständiga passagen genom listan,
Det ser ut så här: [2, 3, 6, 5, 9].
Inte illa. Det är nästan sorteras.
Men vi måste gå igenom listan igen för att få det helt sorteras.
Två är mindre än 3, så vi inte byta dem.
>> Tre är mindre än 6, så vi inte byta dem.
Sex är större än 5. Vi bytte.
Sex är mindre än 9. Vi vill inte byta.
Efter den andra passerar genom ser det ut så här: [2, 3, 5, 6, 9]. Perfekt.
Nu ska vi skriva det i pseudokod.
I grund och botten, för varje element i listan, måste vi titta på det
och elementet direkt till sin rätt.
Om de är ur funktion i förhållande till varandra - det är, om elementet till vänster
är större än en på höger - vi borde byta de två elementen.
>> Vi gör detta för varje element i listan, och vi har gjort en passerar.
Nu har vi bara göra genomslaget tillräckligt många gånger för att säkerställa att listan
är fullt, korrekt sorterad.
Men hur många gånger måste vi passera genom listan
garantera att vi är klara?
Tja, är det värsta scenariot om vi har en helt bakåt lista.
Sedan tar det ett antal pass-throughs lika med antalet
element n-1.
Om detta inte är vettigt intuitivt, tänk på ett enkelt fall - listan [2, 1].
>> Detta kommer att ta ett pass-through för att sortera rätt.
[3, 2, 1] - Det värsta fallet är att med 3 element sorteras bakåt,
det kommer att ta 2 iterationer för att sortera.
Efter en iteration, är det [2, 1, 3].
Den andra ger den sorterade arrayen [1, 2, 3].
Så du vet att du aldrig behöver gå igenom arrayen, i allmänhet,
mer än n-1 gånger, där n är antalet element i matrisen.
Det kallas Bubble Sortera eftersom de största delarna tenderar att "bubbla upp"
till höger ganska snabbt.
I själva verket har denna algoritm mycket intressant beteende.
>> Efter m iterationer genom hela matrisen,
längst till höger m element garanteras
att sorteras i sin rätta plats.
Om du vill se detta själv,
Vi kan prova på en helt bakåt lista [9, 6, 5, 3, 2].
Efter en passage genom hela listan,
[Ljudet av skrivande]
[6, 9, 5, 3, 2], [6, 5, 9, 3, 2], [6, 5, 3, 9, 2], [6, 5, 3, 2, 9]
längst till höger elementet 9 är på sin rätta plats.
Efter den andra genomslaget kommer 6 har "bubblade upp" till
2:a högra plats.
De två delarna till höger - 6 och 9 - kommer att vara i sina rätta ställen
Efter de två första pass-throughs.
>> Så, hur kan vi använda detta för att optimera algoritmen?
Nåväl, efter en iteration genom uppsättningen
Vi egentligen inte behöver kontrollera den högra delen
eftersom vi vet att det är sorterad.
Efter två iterationer, vet vi säkert längst till höger två elementen är på plats.
Så i allmänhet, efter k iterationer genom full uppsättning,
kontrollera sista k elementen är överflödig eftersom vi vet
de är på rätt plats redan.
>> Så om du sorterar en uppsättning n element,
den första iterationen - du måste sortera alla element - det första n-0.
På den andra iterationen, måste du titta på alla element men den sista -
den första n-1.
En annan optimering kan vara att kontrollera om listan redan sorterad
efter varje iteration.
Om det redan är sorterade behöver vi inte göra några fler iterationer
genom listan.
Hur kan vi göra det?
Tja, om vi inte gör några swappar på genomslag i listan,
det är klart att listan redan sorterades eftersom vi inte byta något.
Så vi definitivt inte behöver sortera igen.
>> Kanske kan du initiera en flagga variabel som kallas "inte sorteras" till
falsk och ändra den till true om du måste byta några element på
en iteration genom uppsättningen.
Eller liknande, gör en räknare för att räkna hur många swappar du gör
på en given iteration.
Vid slutet av en iteration, om du inte byta något av elementen,
du vet att listan redan är sorterad och du är klar.
Bubble Sortera, liksom andra sortering algoritmer, kan
tweaked att arbeta för alla element som har en beställning metod.
>> Det är, med tanke på två element du har ett sätt att säga om den första
är större än, lika med eller mindre än den andra.
Till exempel kan du sortera bokstäverna i alfabetet genom att säga
att a Bubble Sortera är ingalunda en mycket effektiv eller snabb sortering algoritm.
Den värsta runtime är Big O n ²
eftersom du måste göra n iterationer genom en lista
kontrollera alla n element varje pass-through, NxN = n ².
Detta körtid innebär att när antalet element som du sorterar ökar,
gångtiden ökar kvadratiskt.
>> Men om verkningsgraden är inte ett stort problem i ditt program
eller om du bara sortera ett litet antal element,
du kan hitta bubbla Sortera användbart eftersom
Det är en av de enklaste sortering algoritmer för att förstå
och att koda.
Det är också ett utmärkt sätt att få erfarenhet översätta en teoretisk
algoritm i själva fungerande kod.
Tja, det är bubbla Sortera åt dig. Tack för att titta.
CS50.TV