本章讲述数据结构中的六大排序算法 欢迎大佬们踊跃讨论，感谢大家支持！ 我的博客主页链接

一.插入排序

1.1 直接插入排序

1.已知第一个元素如果不包含其他元素，没有元素可以比较，为有序。
2.我们可以直接从第二个元素i开始，创建一个对象tmp来接下标元素，如果比前一个元素小，前一个元素往后移动，tmp插入i-1下标
3.当元素大于或者等于时，则tmp直接放在i位置即可。

  public static void insertSort(int[] array){
        for(int i=1;i<array.length;i++){//由数组1下标开始进行比较
            int tmp=array[i];
            int j=i-1;
            for(;j>=0;j--){
                if(tmp<array[j]){
                    array[j+1]=array[j];//将j放入j+1位置
                }else{
                //进入else则为有序，break跳出嵌套循环
                    break;
                }
            }
      //当嵌套的for循环一直在比较最小值tmp，知道为-1跳出循环，这里需要j+1
      //当大于时候，因为i-1赋值给j，break跳出后j需要+1下标值得到tmp
            array[j+1]=tmp;
        }
    }

时间复杂度:最坏情况时间复杂度为O(N*N)
最好情况时间复杂度为O(N)
空间复杂度O(1)
稳定排序

1.2 希尔排序

希尔排序又称缩小增量法。
希尔排序的思想，定义一个整数，将待排序数组元素长度分成多个组，每一个组进行插入排序，重复上述分组，此时为预排序。当到达1时，将所有记录好的元素在一组中进行排序。
每一次分组排序后都变为有序，每组数据由少变多，越来越有序。

划分为n/2组进行比较，根据n/2的距离来划分每一组的数量。

   public static void shellSort(int[] array){
        int gap=array.length;
        while(gap>1){
            gap/=2;//将数组/2，有多组变少组直到为1
            shell(array,gap);
        }
    }
    public static void shell(int[] arr,int gap){
    //从gap开始遍历
        for(int i=gap;i<arr.length;i++){
        //获取gap下标的值
            int tmp=arr[i];
            求i-gap个差距得到j值
            int j=i-gap;
            for(;j>=0;j-=gap){
                if(tmp<arr[j]){
                    arr[j+gap]=arr[j];
                }else{
                    break;
                }
            }
            arr[j+gap]=tmp;
        }
    }

时间复杂度O(N^1.25)
空间复杂度O(1)

二.选择排序

2.1 单向选择排序

单向选择排序通过定义minIndex值来获取最小的元素下标，然后与0下标进行交换

   public static void selectSort2(int[] array){
        for(int i=0;i<array.length;i++){
            int minIndex=i;

            for(int j=i+1;j<array.length;j++){
                if(array[j]<array[minIndex]){
                    minIndex=j;
                }
            }
            swap(array,minIndex,i);
        }
    }

2.2双向选择排序

双向选择排序是我们通过定义起始位置和终点位置的下标作为条件，通过初始位置筛选最大值和最小值的下标，将最大值下标与尾部交换，最小值下标与初始位置交换，然后继续重复上述，知道筛选完成。

这里如果max的最大值为0下标的时候，max已经被 minIndex交换，maxIndex等于minIndex获取最大元素的下标值即可。

 public static void selectSort(int[] array){
        //起始位置和末尾的下标值
        int left=0;
        int right=array.length-1;
        while(left<right){
            //都从0下标开始比较
            int maxIndex=left;
            int minIndex=left;
            for(int i=left+1;i<=right;i++){
                if(array[i]<array[minIndex]) minIndex=i;
                if(array[i]>array[maxIndex]) maxIndex=i;
            }
            swap(array,left,minIndex);
            //如果0下标就是maxIndex的最大值，minIndex的位置就是maxIndex的最大值
            if(maxIndex==left)maxIndex=minIndex;
            swap(array,right,maxIndex);
            left++;
            right--;
        }
    }
    

时间复杂度：O(N^2)
空间复杂度：O(1)

2.3 堆排序

