Das Verfahren der Blasensortierung in einem eindimensionalen Array mit. Sortieren Sie nach Blase (Pascal). Woher kam so ein ungewöhnlicher Name?

Jeder weiß, dass von der Klasse der Austausch-Sortierung die schnellste Methode das sogenannte ist schnelle Sortierung. Die Dissertationen werden über sie geschrieben, es gibt viele Artikel in Habré, es basiert auf komplexen Hybridalgorithmen, die darauf basieren. Aber heute wird es nicht dabei sein schnelle Sorte., aber über eine andere Austauschmethode - altes Gut blasensortierung und seine Verbesserungen, Modifikationen, Mutationen und Sorten.

Der praktische Auspuff dieser Methoden ist nicht ahti. Welche Viele der Habies werden all dies in der ersten Klasse gehalten. Daher wird der Artikel an diejenigen gerichtet, die nur an der Theorie von Algorithmen interessiert sind, und macht die ersten Schritte in diese Richtung.

bild: Blasen

Heute werden wir über den einfachsten sprechen austausch sortieren..

Wenn jemand interessiert ist, werde ich sagen, dass es andere Klassen gibt - die Wahl sortieren., sortiereinsätze sortieren., zusammenschluss sortieren., sortierverteilung, hybridsortierung und parallel-Sortierung.. Es gibt übrigens noch esoterische Sortierung. Dies sind verschiedene gefälschte, grundsätzlich nicht realisierte, komische und andere Pseudoalgorithmen, über die ich ein paar Artikel in einer Hub "IT-HUMOR" schreiben werde.

Aber der heutige Vortrag ist nicht zusammenhängt, wir sind jetzt nur für eine unprätentiöse Sortierung durch den Austausch interessiert. Sortieren selbst, es gibt auch viele Börsen (ich kenne mehr als ein Dutzend), also berücksichtigen wir die sogenannten blasensortierung Und einige andere, damit eng miteinander verbunden sind.

Warnung im Voraus, dass fast alle der oben genannten Methoden eine sehr langsame und tiefe Analyse ihrer temporären Komplexität sind. Einige schneller, einige der denkwürdigsten, aber grob sprechen, können wir das im Durchschnitt sagen Ö.(n 2.). Ich sehe auch nicht den Grund, den Artikel nach Implementierungen in allen Programmiersprachen zu kuppeln. Interessiert ohne die geringste Arbeitsplätze können Beispiele für Code auf Rosette, Wikipedia oder woanders finden.

Aber zurück zum Sortieren von Börsen. Die Anordnung erfolgt als Ergebnis einer mehrfachen konsistenten Aufzählung des Arrays und des Vergleichs der Parameter von Elementen untereinander. Wenn die verglichenen Elemente nicht voneinander sortiert sind, ändern wir sie an Orten. Die einzige Frage ist genau das, was Makar-Array zu umgehen und welches Prinzip ein paar zum Vergleich auswählen kann.

Beginnen wir nicht mit der Referenzblasensortierung, sondern von dem Algorithmus, der namens ...

Dumme Sortierung

Sortieren und wirklich dumm. Wir sehen das Array nach links und rechts und unterwegs mit dem Vergleich der Nachbarn. Wenn wir ein paar voneinander unkorrigierten Elementen erfüllen, ändern wir sie an Orten und gehen zurück in die Kreise, dann meinen Sie zu Beginn. Wir gehen weiter, überprüfen Sie das Array, wenn sie sich wieder ein paar benachbarte Elemente erfüllen, ändern wir uns an Orte und wieder beginnen wir alle Syznov. Wir fahren fort, bis das Array langsam sortiert wird.

"Also kann jeder Narr sortieren" - Sie werden sagen und Sie werden absolut richtig sein. Deshalb ist die Sortierung und "dumm" genannt. In dieser Vorlesung werden wir diese Methode konsequent verbessern und ändern. Jetzt hat er temporäre Komplexität Ö.(n 3.), die eine Korrektur erzeugt, werden wir dazu bringen Ö.(n 2.), dann beschleunigen Sie ein bisschen mehr, dann noch, und am Ende bekommen wir Ö.(n. Log. n.) - Und es wird nicht "schnell sortieren"!

Wir führen eine einzige Verbesserung in einer dummen Art ein. Nachdem ich die beiden benachbarten ungenutzten Elemente gefunden hatte, wenn Sie sie an Orten passieren und ändern, werde ich nicht auf den Anfang des Arrays zurückrollen, und es wird ruhig seinen Bypass bis zum Ende umgehen.

In diesem Fall ist vor uns nichts anderes als der berühmte ...

Blasensortierung

Oder sortieren nach einfachem Austausch. Unsterbliches klassisches Genre. Das Aktionsprinzip ist einfach: Umgehen eines Arrays von Anfang bis zum Ende, wobei die benachbarten benachbarten benachbarten Elemente auf dem Weg passiert. Als Ergebnis der ersten Passage wird das maximale Element "auftauchen". Jetzt müssen wir den ungesalzenierten Teil des Arrays (vom ersten Element zum vorletzten) umgehen und sich entlang des Weges ungesalzener Nachbarn wechseln. Das zweitgrößte Element wird am vorletzten Ort sein. In demselben Geist werden wir den gesamten abnehmenden ungesalzigen Teil des Arrays umgehen, indem wir den gefundenen Maxima bis zum Ende schaufeln.

Wenn nicht nur, um die Maxima, um die Maxima zu setzen, und auch am Anfang, um das Minimum zu übertragen, dann haben wir ...

Shaker-Sortierung

Sie ist sortieren nach Rühren, Sie ist cocktailsortierung.. Der Prozess beginnt wie in der "Blase": Wir drücken das Maximum auf den Hinterhöfen zusammen. Danach drehen wir uns um 180 0 und gehen in die entgegengesetzte Richtung, während sie bereits am Anfang nicht ein Maximum und zumindest zahlen. Nachdem wir die ersten und letzten Elemente im Array sortiert haben, machen wir Erl wieder. Wenn Sie mehrmals zurückgehen, beenden Sie den Prozess, beenden Sie den Prozess, um in der Mitte der Liste zu sein.

