（七）排序算法（二）

希尔排序

简单插入排序存在的问题：当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响.。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

希尔排序图解

希尔排序时，对有序序列在插入时采用交换法

package com.atguigu.sort;

import java.util.Arrays;

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

    public static void shellSort(int[] arr){
        int temp=0;
        int count=0;
        //根据前面的逐步分析，使用循环处理
        for (int gap = arr.length/2; gap >0 ; gap/=2) {
            for (int i = gap; i <arr.length ; i++) {
                //遍历各组中所有的元素（共gap组，每组有个元素）
                for (int j = i-gap; j >=0 ; j-=gap) {
                    //如果当前元素大于加上步长后的那个元素，说明交换
                    if (arr[j]>arr[j+gap]){
                        temp=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }
            System.out.println("希尔排序第"+(++count)+"轮后="+ Arrays.toString(arr));
        }

        /*
        //希尔排序的第1轮
        //因为第一轮排序。是将10个数据分成了5组
        for (int i = 5; i <arr.length ; i++) {
            //遍历各组中所有的元素（共5组，每组有2个元素）
            for (int j = i-5; j >=0 ; j-=5) {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j]>arr[j+5]){
                    temp=arr[j];
                    arr[j]=arr[j+5];
                    arr[j+5]=temp;
                }
            }
        }
        System.out.println("希尔排序1轮后="+ Arrays.toString(arr));//

        //希尔排序的第2轮
        //因为第2轮排序是将10个数据分成了5/2=2组
        for (int i = 2; i <arr.length ; i++) {
            //遍历各组中所有的元素（共5组，每组有2个元素）
            for (int j = i-2; j >=0 ; j-=2) {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j]>arr[j+2]){
                    temp=arr[j];
                    arr[j]=arr[j+2];
                    arr[j+2]=temp;
                }
            }
        }
        System.out.println("希尔排序2轮后="+ Arrays.toString(arr));

        //希尔排序的第3轮
        //因为第3轮排序是将10个数据分成了2/2=1组
        for (int i = 1; i <arr.length ; i++) {
            //遍历各组中所有的元素（共5组，每组有2个元素）
            for (int j = i-1; j >=0 ; j-=1) {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println("希尔排序3轮后="+ Arrays.toString(arr));

         */
    }
}

交换法的时间复杂度要高于直接插入，所以优化的时候将找到一个，比较完后交换一次改为比较晚一次后移一次，找到待插入位置

    //优化
    public static void shellSort2(int[] arr){
        
        for (int gap = arr.length/2; gap >0 ; gap/=2) {
            //从第gap元素，逐个对其所在的组进行直接插入
            for (int i = gap; i <arr.length ; i++) {
                int j=i;
                int temp=arr[j];//待插入元素
                if (arr[j]<arr[j-gap]){//如果待插入元素比前一个姓梁的元素小才找它的插入位置，否则直接看以一个元素
                    while (j-gap>=0 && temp <arr[j-gap]){
                        //移动
                        arr[j]=arr[j-gap];
                        j-=gap;
                    }
                    //找到插入位置
                    arr[j]=temp;
                }

            }

        }
    }

希尔排序注意点：
1.增量那里三层循环的计算：
第一层for循环 (int gap = arr.length/2; gap >0 ; gap/=2）是增量逐步减小的循环
第二层循环 for (int i = gap; i <arr.length ; i++) i从增量所在的索引开始，当i<数组的长度时，i++;
第三层循环 (int j = i-gap; j >=0 ; j-=gap）j从i-gap所在的索引开始，每次和arr[j+gap]比较
比如当 gap=5/2=2时
2.重点是优化的希尔排序，也就是直接插入，这样才是在直接插入的算法上改进过来的，效率高，交换法的效率还不如直接插入。

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序图解

package com.atguigu.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr={-9,78,0,23,-567,70};
        quickSort(arr,0,arr.length-1);
        System.out.println("arr="+ Arrays.toString(arr));
    }

    public static void quickSort(int[] arr,int left,int right){
        int l=left;//左下标
        int r=right;//右下标
        int pivot=arr[(left+right)/2];//pivot中轴
        int temp=0;
        //while循环的目的是让比pivot值小的放到左边，比pivot值大的放在右边
        while (l<r){
            //在pivot的左边一直找，找到大于等于pivot的值才退出
            while (arr[l]<pivot){//注意这里不能有等于，否则有可能会退不出该循环
                l+=1;
            }
            //在pivot的右边一直找，找到小于等于pivot的值才退出
            while (arr[r]>pivot){
                r-=1;
            }
            //如果l>=r说明pivot的左右两边的值已经按照左边全部是小于pivot的值，右边全是大于等于pivot的值
            if (l>=r){
                break;
            }
            //交换
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

            //即交换完以后，如果左右索引所指的园所有一个和pivot相等，则另一个指针直接移动，没有必要再判断后再交换
            //如果交换完，发现这个arr[l]==pivot值 相等 --，前移
            //这两个if为了优化，没有也可以得到正确结果
//            if (arr[l]==pivot){
//                r-=1;
//            }
//            //如果交换完，发现这个arr[r]==pivot值 相等 ++，后移
//            if (arr[r]==pivot){
//                l+=1;
//            }

        }

        /*
        //如果l==r，必须l++，r--，否则会出现栈溢出
        if (l==r){
            l+=1;
            r-=1;
        }
        //向左递归
        if (left<r){
            quickSort(arr,left,r);
        }
        //向右递归
        if (l<right){
            quickSort(arr,l,right);
        }

         */

        //如果l==r，必须l++，r--，否则会出现栈溢出.
        //也可以将这个相关的if语句不写，在递归时做改动也可以
        //将代码改成
        //向左递归
        if (left<r){
            quickSort(arr,left,r-1);
        }
        //向右递归
        if (l<right){
            quickSort(arr,l+1,right);
        }

    }
}