堆序详情堆排序

 //创建二叉堆
    public static void createHeap(int[] array){
        for(int parent=(array.length-1-1)/2;parent>=0;parent--){
            siftDown(array,parent,array.length);
        }
    }
    private static void siftDown(int[] array,int parent,int size) {
        int child=2*parent+1;
        while(child<size){
            if(child+1<size&&array[child]<array[child+1]){
                //child是左右孩子的最大值
                child=child+1;
            }
            if(array[child]>array[parent]){
                //交换孩子与父亲
                swap(array,child,parent);
                //调整父亲节点和孩子节点
                parent=child;
                child=(2*parent)+1;
            }else{
                break;
            }
        }
    }
    //根据创建好的大跟堆，通过最后一个下标与0下标交换后缩小堆的范围，直到称为有序数组
    public static void heapSort(int[] array){
        createHeap(array);
        int end=array.length-1;
        while(end>0){
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }

时间复杂度O(N*logN)
空间复杂度O(1)

三.交换排序

3.1 冒泡排序

冒泡排序是一种较为简单的排序算法，它循环需要排序的元素，依次比较相邻的两个元素，如果顺序错误就进行交换，直至没有元素交换，完成排序，若对数组n个元素进行比较，则需要比较n-1次，最后一个元素已经被前n-1个元素排序好。
排序一次将len-1最大值放到最后，直到有序
本代码中的flag来记录是否有序，如果有序，则直接跳出循环。

 public static void bubbleSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            boolean flag=false;//这里标记一下，每一趟中，给flag置为false，当每趟为有序后，则不进入if语句直接停止循环
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                    flag=true;
                }
            }
            if(!flag){
                break;
            }
        }
    }

时间复杂度：最好情况下：O(n)
最坏情况下：O(n^2)
空间复杂度:O(1)
稳定排序

3.2 快速排序

3.2.1 Hoare排序

1.首先设定一个分界值，通过该分界值将数组分成左右两部分。
2、将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
3、然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4、重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

这里定义一个left为左，right为右，将任意左右位置两边定义一个基准值，根据基准值的大小，直到left为大于基准值数，right为小于基准值数停下，若定义左边为基准值则右边先走，同理右边为基准值左边先走。

 //快速排序
    public static void quickSort(int[] array){
        //记录左起始位置和右边的结束位置进行递归
        quick(array,0,array.length-1);
    }
public static void inSert(int[] array,int left,int right){
        for(int i=left+1;i<=right;i++){
            int tmp=array[i];
            int j=i-1;
            for(;j>=left;j--){
                if(array[j]>tmp){
                    array[j+1]=array[j];
                }else {
                    break;
                }
            }
            array[j+1]=tmp;
        }
    }
    private static void quick(int[] array, int left, int right) {
        if(left>=right)return ;//说明两个相遇或者走出范围
        //当长度少时直接插入排序
        if(right-left+1<=10){
            inSert(array,left,right);
            return ;
        }
        int index = middleNum(array,left,right);
        System.out.println("index下标值:"+index);
        //用来交换left和right范围内元素且最终将首位元素与相遇值交换
        swap(array,left,index);
        int pos=partitionPointer(array,left,right);//递归
        quick(array,left,pos-1);
        quick(array,pos+1,right);
    }

    private static int partitionHoare(int[] array, int left, int right) {
        int record=left;//记录left最后交换
        int tmp=array[left];//比较大小
        while(left<right){
            while(left<right&&array[right]>=tmp){//右边找到小于tmp
                right--;
            }
            while(left<right&&array[left]<=tmp){//左边找到大于tmp
                left++;
            }
            swap(array,left,right);
        }
        //这里left与right相遇
        swap(array,record,left);
        return left;
    }

时间复杂度：最坏情况下N*(logN)
最好情况下：O(N^2) 有序或者逆序情况下
空间复杂度:最好情况下O(logN)
最坏情况下：O(N) 有序或者逆序情况下
数据多时因递归可能容易栈溢出

3.2.2 挖坑法

1.由左或者右选出第一个坑位记录元素值，放入key中，创建left和right对数组遍历，当选左坑右走，右坑左走，直到right和left相遇后将记录的坑位元素值放入即可。

 public static void quickSort(int[] array){
        //记录左起始位置和右边的结束位置进行递归
        quick(array,0,array.length-1);
    }
    
