Пузырьковые сортировки:
Это должно сравнить два смежных элемента последовательно в соответствии с индексом. Если они больше, чем/меньше, чем (в зависимости от того, нужно ли они отсортировать, восходящие или спустившиеся), они будут заменены. В противном случае не будет никаких изменений таким образом. После сравнения n-1, n равна количеству элементов; n-2, n-3 ... до последнего раунда их сравнивают один раз, поэтому количество сравнений уменьшается: от N-1 до 1
Тогда общее количество сравнений составляет: 1+2+3+...+(n-1), рассчитанное по арифметической формуле: (1+n-1)/2*(n-1) ==> n/2*(n-1) ==> (n^2-n)*0.5
Временная сложность алгоритма выражается большим O: O (n^2), а коэффициент 0,5 и постоянный -n игнорируются.
public class bubblesort {public static void main (string [] args) {int len = 10; int [] ary = new int [len]; Случайный случайный = new Random (); for (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); } System.out.println ("-----------------"); for (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); }/** Вознесенный порядок, ASC1 и ASC2 оптимизируют количество сравнений внутренних петель, которые лучше* общее сравнение:* ASC1, ASC2: (1+N-1)/2* (n-1) ==> n/2* (n-1) ==> n* (n-1)/2 ==> (n^2-n)/2* asc: n^2-n*///порядок (ary); // orderasc2 (ary); orderasc1 (ary); // нисходящий порядок, просто необходимо заменить размер суждения} static void orderasc (int [] ary) {int count = 0; // количество сравнений int len = ary.length; for (int j = 0; j <len; j ++) {// количество внешних фиксированных циклов для (int k = 0; k <len - 1; k ++) {// Количество внутренних фиксированных петлей if (ar]> ary [k + 1]) {ary [k] = ary [k + 1] (ary [k + 1] = ary [k] = arep -step. значения переменных * a = a+b * b = ab * a = ab */} count ++; }} System.out.println ("/n ------ Order ASC после сортировки в порядке возрастания --------- Номер времени:" + count); for (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }} static void orderasc1 (int [] ary) {int count = 0; // номер сравнения int len = ary.length; for (int j = 0; j <len; j ++) {// количество фиксированных петель во внешнем слое для (int k = len - 1; k> j; k--) {// количество сравнений во внутреннем слое от большего до меньшего количества if [k] <ary [k - 1]) {ary [k] = ary [k - 1]+(k - 1]) {k] = ary [k - 1]. 0; // Один шаг обмен} count ++; } } System.out.println("/n------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (int j = 0; j < len; j++) { System.out.print (ary [j] + ""); = 0; Заказ ------ Номер раз: " + count); for (int j = 0; j <len; j ++) {System.out.print (ary [j] +" ");}}}}Печать
-------Before sorting------ 898 7 862 286 879 660 433 724 316 737 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Двусторонний пузырь
Bubble sorting_cocktail Sorting-это двусторонняя сортировка пузырьков.
Разница между этим алгоритмом и сортировкой пузырьков состоит в том, что при сортировке он сортируется в двух направлениях в последовательности, а наружный слой сравнивает левую и правую границы l <,
Цикл во внутреннем слое пропорционален слева направо, а высокое значение установлено после; Цикл основан на праве налево, и низкое значение установлено ранее;
С точки зрения эффективности, O (n^2), не быстрее, чем обычные пузыри
открытый класс bubble_cocktailsort {public static void main (string [] args) {int len = 10; int [] ary = new int [len]; Случайный случайный = new Random (); for (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); }/** Минимальное количество обменов составляет 1 время, а максимальное число составляет (n^2-n)/2 раза*/// ary = new int [] {10,9,8,7,6,5,4,3,2,1}; // проверить количество обменов // ary = new int [] {1,2,3,4,5,6,7,8,10,9}; // тестовые обмены System.out.println ("---------------------------"); for (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); } orderasc1 (ary); // orderasc2 (ary); // в зависимости от порядка, просто необходимо заменить размер суждения} static void orderasc1 (int [] ary) {int comparecount = 0; // сравнить время int Changecount = 0; // Количество обменов int len = ary.length; int left = 0, справа = len -1, tl, tr; В то время как (слева <справа) {// количество фиксированных циклов внешнего слоя tl = левое + 1; tr = справа - 1; для (int k = слева; k <справа; k ++) {// количество сравнений внутреннего слоя от большего до меньшего, слева направо, если (a ar [k]> ary [k + 1]) {// фронт больше, чем задняя часть, заместительна [k] = ary [k + 1] + (ar + 1] = ary [k] * 0; tr = k; // Индекс, где находится K, дается TR, а TR представляет значение конечного индекса последующего сравнения, после сравнения слева направо, K представляет индекс слева} CompareCount ++; } right = tr; для (int k = справа; k> слева; k--) {// количество сравнений во внутреннем слое уменьшается от большего до меньшего, от справа налево, если (k] <ary [k-1])) {// Последнее меньше, чем предварительная перспектива ary [k] = ary [k-1]+(ary [k-1] = ary [k] *; tl = k; // В последнем сравнении в раунде назначьте индекс, где k расположен в TL, TL представляет значение начального индекса последующего сравнения. После сравнения справа налево K представляет индекс справа} CompareCount ++; } left = tl; } System.out.println("/n----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- для (; l <r;) {// Количество внешних фиксированных циклов tl = l + 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 после сортировки в порядке возрастания ------- Номер сравнений:" + comparecount + ", обмены:" + ChangeCount); for (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }}}Печать
--------Before sorting------ 783 173 53 955 697 839 201 899 680 677 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------