Sorteermethoden in programmeren: bellen sorteren

Belsortering wordt niet alleen niet als het meest beschouwddoor de snelle methode sluit het bovendien de lijst met de langzaamste manieren van bestellen. Het heeft echter zijn voordelen. Sorteren op de bellenmethode is dus de meest logische en natuurlijke oplossing voor het probleem, als u de elementen in een bepaalde volgorde moet rangschikken. Een gewone man zal het bijvoorbeeld met de hand precies gebruiken - gewoon door intuïtie.

Waar komt zo'n ongebruikelijke naam vandaan?

De naam van de methode is bedacht volgens een analogie metluchtbellen in het water. Dit is een metafoor. Net zoals kleine luchtbellen opstijgen - omdat hun dichtheid groter is dan welke vloeistof dan ook (in dit geval water), dus elk element van de array, hoe kleiner het is in waarde, hoe meer het geleidelijk zijn weg vindt naar het begin van de lijst met getallen.

Algoritme beschrijving

Bubble sorteren gaat als volgt:

• first pass: elementen van een reeks getallen worden in twee genomen en worden ook in paren vergeleken. Als in sommige twee elementen de eerste waarde groter is dan de tweede, wisselt het programma ze uit;
• daarom valt het grootste aantal aan het einde van de array. Terwijl alle andere elementen, zoals ze waren, in een chaotische volgorde blijven en nog steeds moeten worden gesorteerd;
• daarom is een tweede doorgang nodig: deze wordt gemaakt naar analogie met de vorige (reeds beschreven) en heeft een aantal vergelijkingen - min één;
• de passage nummer drie vergelijkingen zijn één minder dan de tweede en twee dan de eerste. Enzovoort;
• om samen te vatten, elke pass heeft (totale waarden in de array, een specifiek aantal) minus (passnummer) vergelijkingen.

Nog korter, het algoritme van het toekomstige programma kan als volgt worden geschreven:

• een reeks getallen wordt gecontroleerd totdat er twee getallen zijn gevonden, waarvan de tweede groter moet zijn dan de eerste;
• het programma is onjuist gelokaliseerd ten opzichte van elkaar uitwisselingen van arrayelementen.

Pseudocode gebaseerd op het beschreven algoritme

De eenvoudigste implementatie is als volgt:

procedure Bubble Sort;

begin

fietsen voor goed van start_index voordat end_index;

fietsen voor en van start_index voordat end_index-1;

als massiv [i]> massiv [i + 1] (het eerste element is groter dan het tweede), dan:

(verander waarden op plaatsen);

Het einde

Natuurlijk wordt de eenvoud hier alleen maar ergersituatie: hoe eenvoudiger het algoritme, hoe meer alle gebreken erin voorkomen. De tijdrovend is zelfs voor een kleine reeks te groot (relativiteit speelt een rol: voor een leek lijkt de hoeveelheid tijd klein, maar in het bedrijf van de programmeur telt elke seconde of zelfs milliseconde).

Het vergde een betere implementatie. Bijvoorbeeld, rekening houdend met de uitwisseling van waarden in een array op plaatsen:

procedure Bubble Sort;

begin

sorteren = waar;

cyclus nog sorteren = waar;

sorteren = onwaar

fietsen voor en van start_index voordat end_index-1;

als massiv [i]> massiv [i + 1] (het eerste element is groter dan het tweede), dan:

(wissel elementen);

sorteren = waar; (gaf aan dat de ruil plaatsvond).

Het einde.

Nadelen van de methode

Het belangrijkste minpuntje is de duur van het proces. Hoe lang duurt het algoritme voor het sorteren van bellen?

De uitvoeringstijd wordt berekend op basis van het kwadraat van het aantal getallen in de array - het uiteindelijke resultaat is er evenredig mee.

In het ergste geval wordt de array doorlopenzo vaak als er elementen in zitten min één waarde. Dit gebeurt omdat er uiteindelijk maar één element overblijft dat niets te vergelijken heeft, en de laatste doorgang door de array een nutteloze actie wordt.

Daarnaast is een efficiënte sorteermethode eenvoudiguitwisselingen, zoals het ook wordt genoemd, alleen voor kleine arrays. Het zal niet mogelijk zijn om met zijn hulp grote hoeveelheden gegevens te verwerken: het resultaat zijn fouten of een storing in het programma.

waardigheid

Belsortering is heel gemakkelijk te begrijpen.In de curricula van technische universiteiten wordt bij het bestuderen van de ordening van de elementen van een array als eerste geslaagd. De methode is eenvoudig te implementeren, zowel in de programmeertaal Delphi (D (Delphi) als C / C ++ (C / C plus plus), een ongelooflijk eenvoudig algoritme om waarden in de juiste volgorde te rangschikken en in Pascal (Pascal). Belsortering is ideaal voor beginners.

Vanwege tekortkomingen wordt het algoritme niet gebruikt voor buitenschoolse doeleinden.

Duidelijk sorteerprincipe

Het eerste aanzicht van de array is 8 22 4 74 44 37 1 7

Stap 1 8 22 4 74 44 37 1 7

8 22 4 74 44 1 37 7

8 22 4 74 1 44 37 7

8 22 4 1 74 44 37 7

8 22 1 4 74 44 37 7

8 1 22 4 74 44 37 7

1 8 22 4 74 44 37 7

Stap 2 1 8 22 4 74 44 7 37

1 8 22 4 74 7 44 37

1 8 22 4 7 74 44 37

1 8 22 4 7 74 44 37

1 8 4 22 7 74 44 37

1 4 8 22 7 74 44 37

Stap 3 1 4 8 22 7 74 37 44

1 4 8 22 7 37 74 44

1 4 8 22 7 37 74 44

1 4 8 7 22 37 74 44

1 4 7 8 22 37 74 44

Stap 4 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Stap 5 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Stap 6 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Stap 7 1 4 7 8 22 37 44 74

Voorbeeld van Pascal-bubbelsortering

Een voorbeeld:

const kol_mas = 10;

var massiv: array [1..kol_mas] van geheel getal;

a, b, k: geheel getal;

beginnen

writeln ("input", kol_mas, "elements of array");

voor a: = 1 tot kol_mas doen readln (massiv [a]);

voor a: = 1 tot kol_mas-1 beginnen

voor b: = a + 1 tot kol_mas beginnen

als massiv [a]> massiv [b] dan beginnen

k: = massiv [a]; massiv [a]: = massiv [b]; massiv [b]: = k;

einde;

einde;

einde;

writeln ("na sorteren");

voor a: = 1 tot kol_mas do writeln (massiv [a]);

einde.

Een voorbeeld van belsortering in C (C)

Een voorbeeld:

#include

#include

int main (int argc, char * argv [])

{

int massiv [8] = {36, 697, 73, 82, 68, 12, 183, 88}, i, ff;

voor (;;) {

ff = 0;

voor (i = 7; i> 0; i -) {

if (massiv [i]

ruilen (massiv [i], massiv [i-1]);

ff ++;

}

}

als (ff == 0) pauze;

}

getch (); // schermvertraging

retourneer 0;

}.