Die Shaker-Sortierung funktioniert etwas schneller als Blase, da das Massiv in der rechten Richtung abwechselnd die Maxima und Minima migriert. Verbesserungen, wie sie sagen, ist offensichtlich.

Wenn Sie sehen können, ist, wenn es kreativ ist, der Auswurf von schweren (Lungen-) Elementen an den Enden des Arrays schneller ist. Daher boten die Handwerker einen weiteren nicht standardmäßigen "Roadmap", um die Liste zu umgehen.

Sogartige Sortierung

Diesmal werden wir nicht auf dem Array zurück und wenden sich an die Idee des systematischen Kriegers nach rechts, sondern machen nur einen breiteren Schritt. An den ersten Pass, Elemente mit einem ungeraden Schlüsselvergleichen mit Nachbarn, die an den Stimmzetteln steigen (1-ter Vergleich von 2., dann der 3. vom 4., 5. von dem 6. und so weiter). Im Gegenteil, "die Elemente" sind dann "Lesen", indem sie mit "ungeraden" vergleichen / wechseln. Dann wieder "Es gibt etwas" etwas ", dann wieder" Sogar-Notch ". Der Prozess stoppt, wenn nach einem Vertrag von zwei Durchläufen entlang des Massivs ("ungeradsschwarz" und "coullless") nicht ein einzelner Austausch aufgetreten ist. Es wurde sortiert.

In der üblichen "Blase" während jedes Passs drücken wir das aktuelle Maximum am Ende des Arrays zusammen. Wenn Sie die Explosion von fragenden und ungeraden Indizes bewegen, werden sofort alle mehr oder weniger großen Elemente des Arrays gleichzeitig in einer Kilometerleistung nach rechts auf eine Position gedrückt. Also wird es schneller heraus.

Wir wunderstelten lackiert* zum Sortannya bulbashko.** - Sortanna grebinets.*** Diese Methode organisiert ziemlich schnell, Ö.(n 2.) - seine schlimmste Komplexität. Im Durchschnitt haben wir Ö.(n. Log. n.), und das Beste, glauben Sie nicht, glauben Sie nicht Ö.(n.). Das heißt, ein sehr würdiger Konkurrent für jede "schnelle Sortierung" und dieses, ohne die Verwendung von Rekursion. Ich habe jedoch versprochen, dass wir in Cruising-Geschwindigkeiten nicht in die Cruising-Geschwindigkeit eintauchen werden, ich werde es schweigen und direkt an den Algorithmus drehen.

Schildkröte zu beschuldigen

Kleine Vorgeschichte. Im Jahr 1980 erklärte Vlodzimezh Doboshevich, warum Blasen und Sortierderivate so langsam funktionieren. Es ist alles wegen der Schildkröten. "Turtles" - kleine Gegenstände, die sich am Ende der Liste befinden. Wie Sie vielleicht bemerkt haben, dass die Bubble-Sortierung auf "Kaninchen" konzentriert ist (nicht mit den "Kaninchen" von Babushkina zu verwechseln) - groß, um die Elemente am Anfang der Liste zu gewinnen. Sie bewegen sich sehr eng in das Ziel. Aber die langsam befriedigenden Reptilien werden widerwillig krabbeln. Customized "Tortila" kann verwendet werden berechnungen.

bild: Schuldschildkröte

Berechnung sortieren.

In der "Blase", "Shaker" und "Sogar-Niemand", mit einem Massiv in dem Array, werden benachbarte Elemente verglichen. Die Hauptidee der "Berechnungen" besteht darin, zunächst einen ausreichend großen Abstand zwischen den funkenfähigen Elementen zu nehmen, als das Array aus dem Array ergibt, er ist bis zum Minimum. So kombinieren wir also ein Array, das allmählich auf zunehmend gepflegte Stränge glättet.

Der anfängliche Lücke zwischen den funkenfähigen Elementen ist besser, um keine ABBA zu nehmen, sondern unter Berücksichtigung der speziellen Größe der Angerufenen faktorabnahmeDer optimale Wert davon beträgt ungefähr 1.247. Zunächst ist der Abstand zwischen den Elementen gleich der Größe des festen Arrays an faktor verringern (Das Ergebnis ist natürlich auf das nächste Ganze gerundet). Wenn Sie dann ein Array mit diesem Schritt passieren, teilen wir den Schritt auf faktor verringern Und wir gehen wieder durch die Liste. Dies setzt sich fort, bis die Indexunterschiede das Gerät erreichen. In diesem Fall ist das Array nicht von einer herkömmlichen Blase.

Erfahrene und theoretische Weise ist der optimale Wert. faktorabnahme.:

Wenn diese Methode erfunden wurde, welchen sich nur wenige Personen an der Kreuzung der 70er und 80er Jahre darauf aufmerksamten. Das Jahrzehnt später, als die Programmierung aufgehört hat, viele Wissenschaftler und IBM-Ingenieure zu sein, und bereits afinanchen gewann massive Natur, wurde die Methode wieder eröffnet, untersucht und 1991 im Jahr 1991 in Stephen Lacey und Richard Boxing eröffnet und populiert.

Das ist eigentlich, und alles, was ich Ihnen von der Sortierung von Bubble sortieren wollte, und andere mögen es.

- Anmerkungen

* Lackiert ( ukr.) - Verbesserung.
** sorvania bulbashmo ( ukr.) - Sortieren nach Blase
*** sorthanny grebinzts ( ukr.) - Sortieren der Berechnung

Wir legen ein Array von oben nach unten, vom Nullelement bis zum letzten.

Die Idee der Methode: Der Sortierschritt besteht in der Passage vom Bottom up das Array. Auf dem Weg gibt es Paare benachbarter Elemente. Wenn die Elemente einiger Paare in der falschen Reihenfolge sind, ändern wir sie an Orten.

