冒泡排序（基础班--＞优化版--＞优化终极版）

冒泡排序

1. 所谓的冒泡排序就是通过两两相邻数组间的比较，将大的沉到下面，小的放上面。

• 假设有一个待排序的数组{3，9，6，4，7}。
• 相邻数组之间进行比较。
• 第一轮两两数组之间进行比较，我们俗称第一趟：
  
• 经过第一趟的相比，我们发现最大的数字9沉到了最下面。接下来进行第二趟的比较：
  
• 经过第二趟的比较，我们发现次大数字7到了倒数第二位。接下来进行第三趟和第四趟的比较：
  
• 每当我们进行一趟相比较，数组中的一个数字便会被确定位置。5个数字，一共经过4趟比较，便可以确定他的序列。

2. 基础版冒泡排序。代码实现

• 5个数据，因为我们需要跑四趟，而每一趟又要两两比较4次，因此我们需要两个嵌套循环实现。

package day6_10_16;

import java.util.Arrays;

/**
 * @author：fover
 * @date：2020/10/16 10:56
 * @version：1.0
 * @function：冒泡排序
 */
public class Exercise3 {
    public static void bubbleSort(int[] array) {
    	//外循环，控制趟数
        for (int i = 0; i < array.length - 1; i++) {
        	//内循环，控制每一趟两两相邻数字之间比较
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {3,9,6,4,7};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

3. 优化版冒泡排序

• 我们知道，每一趟排序过后，数组中便有一个数被确定了位置。比如第一趟，数组中最大的数便沉到了最底下。以后每次两两相邻数字之间比较的时候，最底下的是最大的数，它永远不会和上一个数交换位置。因此，我们可以控制内循环中循环的次数。

package day6_10_16;

import java.util.Arrays;

/**
 * @author：fover
 * @date：2020/10/16 10:56
 * @version：1.0
 * @function：冒泡排序
 */
public class Exercise3 {
    public static void bubbleSort(int[] array) {
    	//外循环，控制趟数
        for (int i = 0; i < array.length - 1; i++) {
        	//内循环，控制每一趟两两相邻数字之间比较
        	//将内循环的条件缩小，即可
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {2,9,3,5,1};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

4. 最优版–>终极版冒泡排序。

• 假如我们在有一趟的比较之后，发现这个数组已经有序了，那么我们就不需要再进行后面的趟数了。那么如何确定这个数组已经有序了呢？
• 在升序冒泡排序中，前一个数如果比下一个数大，那么交换这两个数的位置。如果在某一趟的比较当中，我们发现这一趟一直没有交换数的位置，那么就说明这个数组已经有序。此时，可以通过定义一个flag来标记它，

package day6_10_16;

import java.util.Arrays;

/**
 * @author：fover
 * @date：2020/10/16 10:56
 * @version：1.0
 * @function：冒泡排序
 */
public class Exercise3 {
    public static void bubbleSort(int[] array) {
    	//外循环，控制趟数
        for (int i = 0; i < array.length - 1; i++) {
        	//定义一个初值true的标志，在内循环中，如果发生了位置交换，就将它置为false
            boolean flag = true;
            //内循环，控制每一趟两两相邻数字之间比较
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
            //通过判断内循环结束后标志的状态，从而判断是否发生交换，进而判断当前数组是否有序
            if (flag) {
                return;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {2,9,3,5,1};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}