java学习笔记10：java语言数组常用排序（冒泡排序、选择排序、快速排序，直接插入排序）

一、冒泡排序
1、基本思想
设排序表长为n，从后向前或者从前向后两两比较相邻元素的值，如果两者的相对次序不对(A[i-1] > A[i])，则交换它们，其结果是将最小的元素交换到待排序序列的第一个位置，我们称它为一趟冒泡。下一趟冒泡时，前一趟确定的最小元素不再参与比较，待排序序列减少一个元素，每趟冒泡的结果把序列中最小的元素放到了序列的”最前面”。
2、冒泡排序原理图解

代码如下：

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr={24, 69, 80, 57, 13};
        finalSort(arr);
        System.out.println(Arrays.toString(arr));
    }   
    private static void finalSort(int[] arr) {
        for (int j = 0; j <arr.length-1; j++) {
            for (int i = 0; i < arr.length - 1-j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = t;
                }
            }
        }
    }
 }

二、选择排序
1、选择排序基本思想(假设从大到小排序)：
初始化一个数组：int[] array={n个数据}
第1次排序：将索引为0的元素取出来，用该元素与之后的每一个元素做比较，比该元素小则不动，比该元素大则交换二者的数值，依次比较到最后，这样最大值就放到了索引为0的位置。
第2次排序：将索引为1的元素取出来，用该元素与之后的每一个元素做比较，比该元素小则不动，比该元素大则交换二者的数值，依次比较到最后，这样数组中第二大值就放到了索引为1的位置。
依次类推，将倒数第2个元素取出来，与最后一个元素做比较，比该元素小则不动，比该元素大则交换二者的位置。
2、选择排序原理图解

3、代码实现如下

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        // tuiDaosort(arr);
        for (int index = 0; index < arr.length - 1; index++) {
            for (int i = 1 + index; i < arr.length; i++) {
                if (arr[index] > arr[i]) {
                    int t = arr[index];
                    arr[index] = arr[i];
                    arr[i] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

三、快速排序
1、快速排序思想
挖坑填数：
①将基准数挖出形成第一个坑
②由后向前找比它小的数，找出后挖出此数填到前一个坑中
③由前向后找比它大或等于的数，找出后挖出此数填到前一个坑中
④再重复②③两步骤。
2、原理图如下
3、代码如下：

public class Test {
    public static void main(String[] args) {
        int[] arr={2,3,5,10,10,22,0,1,-1,-4,-3,-2};
        QuickSortUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}
class QuickSortUtils {
    public static void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //找到分左右两半的中间索引
            int index = getIndex(arr, start, end);//挖坑填数
            //对左右两区进行递归调用
            quickSort(arr, start, index - 1); //对左半变部分进行递归
            quickSort(arr, index + 1, end);//对右半部分进行递归
        }
    }
    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //找一个基准数
        int x = arr[i];
        while (i < j) {
            // 2. 由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while (i < j && arr[j] >= x) { //如果 这个数比基准数大，让索引倒退
                j--;
            }
            if (i < j) {
                arr[i] = arr[j]; //把这个数填到上一个坑中
                i++; //顺便让 i 递增一下
            }
            //3由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] < x) { //如果这个数比基准数小，就让这个索引往前跑

                i++;
            }
            if (i < j) {
                arr[j] = arr[i]; //填到上一个坑
                j--; //顺便让 j 递减一下
            }
        }
        //等上述完毕之后，把基准数填到最后一个坑位里
        arr[i] = x;
        return i;
    }
}

四、直接插入排序
1、算法思路:直接插入排序,是一种最简单的排序方法.他的基本操作是将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表.假设有一组元素{k1,k2…,kn},排序开始就认为k1是一个有序序列,让k2插入上述表长为1的有序序列,使之成为一个表长为2的有序序列,然后让k3插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列.
2、代码实现如下：

public class ArrayDemo3 {
    public static void main(String[] args) {
        //直接插入排序：每一次把后面一个元素插入到前一个有序列表中，插入进去后，使之仍保持有序
        int[] arr = {1, 0, -1, 2, 4, 6, 7, 10, 8, 5, -2};
        //外层循环定义轮次 [0,-1,1]
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) { //如果当前元素小于我前一个元素，交换位置
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}