冒泡排序BubbleSort

// 冒泡轮数

int cycle = 0;

// 总比较次数

int compare = 0;

// 总交换次数

int swap = 0;

for(int i = 0; i < arr.length - 1; i++) {

cycle++;

for(int j = 0; j < arr.length - 1 - i; j++) {

compare++;

if (arr[j] > arr[j+1]) {

swap++;

int tmp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = tmp;

}

}

System.out.println(“第” + cycle + “轮冒泡后数组为:” + Arrays.toString(arr));

}

System.out.println(“冒泡轮数:” + cycle + “\n总比较次数:” + compare + “\n总交换次数:” + swap);

System.out.println(“冒泡排序后数组为：” + Arrays.toString(arr));

}

}

冒泡优化-有序区

========

上面每轮冒泡的比较次数为 arr.length - 1 - i ，其中 i 代表的就是冒泡轮数

即：每轮比较后都会确定一个的最大值，比如第一轮确定1个最大值，第二轮确定2个最大值

这些“最大值”的位置就是排序完成后的位置，即 (arr.length - 1 - i) ~ (arr.length - 1) 索引的元素就是有序区。

但是有一种情况，如数组

[6,5,4,3,2,1,7,8,9]

第一轮i=0冒泡后

[5,4,3,2,1,6,7,8,9]

按照上面有序区界定方法 (arr.length - 1 - i) ~ (arr.length - 1)，即 只有9是有序区

但是可以发现其实6,7,8,9都是有序区，其界定方法就是最后一次交换位置的地方

import java.util.*;

public class BasicBubbleSort{

public static void main(String[] args){

int[] arr = new int[]{0,1,2,7,3,6,5,4,8,9};

System.out.println(“原数组为：\t”+Arrays.toString(arr));

sort(arr);

}

public static void sort(int[] arr){

// 冒泡轮数

int cycle = 0;

// 总比较次数

int compare = 0;

// 总交换次数

int swap = 0;

int borderIndex = arr.length - 1;

int lastSwapIndex = 0;

for(int i = 0; i < arr.length - 1; i++) {

cycle++;

for(int j = 0; j < borderIndex; j++) {

compare++;

if (arr[j] > arr[j+1]) {

swap++;

int tmp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = tmp;

lastSwapIndex = j;

}

}

borderIndex = lastSwapIndex;

System.out.println(“第” + cycle + “轮冒泡后数组为:” + Arrays.toString(arr));

}

System.out.println(“冒泡轮数:” + cycle + “\n总比较次数:” + compare + “\n总交换次数:” + swap);

System.out.println(“冒泡排序后数组为：” + Arrays.toString(arr));

}

}

冒泡优化-整体有序识别

===========

前面排序结果发现，在整体有序后，由于冒泡外层for循环轮数还没有结束，所以就算整体有序后，还是在无意义循环冒泡。

所以当整体有序时，就可以终止冒泡。

整体有序时刻其实就是一轮冒泡过程中没有发生交换元素的情况。

import java.util.*;

public class BasicBubbleSort{

public static void main(String[] args){

int[] arr = new int[]{0,1,2,7,3,6,5,4,8,9};

System.out.println(“原数组为：\t”+Arrays.toString(arr));

sort(arr);

}

public static void sort(int[] arr){

// 冒泡轮数

int cycle = 0;

// 总比较次数

int compare = 0;

// 总交换次数

int swap = 0;

int borderIndex = arr.length - 1;

int lastSwapIndex = 0;

for(int i = 0; i < arr.length - 1; i++) {

cycle++;

boolean finished = true;

for(int j = 0; j < borderIndex; j++) {

compare++;

if (arr[j] > arr[j+1]) {

swap++;

int tmp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = tmp;

lastSwapIndex = j;

finished = false;

}

}

if(finished){

break;

}

borderIndex = lastSwapIndex;

System.out.println(“第” + cycle + “轮冒泡后数组为:” + Arrays.toString(arr));

}

System.out.println(“冒泡轮数:” + cycle + “\n总比较次数:” + compare + “\n总交换次数:” + swap);

System.out.println(“冒泡排序后数组为：” + Arrays.toString(arr));

}

}

冒泡优化-双向冒泡，鸡尾酒排序，无序区

===================

上面的冒泡是单向冒泡，即大的元素向上冒泡。单向冒泡可以界定出有序区，即最后一次交换元素的位置到arr.length-1索引位置。

最后

给大家分享一些关于HTML的面试题。

shadow_50,text_Q1NETiBA5LyP5Z-O5LmL5aSW,size_20,color_FFFFFF,t_70,g_se,x_16)

冒泡优化-双向冒泡，鸡尾酒排序，无序区

===================

上面的冒泡是单向冒泡，即大的元素向上冒泡。单向冒泡可以界定出有序区，即最后一次交换元素的位置到arr.length-1索引位置。

最后

给大家分享一些关于HTML的面试题。

[外链图片转存中…(img-ISssbrWw-1719241694252)]
[外链图片转存中…(img-wohckMuX-1719241694254)]