冒泡排序法<详解+优化>
冒泡排序法,是个大学生都听过吧,游泳时也会吹个泡泡什么的,这个排序算法被老师作为排序算法的入门算法,很基础,由于名字比较特别,我就一直记住了,今天想把这个写下来。
冒泡思想:
假如将不同的数放在不同的气泡中,依次是最小的数放在最大的气泡中,那么,我们知道,在水中,这些气泡会上浮,越大越容易上浮,那么,当一连串气泡挨在一起时,两个相邻的气泡就会在浮力东风作用下交换位置,浮力大的,也就是大的气泡上浮,就这样,一次交换下去,最后是最大的气泡在最上面。
冒泡排序:
Bubble sort 属于一种交换排序,两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。
两两比较:
@反序:两两交换。
@正序:指针后移,下两个记录两两比较。
看一个冒泡排序一轮排序的的过程:
也就是两两比较,以数组为例,比较过程:
第一轮:数组下标为0的元素与1的元素相比,25<36,正序,指针后移,36>21反序,交换36和21,指针后移,36<45正序,指针后移,45<98正序,指针后移,98>13反序,交换98和13,最后98位于为底端,也就是数组的末尾。比较次数为(n-1)
第二轮:还是从数组下标为0开始两两比较,在第一比较后的结果98就不参与比较,比较次数为(n-2);
......
核心比较和交换的代码:
-
-
-
-
-
- public void bubbleSort(int... array) {
- int length = array.length;
- for (int i = 0; i < length - 1; i++) {
- for (int j = 0; j < length - i - 1; j++) {
- if (array[j] > array[j + 1]) {
- swap(j, j + 1, array);
- }
- }
- }
- }
@注意上边的外部循环的边界是 length-1,因为最后一个元素不用比较了。
- for (int i = 0; i < length - 1; i++)
@内部循环的边界随着外部循环的变化而变化,也就是在前面比较后的记录就不用参与下一轮的比较。
- for (int j = 0; j < length - i - 1; j++)
@swap依然是一个交换数组两个元素的函数:
-
-
-
-
-
-
-
- private void swap(int oneIndex, int anotherIndex, int[] array) {
- int temp = array[oneIndex];
- array[oneIndex] = array[anotherIndex];
- array[anotherIndex] = temp;
- }
那么将完整的代码列出来:
-
-
-
-
-
-
- public class BubbleSort {
-
- public static void main(String[] args) {
- BubbleSort bubbleSort = new BubbleSort();
- int[] array = { 25, 36, 21, 45, 98, 13};
- System.out.println(Arrays.toString(array));
- bubbleSort.bubbleSort(array);
- System.out.println(Arrays.toString(array));
- }
-
-
-
-
-
-
- public void bubbleSort(int... array) {
- int length = array.length;
- for (int i = 0; i < length - 1; i++) {
- for (int j = 0; j < length - i - 1; j++) {
- if (array[j] > array[j + 1]) {
- swap(j, j + 1, array);
- }
- }
- }
- }
-
-
-
-
-
-
-
-
- private void swap(int oneIndex, int anotherIndex, int[] array) {
- int temp = array[oneIndex];
- array[oneIndex] = array[anotherIndex];
- array[anotherIndex] = temp;
- }
- }
小结:冒泡排序法最核心的地方就是两两比较交换了,这种排序法容易被人理解和记忆,实现起来不难,性能稍高于比较排序算法,时间复杂度也是O(n²)
有一个问题来了:就是如果一个数组开始是有序的,照上面的算法,每一次都要进行比较,这样对有序的数组来说是多余的,我们是不是可以做一些改进,在第一轮比较之后,如果发现有序的,就是没有数据交换,后面的比较可以省去,直接跳出循环呢?
----->答案是可以的,这是我们需要一个标记,boolean flag = true;辅助我们,看看下面的代码:
-
-
-
-
-
- public void bubbleSort(int... array) {
- int length = array.length;
- boolean flag = true;
- for (int i = 0; i < length - 1 && flag; i++) {
- flag = false;
- for (int j = 0; j < length - i - 1; j++) {
- if (array[j] > array[j + 1]) {
- swap(j, j + 1, array);
- flag = true;
- }
- }
- }
- }
@上边的代码多了一个 boolean flag = true;
@外部循环的条件也有所改变:
- for (int i = 0; i < length - 1 && flag; i++)
@开始flag为true,能进入循环,已进入循环就将flag = false;:
- for (int i = 0; i < length-1 && flag; i++) {
- flag = false;
@在内部循环中,如果存在反序,又将flag置为true,下一轮就可以进入,反之就直接退出外部循环了:
- if (array[j] > array[j + 1]) {
- swap(j, j + 1, array);
- flag = true;
- }
这样就解决了有序数组重复比较的问题,对象能有所优化。
完整代码如下:
-
-
-
-
-
-
- public class BubbleSortOpt {
-
- public static void main(String[] args) {
- BubbleSortOpt bubbleSort = new BubbleSortOpt();
- int[] array = { 25, 36, 21, 45, 98, 13};
- System.out.println(Arrays.toString(array));
- bubbleSort.bubbleSort(array);
- System.out.println(Arrays.toString(array));
- }
-
-
-
-
-
-
- public void bubbleSort(int... array) {
- int length = array.length;
- boolean flag = true;
- for (int i = 0; i < length-1 && flag; i++) {
- flag = false;
- for (int j = 0; j < length - i - 1; j++) {
- if (array[j] > array[j + 1]) {
- swap(j, j + 1, array);
- flag = true;
- }
- }
- }
- }
-
-
-
-
-
-
-
-
- private void swap(int oneIndex, int anotherIndex, int[] array) {
- int temp = array[oneIndex];
- array[oneIndex] = array[anotherIndex];
- array[anotherIndex] = temp;
- }
- }
上面是对int[] 进行的排序,那么面向对象的这这应用不能只局限于int[] 数组中,也就是任何可以比较的类型都可以用冒泡来排序,下面是优化后的代码的实现:
-
-
-
-
-
-
- public class BubbleSortTOpt {
-
- public static void main(String[] args) {
- BubbleSortTOpt bubbleSort = new BubbleSortTOpt();
- Integer[] array = { 25, 36, 21, 45, 98, 13};
- System.out.println("Before sorting:");
- System.out.println(Arrays.toString(array));
- bubbleSort.bubbleSort(array);
- System.out.println("After sorting:");
- System.out.println(Arrays.toString(array));
- }
-
-
-
-
-
-
- public <T extends Comparable<T>> void bubbleSort(T[] array) {
- int length = array.length;
- boolean flag = true;
- for (int i = 0; i < length - 1 && flag; i++) {
- flag = false;
- for (int j = 0; j < length - i - 1; j++) {
- if (array[j].compareTo(array[j + 1]) > 0) {
- swap(j, j + 1, array);
- flag = true;
- }
- }
- }
- }
-
-
-
-
-
-
-
-
- private <T extends Comparable<T>> void swap(int oneIndex, int anotherIndex,
- T[] array) {
- T temp = array[oneIndex];
- array[oneIndex] = array[anotherIndex];
- array[anotherIndex] = temp;
- }
- }
冒泡冒泡,浮力大了,就会上浮,我们要充实自己,沉淀自己...
"做一个丰盈的男人,不虚华,不浮躁,以先锋的姿态去拼搏奋斗;做一个明媚的女子,不倾国,不倾城,以优雅的姿势去摸爬滚打"