2. 冒泡排序

1. 算法描述

1. 依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
2. 重复以上步骤，直到整个数组有序

2. 代码实现

package com.zhang.sort;

import java.util.Arrays;

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

        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {

        //外循环，控制总共需要几轮(数组长度减1)
        for (int i = 0; i < arr.length - 1; i++) {

            //内循环，控制每轮依次往后比较几个位置(数组长度减1)
            for (int j = 0; j < arr.length - 1; j++) {
                //若 a[j] > a[j+1]，则交换两个元素
                if(arr[j] > arr[j+1]){
                  swap(arr, j, j+1);
                }
            }

        }
    }


    /**
     交换元素:
     先把arr[i]赋值给一个临时变量
     再把arr[j]的值赋值给arr[i]
     最后把arr[i](tem)给arr[j]，即完成元素交换
     */
    public static void swap(int[] arr, int i,int j){

        int tem = arr[i];
        arr[i] = arr[j];
        arr[j] = tem;
    }
}

3. 优化1

每经过一轮冒泡，内层循环就可以减少一次比较次数

在一轮冒泡后，已经把最大元素排到最后，再下一轮冒泡的时候可以减少一次比较次数

public static void bubbleSort(int[] arr) {

        //外循环，控制总共需要几轮(数组长度减1)
        for (int i = 0; i < arr.length - 1; i++) {
            //内循环，控制每轮依次往后比较几个位置(数组长度减1)
            for (int j = 0; j < arr.length - 1-i; j++) {
                System.out.println("第"+j+"次比较");
                if(arr[j] > arr[j+1]){
                  swap(arr, j, j+1);
                }
            }
            System.out.println("第"+i+"轮冒泡===>"+Arrays.toString(arr));
        }
}

4. 优化2

如果某一轮冒泡没有发生交换，则表示所有数据有序，可以结束外层循环

public static void bubbleSort(int[] arr) {

        //外循环，控制总共需要几轮(数组长度减1)
        for (int i = 0; i < arr.length - 1; i++) {

            Boolean flag = false;//先假设某一轮冒泡没有发生元素交换

            //内循环，控制每轮依次往后比较几个位置(数组长度减1)
            for (int j = 0; j < arr.length - 1-i; j++) {
                System.out.println("第"+j+"次比较");
                if(arr[j] > arr[j+1]){
                  swap(arr, j, j+1);
                  flag = true;//发生元素交换了
                }
            }

            if(!flag){//这一轮冒泡没有交换元素的话，结束外循环
                break;
            }

            System.out.println("第"+i+"轮冒泡===>"+Arrays.toString(arr));
        }
    }

5. 最佳优化

每一轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，表示整个数组有序，直接退出外层循环即可

 private static void bubbleSort(int[] arr) {

        int tmp = arr.length-1;

        while (true) {
            int lastSwapIndex = 0;//一轮冒泡最后交换位置的索引
            for (int j = 0; j < tmp; j++) {

                if(arr[j] > arr[j+1]){
                    swap(arr, j, j+1);
                    lastSwapIndex = j;//一轮冒泡最后交换位置的索引
                }
            }
            tmp = lastSwapIndex;
            if(tmp == 0){
                break;
            }
        }
    }