Nach Nulldurchgang durch Array "oben" erstellt sich als das licht leichte Element - von hier eine Analogie mit einer Blase. Der folgende Durchgang wird von oben auf das zweite Element hergestellt, so dass das zweitgrößte Element an der richtigen Position steigt ...

Wir erstellen Passagen für den gesamten abnehmenden unteren Teil des Arrays, bis nur ein Element darin bleibt. An dieser Sortierung endet, da die Sequenz aufsteigend bestellt wird.

Vorlage. Void bubblesort (t a, lange größe) (lang i, j; t x; für (i \u003d 0; ich< size; i++) { // I - Eine Passnummer für (j \u003d Größe-1; j\u003e i; j--) ( // Interner Durchgangszyklus wenn (a\u003e a [j]) (x \u003d a; a \u003d a [j]; a [j] \u003d x;)))

Die durchschnittliche Anzahl von Vergleiche und Börsen hat eine quadratische Reihenfolge des Wachstums: Theta (N 2), von hier aus können Sie abschließen, dass der Blasealgorithmus sehr langsam ist und unwirksam ist.
Trotzdem hat er ein riesiges Plus: Er ist einfach und kann in irgendeiner Weise verbessert werden. Was wir jetzt gehen werden.

Betrachten Sie zunächst die Situation, wenn kein Austausch an einem der Pässe passiert ist. Was bedeutet das?

Dies bedeutet, dass sich alle Paare in der rechten Reihenfolge befinden, sodass das Array bereits sortiert ist. Und um den Prozess fortzusetzen, macht es keinen Sinn (insbesondere wenn das Array von Anfang an sortiert wurde!).

Die erste Verbesserung des Algorithmus besteht also darin, sich daran zu erinnern, ob in dieser Passage ein Austausch getroffen wurde. Wenn nicht, endet der Algorithmus die Arbeit.

Der Verbesserungsprozess kann fortgesetzt werden, wenn Sie sich nicht nur die Tatsache des Austauschs erinnern, sondern auch der Index des letzten Austauschs von k. In der Tat: Alle Paare des Pakets von Elementen mit Indizes, kleiner k, sind bereits in der gewünschten Reihenfolge angeordnet. Weitere Passagen können auf dem K-Index abgeschlossen werden, anstatt in die obere Grenzversion, die ich im Voraus installiert habe.

Qualitativ kann eine weitere Verbesserung des Algorithmus von der folgenden Beobachtung erhalten werden. Obwohl die leichte Blase von der Unterseite in einem Pass aufsteigt, werden schwere Blasen auf eine Mindestgeschwindigkeit abgesenkt: ein Schritt zur Iteration. So wird das Array 2 3 4 5 6 1 in einem Durchlauf sortiert, und die Sortierung der Sequenz 6 1 2 3 4 5 erfordert 5 Durchläufe.

Um einen ähnlichen Effekt zu vermeiden, können Sie die Richtung der folgenden anderen Pässe ändern. Der resultierende Algorithmus wird manchmal genannt " shaker-Sortierung".

Vorlage. void shakersort (t a, langer Größe) (lange j, k \u003d Größe-1; langes LB \u003d 1, UB \u003d Größe-1; // die Grenzen des nichtstehenden Teils des Arrays T x; tun ( // pass an Für (j \u003d Ub; j\u003e 0; j--) (wenn (a\u003e a [j]) (x \u003d a; a \u003d a [j]; a [j] a \u003d a [j \u003d j;)) lb \u003d k + 1; // Pass von oben nach unten für (j \u003d 1; j<=ub; j++) { if (a > a [j]) (x \u003d a; a \u003d a [j]; a [j] \u003d x; k \u003d j;)) Ub \u003d k-1; ) Während (lb< ub); }

Wie beschriebene Änderungen betrugen die Wirksamkeit der Methode? Die durchschnittliche Anzahl der Vergleiche, obwohl es gesunken ist, bleibt jedoch o (n 2), während sich die Anzahl der Börsen in keiner Weise nicht geändert hat. Der Durchschnitt (es ist das Schlimmste) Die Anzahl der Operationen bleibt quadratisch.

Zusätzlicher Speicher ist offensichtlich nicht erforderlich. Das Verhalten einer verbesserten (aber nicht anfänglichen) Methode ist eher natürlich, fast sortiertes Array wird viel schneller sortiert. Sortieren nach Blase ist stabil, aber die Shaker-Sortierung verliert diese Qualität.

In der Praxis funktioniert die Bubble-Methode auch mit Verbesserungen, arbeitet, leider, zu langsam. Und daher gilt fast nicht.

Details Kategorie: Sortierung und Suche

Sortieren nach Blase (Austauschsortierung) - einfach zu implementieren und unwirksamer Sortieralgorithmus. Die Methode wird von einem der ersten im Laufe der Theorie der Algorithmen untersucht, während es in der Praxis sehr selten verwendet wird.

Der Algorithmus besteht aus sich wiederholenden Pässen auf dem sortierten Array. Für jeden Pass werden die Elemente gleichzeitig in Paaren verglichen, und wenn die Reihenfolge falsch ist, wird der Austausch von Elementen erfüllt. Die Array-Pisten werden einmal wiederholt, oder bis der nächste Durchgang erstellt, erscheint er heraus, dass der Austausch nicht mehr benötigt wird, was bedeutet, was bedeutet, dass ein Array sortiert ist. Bei jedem Durchgang des Algorithmus auf dem Innenzyklus wird das nächstgrößere Element des Arrays am Ende des Arrays neben dem vorherigen "größten Element" an seiner Stelle angelegt, und das kleinste Element bewegt sich zu einer Position zu Beginn von Das Array ("knallt auf die gewünschte Position als Blase in Wasser, somit und der Name des Algorithmus).

Schlimmer
Beste Zeit
Durchschnittliche Zeit
Speicherkosten

Ein Beispiel für die Arbeit des Algorithmus

Nehmen Sie ein Array mit Zahlen "5 1 4 2 8" und sortieren Sie die Werte aufsteigend mit der Sortierung durch eine Blase. Diese Elemente, die zu diesem Zeitpunkt verglichen werden, werden hervorgehoben.

Erster Pass:

(5 1 4 2 8) (1 5 4 2 8), hier vergleicht der Algorithmus die beiden ersten Elemente und ändert sie an Stellen. (1 5 4 2 8) (1 4 5 2 8), Änderungen an Orten, weil (1 4 5 2 8) (1 4 2 5 8), Änderungen an Orten, weil (1 4 2 5 8 ) (1 4 2 5 8 ) Nun, angesichts der Tatsache, dass sich Elemente an ihren Orten befinden (), ändert der Algorithmus sie nicht an Stellen.

Zweiter Pass:

(1 4 2 5 8) (1 4 2 5 8) (1 4 2 5 8) (1 2 4 5 8), Änderungen an Orten, weil (1 2 4 5 8) (1 2 4 5 8) (1 2 4 5 8 ) (1 2 4 5 8 )

Jetzt ist das Array vollständig sortiert, aber der Algorithmus weiß nicht, ob es ist. Daher muss er einen vollen Durchgang machen und bestimmen, dass es keine Permutation der Elemente gab.

Dritter Pass:

(1 2 4 5 8) (1 2 4 5 8) (1 2 4 5 8) (1 2 4 5 8) (1 2 4 5 8) (1 2 4 5 8) (1 2 4 5 8 ) (1 2 4 5 8 )

Nun ist das Array sortiert und der Algorithmus kann abgeschlossen werden.

Implementierung des Algorithmus in verschiedenen Programmiersprachen:

Intel Syntax.

MOV BX, Offset-Array MOV CX, N for_i: dec cx xor dx, dx for_j: cmp dx, cx jae exit ah, byte ptr bx mov byte ptr bx, al mov byte ptr bx, ah no_swap: inc dx jmp For_j exit_for_j: Schleife for_i

AT & T-Syntax (GNU)

Text # void bubble_sort (unsigniertes * Array, unsignierter langer Langstatt); .globl Bubble_sort .Type bubble_sort, @function bubble_sort: MOV 8 (% ESP),% ECX # unsignierte Länge CMP $ 1,% ECX JBE EXIT MOV 4 (% ESP),% EAX # unsigniert * Array Dec% ECX for_ecx: xor % EDI,% EDI For_EDI: MOV (% EAX,% EDI, 4),% EBX CMP% EBX, 4 (% EAX,% EDI, 4) Jae no_xchng MOV 4 (% EAX,% EDI, 4),% EDX MOV% EDX, (% EAX,% EDI, 4) MOV% EBX, 4 (% EAX,% EDI, 4) no_xchng: INC% EDI CMP% EDI,% ECX JNE FORD_EDI-Loop for_ecx Exit: RET

C.

#Define Swap (A, B) (INT T \u003d A; A \u003d B; B \u003d T;) void bubblesort (int * a, int n) (int i, j; für (i \u003d n - 1; I\u003e 0 ; i--) (für (j \u003d 0; j< i; j++) { if (a[j] > a) Swap (A [J], A); )))

C ++.

Verwenden der Vorlage.

#Einschließen. Vorlage.< typename Iterator > Void bubble_sort (iterator zuerst, iterator zuletzt) \u200b\u200b(während< --Last) for(Iterator i = First; i < Last; ++i) if (*(i + 1) < *i) std::iter_swap(i, i + 1); }

Ohne Anwendungsvorlage

Leerblase (int * a, int n) (für (int i \u003d n - 1; i\u003e \u003d 0; i--) (für (int j \u003d 0; j< i; j++) { if (a[j] > a) (int tmp \u003d a [j]; a [j] \u003d a; a \u003d tmp;))))

C #

Void bubblesort (int a) (für (int i \u003d 0; ich< A.Length; i++) { for (int j = i+1; j < A.Length; j++) { if (A[j] < A[i]) { var temp = A[i]; A[i] = A[j]; A[j] = temp; } } } }

Delphi.

Sortieren eines eindimensionalen dynamischen Integer-Massivs:

Typ Tintvec \u003d Anordnung der Ganzzahl; ... Verfahren bubblesort (var a: tintvec); Var I, P, N: Ganzzahl; B: boolean; Beginnen Sie n: \u003d Länge (A); Wenn n.< 2 then exit; repeat b:= false; Dec(n); if n > 0 dann für i: \u003d 0 bis n-1 tun, wenn ein [i]\u003e a dann beginnen p: \u003d a [i]; A [I]: \u003d A; A: \u003d p; B: \u003d wahr; Ende; Bis nicht b; Ende;

D.

Void bubblesort (alias op, t) (t inarray) (feach (i, ref a; inarray) (foreach (ref b; inarray) (if (mixin (mixin (op)) (auto tmp \u003d a; a \u003d b; B \u003d tmp;))))

Fortran

Do i \u003d n-1,1, -1 do j \u003d 1, i, wenn (a (j) .g.a (j + 1)) dann t \u003d a (j) a (j) \u003d a (j + 1 ) A (j + 1) \u003d t endIf enddo enddo

Java.

Void bubblesort (int arr) (für (int i \u003d 0; i< arr.length-1; i++){ for (int j = i+1; j < arr.length; j++){ if (arr[i] < arr[j]) { int t = arr[i]; arr[i] = arr[j]; arr[j] = t; } } } }

Pascal

Für i: \u003d n-1 Downto 1 do (n - Array-Größe M) für J: \u003d 1 bis I Mache, wenn m [j]\u003e m dann beginne tmp: \u003d m [j]; M [j]: \u003d m; M: \u003d tmp; Ende; Schreiben ("Die Ausgabe der Werte M:"); Für i: \u003d 1 bis n schreiben (m [i]: 4); Writeln;

Verbesserter Sortieralgorithmus durch Blase:

P: \u003d wahr; (Gibt es eine Permutation?) K: \u003d 1; (Anzeigennummer) Während P beginnen P: \u003d FALSE; Für i: \u003d 1 bis n - k tun, wenn x [i]\u003e x dann ein: \u003d x [i] beginnen; X [i]: \u003d x; X: \u003d a; P: \u003d wahr; Ende; k: \u003d k + 1; Ende;

Perl

Für (@out) (für (0. $ n-1) (if ($ ($ _] gt $ out [$ _ + 1]) (($ _ + 1]) (($ _ [$ _], $ out [$ _ + 1]) \u003d ($ out [$ _ + 1], $ out [$ _]);)))

Rubin

Arr \u003d swap \u003d echte Größe \u003d arr.Length - 1 während Swap Swap \u003d FALSE FÜR I IN 0 ... GRÖSSE SWAP | \u003d ARR [I]\u003e ARR [I], ARR \u003d ARR, ARR [I] Wenn ARR [I] ]\u003e ARR-Endgröße - \u003d 1-End-Puts Arr.join ("") # -Unterie \u003d\u003e 1 3 3 5 8 10 11 12 17 20

Python

Def Swap (ARR, I, J): ARR [I], ARR [J] \u003d ARR [J], ARR [I] def Bubble_sort (ARR): i \u003d len (arr) während i\u003e 1: für j in xrange (i - 1): Wenn ARR [J]\u003e ARR: Swap (ARR, J, J + 1) I - \u003d 1

Vba.

Sub sort (mus () so lang) dim i so lange, tmp so lange, t als boolean t \u003d true do tt \u003d false für i \u003d 0 zu ubound (mus ()) - 1 wenn mus (i)\u003e mus ( I + 1) dann tmp \u003d mus (i) mus (i) \u003d mus (i + 1) mus (i + 1) \u003d tmp t \u003d echtes Ende, wenn das nächste Schleifenend-Sub

PHP.

$ Size \u003d sizeof ($ arr) -1; Für ($ i \u003d $ Größe; $ i\u003e \u003d 0; $ i--) (für ($ j \u003d 0; $ j<=($i-1); $j++) if ($arr[$j]>$ ARR [$ J + 1]) ($ k \u003d $ ARR [$ j]; $ arr [$ j] \u003d $ ARR [$ J + 1]; $ ARR [$ J + 1] \u003d $ k;))

Javascript

Funktion sortbubble (Daten) (var tmp; für (var i \u003d data.länge - 1; i\u003e 0; i--) (für (var j \u003d 0; j< i; j++) { if (data[j] > Daten) (TMP \u003d Daten [J]; Daten [J] \u003d Daten; Daten \u003d TMP;))) Rückgabedaten; )

Javafx.

Funktion Bubblesort (SEQ: Nummer): Nummer (VAR Sort \u003d SEQ; varel elem: Nummer; für (n in Rückwärts) (für (i in) (wenn (sortieren)< sort[i]){ elem = sort[i]; sort[i] = sort; sort = elem; } } } return sort; }

Nemerle.

Mit system.console; mit nemerle.collections; Def Array \u003d Array; Foreach (i in) foreach (j in), wenn (ARR [J]\u003e ARR) (ARR [J], ARR) \u003d (ARR, ARR [J]); Writine ($ "sortierte Liste ist ein $ (arr.tolist ())");

Turbobasic 1.1.

CLS Randomize-Timer-Definition X, Y, N, I, J, DN \u003d 10 "32 766 - 62.7 sec dim y [n], y1 [n], y2 [n], y3 [n], y4 [n]" fre (-1) \u003d 21440-21456 drucken "zapolnenie massiva elementami" für x \u003d 1 bis ny [x] \u003d x drucken y [x]; Nächste x: drucken drucken "peremeshivanije elementov massiva" drucken "sluchainye chlala" für x \u003d 1 bis n yd \u003d y [x] xs \u003d int (rnd * n) +1 drucken xs; Y [x] \u003d y y \u003d yd next x: drucken drucken "peremeshannyj massiv" für x \u003d 1 bis n drucken y [x]; NEXT X: Drucken "Algoritm" SortiRovka Prostym OBMENOM "O (N ^ 2) MTImer für J \u003d 1 bis N-1 Schritt 1 f \u003d 0 für i \u003d 1 bis nj Schritt 1" Wenn y [i]\u003e yene d \u003d y [i]: y [i] \u003d y: y \u003d d: f \u003d 1 Wenn y [i]\u003e yene Swap y [i], y: f \u003d 1 lokalisieren 8,1 REMPT "Anymacija sortirovki" REM für x1 \u003d 1 zum N REM-Animationsblock-Druck y; REM NÄCHST X1: DRUCKEN SIE DRUS REM DELAY .5 REM NÄCHSTE I IF F \u003d 0, dann EXIT NEXT J T1 \u003d MTImer Print "OTSORTIROVANNYJ MASSIV" für X \u003d 1 bis N Print y [x]; Nächstes x: drucken drucken "abgelaufene zeit \u003d" t1

Wie bereits erwähnt, wird der Algorithmus selten in der Praxis verwendet, da er eine geringe Leistung aufweist. Im besten Fall erfordern die Sortierung durch die Blase o (n) der Zeit und im Durchschnitt und im Durchschnitt und schlechtem - O (N2).

Beim Schreiben des Artikels wurden offene Internetquellen verwendet:

Es gibt eine ziemlich große Anzahl von Sortieralgorithmen, viele von ihnen sind sehr spezifisch und entwickelt, um einen schmalen Taskkreis zu lösen und mit bestimmten Datentypen zu arbeiten. Bei all dieser Vielfalt ist der am einfachstesten Algorithmus jedoch von der Bubble-Sortierung, die in jeder Programmiersprache implementiert werden kann. Trotz seiner Einfachheit ist es vielen von recht komplexen Algorithmen zugrunde. Ein weiterer ebenso wichtiger Vorteil ist seine Einfachheit, und daher kann er abgerufen und umgesetzt werden, ohne dass eine zusätzliche Literatur vor den Augen hat.

Einführung

Das gesamte moderne Internet ist eine große Menge an dargestellten Datenstrukturen, die in Datenbanken gesammelt wurden. Sie enthalten alle Arten von Informationen, die von personenbezogenen Daten von Benutzern reichen und mit dem semantischen Kern hoch intelligenter automatisierter Systeme enden. Es lohnt sich, dass die Datensortierung in dieser Vielzahl strukturierter Informationen eine äußerst wichtige Rolle spielt. Die Sortierung kann ein Bindungsschritt sein, bevor Sie nach Informationen in der Datenbank suchen, und das Wissen der Sortieralgorithmen spielt eine äußerst wichtige Rolle bei der Programmierung. Es gibt eine ziemlich große Anzahl von Sortieralgorithmen, viele von ihnen sind sehr spezifisch und entwickelt, um einen schmalen Taskkreis zu lösen und mit bestimmten Datentypen zu arbeiten. Aber unter all dieser Vielfalt ist der am einfachste, der diskutiärste Algorithmus, ist blasensortierungwas in jeder Programmiersprache implementiert werden kann. Trotz seiner Einfachheit ist es vielen von recht komplexen Algorithmen zugrunde. Ein weiterer ebenso wichtiger Vorteil ist seine Einfachheit, und daher kann er abgerufen und umgesetzt werden, ohne dass eine zusätzliche Literatur vor den Augen hat.

Die Augen der Maschine und der Augen des Menschen sortieren

Stellen Sie sich vor, Sie müssen in aufsteigenden 5 Spalten unterschiedlicher Höhen sortieren. Unter diesen Spalten können alle Informationen verstanden werden (Aktienkurse, Kommunikationskanalbandbreite usw.), Sie können eine Art Option für diese Aufgabe einreichen, um eindeutiger zu sein. Nun, wir werden als Beispiel die Avengers durch das Wachstum sortieren:

Im Gegensatz zum Computerprogramm ist das Sortieren nicht arbeitet, da Sie das Bild insgesamt sehen können und sofort einschätzen können, was ein Held, in dem Sie sich bewegen müssen, so dass die Sortierung des Wachstums erfolgreich abgeschlossen wurde. Sie haben bereits vermutet, dass es zum Sortieren, diese Datenstruktur zu erhöhen, reicht aus, um die Hallen und einen Eisenmann an Orten zu wechseln:

Getan!

Und auf dieser Sortierung wird erfolgreich abgeschlossen. Die Rechenmaschine, anders als Sie etwas dumm, sieht die gesamte Datenstruktur nicht vollständig. Sein Steuerungsprogramm kann nur zwei Werte gleichzeitig vergleichen. Um diese Aufgabe zu lösen, sollte es getan werden, um zwei Zahlen in Ihrem Speicher zu posten und den Vergleichsvorgang über ihnen auszuführen, danach zu einem anderen Zahlenpaar und so, bis alle Daten analysiert werden. Daher ist jeder Sortieralgorithmus sehr einfach, kann durch drei Schritte dargestellt werden:

• Vergleichen Sie zwei Elemente;
• Orte wechseln oder einen von ihnen kopieren;
• Gehe zum nächsten Element;

Verschiedene Algorithmen können diese Vorgänge anders ausführen, aber wir werden zur Berücksichtigung des Prinzips des Betriebs der Blasensortierung fortgesetzt.

Algorithmus-Blasen-Sortierung.

Bubble Sorting gilt als einfachste, aber bevor Sie diesen Algorithmus beschreiben, können Sie sich vorstellen, wie Sie die Avengers durch das Wachstum sortieren, wenn sie könnten, wenn sie könnten, wie das Auto, um nur zwei Helden in einem Zeitpunkt zu vergleichen. Höchstwahrscheinlich hätten Sie (optimalste) wie folgt angekommen:

• Sie bewegen sich zum Nullelement unseres Arrays (schwarze Witwe);
• Vergleichen Sie das Nullelement (schwarze Witwe) mit dem ersten (Halkom).
• Wenn sich das Element auf der Nullposition als höher erwies, ändern Sie sie an Orten.
• Andernfalls, wenn das Element auf der Nullposition geringer ist, lassen Sie sie an unseren Orten.
• Erzeugen Sie die Position nach rechts nach rechts und wiederholen Sie den Vergleich (vergleichen Sie den HULK mit dem Kapitän)

Nachdem Sie mit einem solchen Algorithmus in der gesamten Liste in einem Durchgang gegangen sind, wird die Sortierung nicht vollständig gemacht. Aber das größte Element in der Liste wird jedoch in die extreme rechte Position verschoben. Es wird immer passieren, denn, denn, denn, sobald Sie das größte Element finden, werden Sie die ganze Zeit, bis Sie sie ändern, bis Sie zum einfachsten ziehen. Das heißt, sobald das Programm "findet" das Hulk im Array, wird es am Ende der Liste weiter verschieben:

Deshalb wird dieser Algorithmus als Blasensortierung genannt, da als Ergebnis seiner Arbeit das größte Element in der Liste sich als ganz oben des Arrays herausstellt, und alle kleinsten Elemente werden auf eine Position nach links verschoben:

Um die Sortierung abzuschließen, müssen Sie zum Anfang des Arrays zurückkehren und die oben beschriebenen fünf Schritte wiederholen, um erneut nach rechts zu verschieben, zu vergleichen, und durch die Notwendigkeit, Elemente zu verschieben. Diesmal müssen Sie jedoch den Algorithmus für ein Element bis zum Ende des Arrays anhalten, da wir bereits wissen, dass in der äußersten rechten Position absolut genau das größte Element (HULK) enthält:

Somit muss das Programm zwei Zyklen haben. Für eine größere Klarheit, bevor wir mit der Berücksichtigung des Programmcodes fortfahren, können Sie diese Verbindung mit der Visualisierung der Arbeit der Blasensortierung kennenlernen: Visualisierung der Blasensortierung

Verkauf von Bubble Sorting in Java-Sprache

Um die Arbeit der Sortierung auf Java zu demonstrieren, geben wir dem Programmcode an, den:

• erstellt ein Array von 5 Elementen;
• lädt das Wachstum der Avengers;
• zeigt den Inhalt des Arrays an;
• verkauft Bubble Sorting;
• wiederholt den Bildschirm des sortierten Arrays.

Der Code ist unten zu finden und laden Sie ihn sogar an Ihre bevorzugte Intellij IDE herunter. Seine Analyse wird unten durchgeführt: Klasse ArrayBubble (privat lang A; // Link zu einem Array Private int eles; // Anzahl der Elemente im Array Öffentlicher Arraybubble (int max) ( // Klasse Designer. a \u003d neuer langer [max]; // Erstellen eines Arrays von max elems \u003d 0; // Bei der Erstellung eines Arrays enthält 0 Elemente ) Öffentliche Leere in (langer Wert) (langer Wert) ( // Methodeneinfügungselement in einem Array Ein [elems] \u003d Wert; // Wert einfügen in Array a Elems ++; // Die Größe des Arrays erhöht sich ) Öffentlicher Leerlaufdrucker () ( // Ausgangsmethode des Arrays in der Konsole für (int i \u003d 0; ich elems ; I ++) ( // Für jedes Element im Array System. Aus. Drucken (a [i] + "); // zur Konsole bringen System. Aus. Println (""); // aus dem neuen Zeile) System. Aus. Println ( "---- Ende der Ausgabe des Arrays ----"); ) Privater void toswap (int erster, int second) ( // Methode ändert sich in Orten ein paar Zahlen-Array Langer Dummy \u003d A [Erster]; // In der temporären Variablen platzieren wir das erste Element Ein [erster] \u003d a [zweiter]; // an Ort und Stelle das zweite Element zuerst ein [zweiter] \u003d Dummy; // Anstelle des zweiten Elements schreiben wir den ersten Zeitspeicher ) Public Level Bubblesorder () (für (int out \u003d elems - 1; aus\u003e ; in ++) ( // interner Zyklus wenn (A [IN]\u003e A [IN + 1]) Toswap (in, in + 1); )))) Public Class Main (öffentlicher statischer Mengen-Main (String Args) (ArrayBubble-Array \u003d neuer ArrayBubble (5); // Erstellen Sie ein Array-Array für 5 Elemente Array. In (163); // Füllen Sie ein Array Array. Ino (300); Array. Ino (184); Array. In (191); Array. In (174); Array. Drucker (); // Anzeigepunkte vor dem Sortieren anzeigen Array. Bubblesorder (); // Bubble Sorting verwenden Array. Drucker (); // Wiederholen Sie das sortierte YPISOK erneut } } Trotz detaillierter Kommentare in dem Code geben wir eine Beschreibung der im Programm vorgelegten Methoden an. Schlüsselmethoden, die die Hauptarbeit im Programm durchführen, werden in der ArrayBubble-Klasse geschrieben. Die Klasse enthält einen Konstruktor und mehrere Methoden:

• in - Verfahren zum Einfügen von Elementen in ein Array;
• drucker - Zeigt den Inhalt der Array-Linie an;

toswap - setzt gegebenenfalls Artikel an Orten. Verwenden Sie dazu den temporären Variablen-Dummy, in dem der Wert der ersten Nummer aufgezeichnet ist, und ein Wert der zweiten Anzahl wird an Ort und Stelle aufgezeichnet. Danach wird der Inhalt der Zeitvariablen in die zweite Zahl geschrieben. Dies ist ein Standarderhalt von Umlagerungen von zwei Elementen.

und schließlich die Hauptmethode:

• bubblesorterer -, der die Hauptarbeit herstellt und die im Array gespeicherten Daten sortiert, die wieder einmal separat präsentieren:

  Öffentlicher Leere Bubblesorterer () ( // Bubble Sort-Methode Für (int out \u003d elems - 1; aus\u003e \u003d 1; out--) (// externen Zyklus für (int in \u003d 0; in out ; in ++) ( // interner Zyklus Wenn (A [IN]\u003e A [IN + 1]) // Wenn die Reihenfolge der Elemente kaputt ist Toswap (in, in + 1); // Rufen Sie die Methode an, die sich an Orten ändern } } }

Hier sollten Sie auf die zwei Meter achten: Außenlaus und intern in. Externer Gegenausdruck. Beginnt die Büste der Werte vom Ende des Arrays und nimmt allmählich mit jedem neuen Durchgang pro Einheit ab. Die OUT-Variable mit jedem neuen Durchgang wird auf alle Links verschoben, um die bereits in der rechten Seite des Arrays bereits sortierten Werte nicht zu beeinflussen. Interner Meter in. Beginnt die Büste der Werte vom Anfang des Arrays und erhöht sich allmählich um einen auf jedem neuen Pass. Die Erhöhung des Eintritts erfolgt, bis er reicht (das letzte in dem aktuelle Durchgang analysierte Element). Der interne Zyklus in erzeugt einen Vergleich von zwei benachbarten in- und in + 1 -Zellen. Wenn in IN IN IN IN + 1 gespeichert ist, wird die TOSWAP-Methode aufgerufen, die diese beiden Zahlen an Stellen ändert.

Fazit

Der Algorithmus der Blasensortierung ist einer der langsamsten. Wenn das Array aus N-Elementen besteht, wird der erste Durchgang von N-1-Vergleiche auf dem zweiten N-2, dann N-3 usw. durchgeführt. Das heißt, die Pässe werden durchgeführt: (N - 1) + (n-2) + (n-3) + ... + 1 \u003d n x (n - 1) / 2 Beim Sortieren des Algorithmus führt somit etwa 0,5 × (n ^ 2) Vergleiche. Für N \u003d 5 beträgt die Vergleichsmenge etwa 10, für n \u003d 10 wird die Menge an Vergleichsmengen auf 45 wachsen. Somit erhöht sich die Komplexität der Sortierung deutlich:

Die Geschwindigkeit des Algorithmus betrifft nicht nur die Anzahl der Durchgänge, sondern auch die Anzahl der Permutationen, die erforderlich sind. Für zufällige Daten beträgt die Anzahl der Permutationen im Durchschnitt (n ^ 2) / 4, dh etwa halb weniger als die Anzahl der Pässe. Im schlimmsten Fall kann die Anzahl der Permutationen jedoch auch n ^ 2/2 sein - dies ist, wenn die Daten anfänglich in umgekehrter Reihenfolge sortiert sind. Trotz der Tatsache, dass dies ein ausreichend langsamer Algorithmus des Sortierens ist, wissen und verstehen, wie es ganz vor allem funktioniert, außerdem, wie bereits erwähnt, es ist die Basis für komplexere Algorithmen. JGD!

Hallo zusammen!

Heute werden wir die Sortierung nach der "Blase" -Methode prüfen. Dieser Algorithmus wird häufig in Schulen und Universitäten eingesetzt, sodass wir die Pascal-Sprache verwenden werden. Und also was sortiert? Sortierung ist die Reihenfolge von Elementen von kleiner bis mehr (Sortierung in aufsteigend) oder von einem größeren Element bis zu einem kleineren (Sortieren absteigend). Sortieren normalerweise Arrays.

Es gibt verschiedene Sortieralgorithmen. Einige, die eine große Anzahl von Elementen sortieren, andere, andere, effizienter mit einer sehr kleinen Anzahl von Elementen. Unsere Bubble-Methode ist charakteristisch:

Pros:

• Einfach, den Algorithmus zu implementieren
• Schöner Name

Minus:

• Eine der langsamsten Sortiermethoden (Ausführungszeit ist quadratisch von der Länge des Arrays n 2 abhängig)
• Fast nicht im wirklichen Leben (hauptsächlich für Schulungszwecke) verwendet (hauptsächlich verwendet)

Lassen Sie uns ein bestimmtes Array haben: 3 1 4 2

Algorithmus: Wir nehmen ein Element des Arrays ein, vergleichen Sie das Folgende, wenn unser Element mehr als der nächste Artikel, dann wechseln wir sie an Orten. Nachdem wir das gesamte Array durchlaufen haben, können wir sicher sein, dass das maximale Element "ausgeschoben" wird - und letztendlich letztendlich ertönt. Somit ist ein Element bereits genau an ihrer Stelle. weil Wir müssen sie alle an unserem Platz platzieren, daher müssen wir diesen Vorgang so oft wiederholen, da wir die Elemente des Arrays minus 1. Das letzte Element wird automatisch automatisch stehen, wenn der Rest an ihren Orten steht.

Gehen wir zurück in unser Array: 3 1 4 2
Wir nehmen das erste Element "3", das mit dem folgenden "1" verglichen werden. weil "3"\u003e "1", dann wechseln wir Orte:
1 3 4 2
Jetzt mit dem Vergleich "3" und "4", ist der Troika nicht mehr als der vierte, es bedeutet nichts. Vergleichen Sie "4" und "2". Vier mehr als zwei - es bedeutet, dass wir die Orte ändern: 1 3 2 4. Der Zyklus endete. Das größte Element muss also bereits an seiner Stelle stehen !! Wir sehen, dass wir passiert sind. Wo immer "4" (unser größtes Element) nicht - er war nicht - er ist immer noch, nachdem er den Zyklus des gesamten Arrays passiert hat, der letzte sein wird. Analogie - als Luft-Bubble schwimmt in Wasser - sowohl unseres Elements in einem Array. Daher wird der Algorithmus als "Bubble Sorting" bezeichnet. Um den nächsten Punkt zu positionieren, müssen Sie den Zyklus zuerst starten, aber das letzte Element kann nicht mehr in Betracht gezogen werden, da es an seiner Stelle ist.

Vergleichen Sie "1" und "3" - wir ändern nichts.
Vergleichen Sie "3" und "2" - drei mehr als zwei, dann wechseln wir Orte. Es stellt sich heraus: 1 2 3 4. Der zweite Zyklus wurde abgeschlossen. Wir haben bereits zwei Zyklen gemacht - es bedeutet, dass wir sagen können, dass wir haben, die letzten beiden Elemente sind bereits sortiert. Es bleibt, das dritte Element zu sortieren, und der vierte, steigt automatisch an der richtigen Stelle an. Wieder einmal vergleichen wir das erste Element und den zweiten - wir sehen, dass wir alles an unseren Orten haben, es bedeutet, dass ein Array in Betracht gezogen werden kann, sortiert durch zunehmende Elemente.

Nun ist es weiterhin, den Algorithmus in der Pascal-Sprache zu programmieren. const n \u003d 4; (Wir bringen die Konstante, es ist die Länge des Arrays) VAR i, J, K: Ganzzahl; (Zwei Variablen für den investierten Zyklus, eines, um die Elemente an Orten zu ändern) m: Array der Ganzzahl; (Wir bringen das Array mit) beginnen (wir fordern ein Array von der Tastatur an :) writeln ("ein Array eingeben:"); Für i: \u003d 1 bis n starten writeln (i, element: "); Readln (m [i]); Ende; (Der externe Zyklus ist dafür verantwortlich, dass wir den inneren Zyklus so oft wie die Elemente des Arrays von minus 1 wiederholen müssen) für i: \u003d 1 bis n-1 starten (der innere Zyklus bewegt sich bereits die Elemente und vergleicht sich gegenseitig.) FÜR J: \u003d 1 bis Ni (falls ein Element, mehr als der nächste, dann die Orte ändern.) Wenn M [J]\u003e Männer beginnen K: \u003d m [j]; m [j]: \u003d m; M: \u003d k; Ende; Ende; Ende; (Das Ergebnis ausgeben :) für i: \u003d 1 bis n schreiben (m [i], ""); Ende.
Hier ist das Ergebnis:

Aber das Video-Tutorial