基础算法——冒泡排序

一、冒泡排序的文字描述

1.依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后

2.重复以上步骤，直到整个数组有序

二、冒泡排序的图形演示

1、选择索引0 1的进行比较，i>i+1,则交换

2、索引1 2比较

3、索引2 3比较，交换

4、索引3 4比较

5、索引 4 5比较 交换

6、索引5 6比较 

 

7、第二轮 索引0 1比较

 8、第二轮索引1 2比较，交换

 

9、第三轮0 1比较，交换

后面还会遍历继续遍历4轮，那么后面会进行改进

三、冒泡排序算法（无脑版）

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5, 2, 7, 4, 1, 3, 8, 9};
        bubble(a);
    }

    public static void bubble(int[] a) {
        for (int j = 0; j < a.length - 1; j++) {
            // 一轮冒泡
            for (int i = 0; i < a.length - 1; i++) {
                if (a[i] > a[i + 1]) {
                    swap(a, i, i + 1);
                }
            }
            System.out.println("第" + j + "轮冒泡"
                    + Arrays.toString(a));

        }
    }

    public static void swap(int []a,int i,int j){
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }

}

运行结果：

 四、冒泡排序改进版1

思路：内层循环每次比较次数都是数组长度-1，但不是每次都需要比较数组长度-1次，第一轮冒泡后，最后一个元素已经是固定位置，后续每一轮都会多一个固定位置元素，那只要把内层循环的数组长度-1-外层循环次数，就可以减少比较次数。还有一个问题，根据以上数据发现第4轮的时候数据已经有序，但基础版依旧进行了两轮才停止。解决方法：如果某一次循环都没有一次数值交换，则数组有序，改进版代码如下：

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5, 2, 7, 4, 1, 3, 8, 9};
        bubble(a);
    }

    public static void bubble(int[] a) {
        for (int j = 0; j < a.length - 1; j++) {
            // 一轮冒泡
            boolean swapped =false;//是否发生交换
            for (int i = 0; i < a.length - 1 - j; i++) {
                if (a[i] > a[i + 1]) {
                    swap(a, i, i + 1);
                    swapped=true;
                }
            }
            System.out.println("第" + j + "轮冒泡"
                    + Arrays.toString(a));
            if(!swapped){
                break;
            }
        }
    }

    public static void swap(int []a,int i,int j){
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

 运行结果：

  四、冒泡排序改进版2

 思路：记录最后一次交换位置的索引

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5, 2, 7, 4, 1, 3, 8, 9};
        bubble_v2(a);
    }

    public static void bubble_v2(int[] a) {
        int n = a.length - 1;
        while (true) {
            int last = 0; // 表示最后一次交换索引位置
            for (int i = 0; i < n; i++) {
                if (a[i] > a[i + 1]) {
                    swap(a, i, i + 1);
                    last = i;
                }
            }
            n = last;
            System.out.println("第轮冒泡"
                    + Arrays.toString(a));
            if (n == 0) {
                break;
            }
        }
    }

    public static void swap(int []a,int i,int j){
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

运行结果：不仅轮数变少了，次数也变少了，感兴趣的可以将比较次数打印出来