Sort Bubble:
Ini untuk membandingkan dua elemen yang berdekatan secara berturut -turut sesuai dengan indeks. Jika mereka lebih besar dari/kurang dari (tergantung pada apakah mereka perlu diurutkan naik atau turun), mereka akan diganti. Kalau tidak, tidak akan ada perubahan dengan cara ini. Setelah membandingkan N-1 kali, N sama dengan jumlah elemen; n-2, n-3 ... sampai putaran terakhir, mereka dibandingkan sekali, jadi jumlah perbandingan menurun: dari n-1 ke 1
Maka jumlah total perbandingan adalah: 1+2+3+...+(n-1), dihitung dengan rumus aritmatika: (1+n-1)/2*(n-1) ==> n/2*(n-1) ==> (n^2-n)*0.5
Kompleksitas waktu algoritma diekspresikan oleh O: O (n^2) yang besar, dan koefisien 0,5 dan konstan -n diabaikan.
Public Class Bubblesort {public static void main (string [] args) {int len = 10; int [] ary = int [len] baru; Acak acak = acak baru (); untuk (int j = 0; j <len; j ++) {ary [j] = random.nextInt (1000); } System.out.println ("-----------------"); untuk (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); }/** Urutan naik, ASC1 dan ASC2 mengoptimalkan jumlah perbandingan loop internal, yang lebih baik* perbandingan total:* ASC1, ASC2: (1+n-1)/2* (n-1) ==> n/2* (n-1) ==> n* (n-1)/2 ==> (n^2-n)/2* Asc: // orderasc2 (ary); orderasc1 (ary); // urutan menurun, hanya perlu mengganti ukuran penilaian} static void orderasc (int [] ary) {int count = 0; // jumlah perbandingan int len = ary.length; for (int j = 0; j < len; j++) {//number of outer fixed cycles for (int k = 0; k < len - 1; k++) {//The number of inner fixed loops if (ary[k] > ary[k + 1]) { ary[k] = ary[k + 1] + (ary[k + 1] = ary[k]) * 0;//One-step exchange/* Exchange two Nilai variabel * a = a+b * b = ab * a = ab */} count ++; }} System.out.println ("/n ------ orderasc Setelah menyortir urutan naik --------- berapa kali:" + hitung); untuk (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }} static void orderasc1 (int [] ary) {int count = 0; // Jumlah perbandingan int len = ary.length; untuk (int j = 0; j <len; j ++) {// Jumlah loop tetap di lapisan luar untuk (int k = len - 1; k> j; k--) {// Jumlah perbandingan dalam lapisan dalam dari lebih banyak ke lebih sedikit if (ary [k] <ary [k - 1]) {ary [k] = ary [k -1] [ary [ary [k - 0; // pertukaran satu langkah} Count ++; } } System.out.println("/n------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (int j = 0; j < len; j++) { System.out.print (ARY [j] + ""); K = 0; System.out.println ("/n ----- Urutan yang disesuaikan dengan orderasc2 ------ jumlah kali:" + hitung);Mencetak
-------Before sorting------ 898 7 862 286 879 660 433 724 316 737 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Sortir gelembung dua arah
Bubble sorting_cocktail sortir adalah penyortiran gelembung dua arah.
Perbedaan antara algoritma ini dan penyortiran gelembung adalah bahwa ketika menyortir, itu diurutkan dalam dua arah dalam urutan, dan lapisan luar membandingkan batas kiri dan kanan l <r,
Siklus di lapisan dalam sebanding dari kiri ke kanan, dan nilai tinggi ditetapkan setelah; Siklus didasarkan pada kanan ke kiri, dan nilai rendah ditetapkan sebelumnya;
Dalam hal efisiensi, o (n^2), tidak lebih cepat dari gelembung biasa
kelas publik bubble_cocktailsort {public static void main (string [] args) {int len = 10; int [] ary = int [len] baru; Acak acak = acak baru (); untuk (int j = 0; j <len; j ++) {ary [j] = random.nextInt (1000); }/** Jumlah pertukaran minimum adalah 1 waktu, dan angka maksimum adalah (n^2-n)/2 kali*/// ary = int baru [] {10,9,8,7,6,5,4,3,2,1}; // Uji jumlah pertukaran // ary = int baru [] {1,2,3,4,5,6,7,8,10,9}; // uji pertukaran system.out.println ("---------------------------"); untuk (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); } orderasc1 (ary); // orderasc2 (ary); // tergantung urutan, hanya perlu mengganti ukuran penilaian} static void orderasc1 (int [] ary) {int compareCount = 0; // bandingkan kali int changeCount = 0; // Jumlah pertukaran int len = ary.length; int kiri = 0, kanan = len -1, tl, tr; while (kiri <kanan) {// Jumlah siklus tetap dari lapisan luar TL = kiri + 1; tr = kanan - 1; untuk (int k = kiri; k <kanan; k ++) {// Jumlah perbandingan lapisan dalam dari lebih banyak ke lebih sedikit, dari kiri ke kanan jika (ary [k]> ary [k + 1]) {// bagian depan lebih besar dari belakang, mengganti ary [k] = ary [k + 1] + (ary [k + 1] = ary [k] = ary [k + 1] + (ary [k + 1] = ary [k] = kn [k + 1] + (ary [k + 1] = ary [k] = K + 1] (ARY [K + 1] = ARY [K + 1] (ARY [K + 1] (ARY [K + 1] (ARY [K + 1] (ARY [K + 1] tr = k; // Indeks di mana k berada diberikan ke TR, dan TR mewakili nilai indeks akhir dari perbandingan berikutnya, setelah dibandingkan dari kiri ke kanan, k mewakili indeks pada kiri} CompareCount ++; } benar = tr; untuk (int k = kanan; k> kiri; k--) {// Jumlah perbandingan dalam lapisan dalam dikurangi dari lebih banyak menjadi lebih sedikit, dari kanan ke kiri jika (ary [k] <ary [k-1]) {// yang terakhir lebih kecil dari 2-kp-1) (K] = AR) [K] = ary [k-1]+(ary [k-1] = ary [k] = ary [k-1]+(ary [k-k-1] = ary [k] = ary [k-1]+(ary [k-1] = ary [k] = ary [k-1]+(ary [k-k- tl = k; // Dalam perbandingan terakhir dalam satu putaran, tetapkan indeks di mana k berada di TL, TL mewakili nilai indeks awal dari perbandingan berikutnya. Setelah membandingkan dari kanan ke kiri, k mewakili indeks di sebelah kanan} CompareCount ++; } kiri = tl; } System.out.println ("/N ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- untuk (; l <r;) {// Jumlah siklus tetap tl = l + 1; ARY [K+1]; 1]; ary [k - 1] = temp - ary [k - 1]; ary [k] = temp - ary [k - 1]; ChangeCount ++; tl = k; } compareCount ++; } l = tl; } System.out.println ("/n ----- orderasc2 Setelah menyortir urutan menaik ------- jumlah perbandingan:" + compareCount + ", pertukaran:" + changeCount); untuk (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }}}Mencetak
--------Before sorting------ 783 173 53 955 697 839 201 899 680 677 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------