Blasenart:
Es soll zwei benachbarte Elemente nacheinander gemäß dem Index vergleichen. Wenn sie größer als/weniger sind (je nachdem, ob sie aufsteigend oder absteigend sortiert werden müssen), werden sie ersetzt. Andernfalls wird es auf diese Weise keine Änderungen geben. Nach dem Vergleich der N-1-Zeiten entspricht N gleich der Anzahl der Elemente; N-2, N-3 ... bis zur letzten Runde werden sie einmal verglichen, so dass die Anzahl der Vergleiche abnimmt: von N-1 auf 1
Dann lautet die Gesamtzahl der Vergleiche: 1+2+3+...+(n-1), berechnet durch die arithmetische Formel: (1+n-1)/2*(n-1) ==> n/2*(n-1) ==> (n^2-n)*0,5
Die zeitliche Komplexität des Algorithmus wird durch großes O: O (n^2) ausgedrückt, und der Koeffizient 0,5 und die Konstante -n werden ignoriert.
öffentliche Klasse Bubblesort {public static void main (String [] args) {int len = 10; int [] ary = new int [len]; Random random = new random (); für (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); } System.out.println ("------------------"); für (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); }/** Ascending Order, ASC1 und ASC2 optimieren die Anzahl der Vergleiche von internen Schleifen, was besser* Gesamtvergleich ist:* ASC1, ASC2: (1+n-1)/2* (n-1) ==> n/2* (n-1) ==> n* (n-1)/2 ==> (n^2-n)/2* asc: n^2-n*/// ordnungssc); // orderasc2 (ary); Orderasc1 (Ary); // absteigende Reihenfolge, muss nur die Urteilsgröße ersetzen} statische void orderasc (int [] ary) {int count = 0; // Anzahl der Vergleiche int len = ary.length; für (int j = 0; j <len; j ++) {// Anzahl der äußeren festen Zyklen für (int k = 0; k <len - 1; k ++) {// die Anzahl der inneren festen Schleifen, wenn (Ary [k]> Ary [k + 1]) {Ary [k] = ary [k + 1] + (ark [k + 1] = ary [k]) */or -strip [ark [k + 1] 1 ary [k] ark [k) ari/ark [k + 1] Variablenwerte * a = a+b * b = ab * a = ab */} count ++; }} System.out.println ("/n ------ orderasc nach sortiert in aufsteigender order --------- häufige mal:" + count); für (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }} static void orderasc1 (int [] ary) {int count = 0; // Anzahl der Vergleiche int len = ary.length; für (int j = 0; j <len; j ++) {// Anzahl der festen Schleifen in der Außenschicht für (int k = len - 1; k> j; k--) {// Anzahl der Vergleiche in innerer Schicht von mehr zu weniger, wenn (Ary [k] <k - 1] {k] ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ark [k - 1] (ary) (ary) (ark [k - 1] (ark [k - ark [k - 1] (ark [k - ark [k - ark [k - are) (ark [k - ark [k - ark [k - ari) (ark [k - ark [k - ari) wird [(ark [k] arm [k] (ark [k] ()af [ari )ömer Exchange} count ++; }} System.out.println ("/n ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ System.out.print (ary [j] + ""); 0; Reihenfolge ------ Anzahl der Male: " + count); für (int j = 0; j <len; j ++) {System.out.print (ary [j] +" ");}}}}-----
Zwei-Wege-Blase
Bubble Sorting_Cocktail-Sortierung ist eine Zwei-Wege-Bubble-Sortierung.
Der Unterschied zwischen diesem Algorithmus und der Blasensortierung besteht darin, dass es beim Sortieren in zwei Richtungen in der Sequenz sortiert wird und die äußere Schicht die linken und rechten Grenzen vergleicht, l <R,.
Ein Zyklus in der inneren Schicht ist proportional von links nach rechts, und der hohe Wert wird danach festgelegt. Ein Zyklus basiert auf der rechten nach links, und der niedrige Wert wird vorher festgelegt.
In Bezug auf die Effizienz ist O (n^2) nicht schneller als gewöhnliche Blasen
public class bubble_cocktailsort {public static void main (String [] args) {int len = 10; int [] ary = new int [len]; Random random = new random (); für (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); }/** Die minimale Anzahl von Börsen beträgt 1 Zeit und die maximale Anzahl (n^2-n)/2-mal*/// ary = new int [] {10,9,8,7,6,5,4,3,2,1}; // Testen Sie die Anzahl der Börsen // ary = new int [] {1,2,3,4,5,6,7,8,10,9}; // Testen Sie den Austausch system.out.println ("-----------------------"); für (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); } orderasc1 (ary); // orderasc2 (ary); // Abhängig von der Reihenfolge muss nur die Urteilsgröße ersetzen} statische void orderasc1 (int [] ary) {int complexeCount = 0; // vergleiche Zeiten int echneCount = 0; // Anzahl der Börsen int len = ary.Length; int links = 0, rechts = len -1, tl, tr; while (links <rechts) {// die Anzahl der festen Zyklen der äußeren Schicht tl = links + 1; tr = rechts - 1; für (int k = links; k <rechts; k ++) {// die Anzahl der Vergleiche der inneren Schicht von mehr nach links nach rechts, wenn (ary [k]> ary [k + 1]) {// die vordere vordere ist größer als der Rücken, ersetzen Sie Ary [k] = Ary [k + 1] + (ary [k + 1] = äry [k). tr = k; // Der Index, in dem sich k befindet, wird TR angegeben, und TR repräsentiert den Endindexwert des nachfolgenden Vergleichs. Nach dem Vergleich von links nach rechts repräsentiert K den Index auf der linken Seite} CompueCount ++. } rechts = tr; for (int k = right; k > left; k--) {//The number of comparisons in the inner layer is reduced from more to less, from right to left if (ary[k] < ary[k - 1]) {//The latter is less than the pre-permutation ary[k] = ary[k - 1] + (ary[k - 1] = ary[k]) * 0;//One-step exchange changeCount++; tl = k; // Im letzten Vergleich in einer Runde den Index zuweisen, in dem K TL befindet, repräsentiert TL den Startindexwert des nachfolgenden Vergleichs. Nach dem Vergleich von rechts nach links repräsentiert K den Index auf der rechten Seite} Vergleiche ++; } links = tl; } System.out.println ("/n ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- für (; l <r;) {// die Anzahl der äußeren festen Zyklen tl = l + 1; Ary [k+1]; 1]; ary [k - 1] = temp - ary [k - 1]; ary [k] = temp - ary [k - 1]; ChangeCount ++; tl = k; } ComparyCount ++; } l = tl; } System.out.println ("/n ----- orderasc2 nach sortiert in aufsteigender Reihenfolge ------- Anzahl der Vergleiche:" + ComparyCount + ", Börsen:" + ChangeCount); für (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }}}--------Before sorting------ 783 173 53 955 697 839 201 899 680 677 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------