java排序

初级排序：冒泡排序、插入排序、选择排序

冒泡排序：

     //假设有 n 个数字要比较，那就循环 n-1 次
        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;
                }
            }
        }

插入排序：

        for (int i = 1; i < array.length; i++) {

            //将用来比较的数拿出来（起个小名叫提取数）
            int temp = array[i];
            int j = i;

            //当下标大于零，并且前一个数大于提取数，循环至前一个数小于提取数或下标小于零
            while (j > 0 && array[j - 1] > temp) {
                //将小的数往后移一位
                array[j] = array[j - 1];
                j--;
            }
            //将提取数填入空位
            array[j] = temp;
        }

选择排序：

     //假设有 n 个数字要比较，那就循环 n-1 次
        for (int i = 0; i < array.length-1; i++) {
            for (int j = i+1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }

 

高级排序：希尔排序、快速排序

希尔排序：插入排序的升级版（理解链接：https://blog.csdn.net/qq_39207948/article/details/80006224）

        //希尔排序的增量
        int d = array.length;

        //循环次数：使用希尔增量的方式，即每次折半(循环递减增量)
        for (int gap = d / 2; gap > 0; gap /= 2) {
            //对各个分组进行插入排序（从i(增量)往后遍历）
            for (int i = gap; i < d; i++) {

                //和直接插入排序原理相同，i为当前 “提取数” 的下标
                int temp = array[i];
                // i（下标）- 增量 = 分组中，他前面一个数的下标
                int j = i - gap;
                //判断 “提取数” 是否小于 “分组中靠他前面的数”，是的话就进行插入排序
                while (j >= 0 && temp < array[j]) {
                    array[j + gap] = array[j];
                    j -= gap;
                }
                //将"提取数"空位
                array[j + gap] = temp;

            }
        }

快速排序：冒泡排序的升级版 (理解视频：https://www.bilibili.com/video/av26394341/?p=8)

    public void sort(int[] array, int low, int high) {

        //当起始下标>=最后的下标
        if (low >= high) {
            return;
        }

        int l = low;//l是起始坐标
        int r = high;//r是最后的坐标

        int key = array[l];//key是基数值

        //当l= key && l < r) {
                r--;
            }

            if (l < r) {
                //交换位置
                int temp = array[r];
                array[r] = array[l];
                array[l] = temp;
            }

            //因为基数到了array[l]的位置，所以下标++，找到<=array[l]的值，左边的值小于等于基数值，跳出循环
            while (array[l] <= key && l < r) {
                l++;
            }
            //交换位置
            if (l < r) {
                int temp = array[l];
                array[l] = array[r];
                array[r] = temp;
            }


        }
        //递归基数左边的数组
        sort(array, low, l - 1);
        
        //递归基数右边的数组
        sort(array, l + 1, high);

    }