public static void inSert(int[] array,int left,int right){
        for(int i=left+1;i<=right;i++){
            int tmp=array[i];
            int j=i-1;
            for(;j>=left;j--){
                if(array[j]>tmp){
                    array[j+1]=array[j];
                }else {
                    break;
                }
            }
            array[j+1]=tmp;
        }
    }
    private static void quick(int[] array, int left, int right) {
        if(left>=right)return ;//说明两个相遇或者走出范围
        if(right-left+1<=10){
            inSert(array,left,right);
            return ;
        }
        int index = middleNum(array,left,right);
        System.out.println("index下标值:"+index);
        //用来交换left和right范围内元素且最终将首位元素与相遇值交换
        swap(array,left,index);
        int pos=partitionPointer(array,left,right);//递归
        quick(array,left,pos-1);
        quick(array,pos+1,right);
    }
    
    private static int partitionPit(int[] array, int left, int right) {
        int record=array[left];//记录起始坑位
        while(left<right){
            while(left<right&&array[right]>=record){//右边找到小于tmp
                right--;
            }
            //说明找到小于tmp的值
            array[left]=array[right];
            while(left<right&&array[left]<=record){//左边找到大于tmp
                left++;
            }
            //说明找到大于tmp的值
            array[right]=array[left];
        }
        //这里left与right相遇后将记录的首个坑填入
        array[left]=record;
        return left;
    }

3.2.3 前后指针法

cur指向起始位置+1，pre是cur的前一位
判断条件：如果cur找到基准值（最初位置key为5），前一项的条件满足后prev向后走不为cur（为cur则不交换），直到prev在前cur在后且cur<基准值
cur如果大于基准值，直到cur找到小于基准值的数或者走完，直到递归调整为升序。

   public static void quickSort(int[] array){
        //记录左起始位置和右边的结束位置进行递归
        quick(array,0,array.length-1);
    }


public static void inSert(int[] array,int left,int right){
        for(int i=left+1;i<=right;i++){
            int tmp=array[i];
            int j=i-1;
            for(;j>=left;j--){
                if(array[j]>tmp){
                    array[j+1]=array[j];
                }else {
                    break;
                }
            }
            array[j+1]=tmp;
        }
    }
    private static void quick(int[] array, int left, int right) {
        if(left>=right)return ;//说明两个相遇或者走出范围
        if(right-left+1<=10){
            inSert(array,left,right);
            return ;
        }
        int index = middleNum(array,left,right);
        System.out.println("index下标值:"+index);
        //用来交换left和right范围内元素且最终将首位元素与相遇值交换
        swap(array,left,index);
        int pos=partitionPointer(array,left,right);//递归
        quick(array,left,pos-1);
        quick(array,pos+1,right);
    }

    private static int partitionPointer(int[] array, int left, int right) {
        //记录cur的前一项
     int Prev=left;
     int cur=left+1;
     while(cur<=right){
         //cur与起始位置比较只有小于才能进行交换且prev不为cur
         if(array[cur]<array[left]&&array[++Prev]!=array[cur]){
             swap(array,cur,Prev);
         }
         cur++;
     }
     //交换最后记录的cur的值
     swap(array,left,Prev);
     return Prev;
    }

3.4 非递归快速排序

这里非递归排序的情况下，因为每次最左边的数我们需要申请一个栈来记录其区间值，出栈由区间值一步步缩小取值的范围并进行交换，重复上述即可。

 public static void quickNor(int[] array){
      quickSortNor(array,0,array.length-1);
    }

    private static void quickSortNor(int[] array, int left, int right) {
        Stack<Integer> stack=new Stack<>();
        int pivot=partitionHoare(array,left,right);
        if(pivot>left+1){
            stack.push(left);
            stack.push(pivot-1);
        }
        if(pivot+1<right){
            stack.push(pivot+1);
            stack.push(right);
        }
        while(!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            pivot=partitionHoare(array,left,right);
            if(pivot>left+1){
                stack.push(left);
                stack.push(pivot-1);
            }
            if(pivot+1<right){
                stack.push(pivot+1);
                stack.push(right);
            }
        }

四.归并排序

4.1 递归归并排序

定义一个分界线mid来获取其中间值，递归左边和右边，每次进入方法进行排序
将左起始到中间值与中间值到右侧比较，创建一个数组来记录，排序后放到数组中，最后让原数组接收。

    public static void mergeSort(int[] array){
        mergeSortM(array,0,array.length-1);
    }

    private static void mergeSortM(int[] array, int left, int right) {
    //知道left和right相遇返回
        if(left>=right)return ;
        int mid=(left+right)/2;
      //以中间值作为分区，递归左边和右边
        mergeSortM(array,left,mid);
        mergeSortM(array,mid+1,right);
        //每次递归传入后进行排序
        merge(array,left,mid,right);
    }

    private static void merge(int[] array, int left, int mid, int right) {
        int[] tmpArr=new int[right-left+1];//创建一个数组接收每一次递归的数组
        int k=0;
          //记录左边的起始位置与右边起始位置
        int s1=left;
        int s2=mid+1;
        while(s1<= mid &&s2<= right){
            if(array[s1]<=array[s2]){
                tmpArr[k++]=array[s1++];
            }else{
                tmpArr[k++]=array[s2++];
            }
        }
        while(s1<= mid){
            tmpArr[k++]=array[s1++];
        }
        while(s2<= right){
            tmpArr[k++]=array[s2++];
        }
        for(int i=0;i<tmpArr.length;i++){
        //这里的left跟随着mid改变，当递归右侧时，left为mid+1
            array[i+left]=tmpArr[i];
        }
    }
}

时间复杂度：O(N*logN)
空间复杂度:O(logN)
稳定排序

4.2非递归归并排序

  private static void merge(int[] array, int left, int mid, int right) {
        int[] tmpArr=new int[right-left+1];//创建一个数组接收每一次递归的数组
        int k=0;
        //记录左边的起始位置与右边起始位置
        int s1=left;
        int s2=mid+1;
        while(s1<= mid &&s2<= right){
            if(array[s1]<=array[s2]){
                tmpArr[k++]=array[s1++];
            }else{
                tmpArr[k++]=array[s2++];
            }
        }
        while(s1<= mid){
            tmpArr[k++]=array[s1++];
        }
        while(s2<= right){
            tmpArr[k++]=array[s2++];
        }
        for(int i=0;i<tmpArr.length;i++){
            array[i+left]=tmpArr[i];
        }
    }
    
  public static void mergeNor(int[] array){
       int gap=1;//每组共有几个数据
        while(gap<array.length){
            for(int i=0;i<array.length;i=i+gap*2){
                int left=i;
                int mid=left+gap-1;
                int right=mid+gap;
                if(mid>=array.length)
                    mid=array.length-1;
                if(right>=array.length){
                    right=array.length-1;
                }
               merge(array,left,mid,right);
            }
            gap*=2;
        }
    }

五.测试运行时间代码

  // 有序
    public static void order(int[] arr){
        for(int i=0;i<arr.length;i++){
            arr[i]=i;
        }
    }
    //逆序
     public static void reverse(int[] arr){
        for(int i=0;i<arr.length;i++){
            arr[i]= arr.length-i;
        }
    }
    //无序
    public static void disorder(int[] arr){
        Random random=new Random();
        for(int i=0;i<arr.length;i++){
            arr[i]= random.nextInt(100);
        }
    }

    //测试
    public static void testSort1(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
    long startTime=System.currentTimeMillis();//开始结束记录
        Sort.shellSort(tmpArray);
    long endTime=System.currentTimeMillis();
        System.out.println("希尔排序时间："+(endTime-startTime));
    }

    public static void testSort2(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.inSert(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("插入排序时间："+(endTime-startTime));
    }

    public static void testSort3(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.selectSort2(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("双向选择排序时间："+(endTime-startTime));
    }
    public static void testSort4(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.bubbleSort(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("冒泡排序时间："+(endTime-startTime));
    }
    public static void testSort5(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.heapSort(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("堆排序时间："+(endTime-startTime));
    }
    public static void testSort6(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.quickSort(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("Hoare快速排序时间："+(endTime-startTime));
    }
    public static void testSort7(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.quickSort(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("挖坑法快速排序时间："+(endTime-startTime));
    }
    public static void testSort8(int[] arr){
        int[] tmpArray= Arrays.copyOf(arr,arr.length);
        long startTime=System.currentTimeMillis();//开始结束记录
        Sort.quickSort(tmpArray);
        long endTime=System.currentTimeMillis();
        System.out.println("前后指针法快速排序时间："+(endTime-startTime));
    }