全网最全的排序代码整理，没有之一

全网最全的排序代码整理，没有之一,各个具体的排序原理，思考步骤在我之前的博客里面，这里知识对所有的排序代码进行一个整理，想看每个排序的思想可以去找之前的博客文章

//冒泡排序
public static void bubbleSort(int[] nums){
    for(int i=0;i<nums.length-1;i++){
        for(int j=0;j<nums.length-i-1;j++){
            if(nums[j]>nums[j+1]){
                swap(nums,j,j+1);
            }
        }
    }
}

//冒泡排序优化
public static void bubblePlusSort(int[] nums){

    for(int i=0;i< nums.length;i++){
        boolean exchange=true;
        for(int j=1;j< nums.length-i;j++){
            if(nums[j]<nums[j-1]){
                swap(nums,j,j-1);
                exchange=false;
            }
        }
        if(exchange)return;
    }
}

//选择排序
public static void selectSort(int[] nums){
    int len=nums.length;
    for (int i = 0; i < len-1; i++) {
        int min=i;
        for(int j=i+1;j<len;j++){
            if(nums[min]>nums[j])min=j;
        }
        if(min!=i)swap(nums,min,i);
    }
}

//选择排序优化
public static void selectPlusSort(int[] nums){
    int begin=0;
    int end= nums.length-1;
    while(begin<end){

        int min=begin;
        int max=end;
        for (int i=begin;i<=end;i++){
            if(nums[i]<nums[min])min=i;
            if(nums[i]>nums[max])max=i;
        }
        swap(nums,min,begin);
        if(max==begin)max=min;
        swap(nums,max,end);

        begin++;
        end--;
    }
}

//插入排序
public static void insertSort(int[] nums){
    int len=nums.length;
    for(int i=0;i<len-1;i++){
        int end=i;
        int target=nums[i+1];
        while(end>=0){
            if(nums[end]>target){
                nums[end+1]=nums[end];
                end--;
            }else break;
        }
        nums[end+1]=target;
    }
}

//快排①_最普通的实现方式
public static void quickSort_level_1(int[] nums,int left,int right){
    if(left>=right)return;

    int key=nums[left];
    int begin=left;
    int end=right;

    while(begin<end){
        while (begin<end && nums[end] >= key)end--;
        nums[begin]=nums[end];
        while(begin<end&&nums[begin]<=key)begin++;
        nums[end]=nums[begin];
    }

    //这一步最容易忘
    nums[begin]=key;

    quickSort_level_1(nums,begin+1,right);
    quickSort_level_1(nums,left,begin-1);
}

public static int getMidIndex(int[] nums,int left,int right){
    int mid=(left+right)>>1;
    if(nums[mid]>nums[left]){
        if(nums[mid]<nums[right])return mid;
        else if(nums[left]>nums[right])return left;
        return right;
    }else{
        if(nums[left]<nums[right])return left;
        else if(nums[mid]>nums[right])return mid;
        return right;
    }
}
//快排②_坑位法_1
public static int partSort2(int[] nums,int left,int right){
    int midIndex=getMidIndex(nums,left,right);
    swap(nums,midIndex,left);
    int begin=left;
    int end=right;
    int prive=left;
    int key=nums[left];
    while(begin<end){
        while (begin<end && nums[end]>=key){
            end--;
        }
        nums[prive]=nums[end];
        prive=end;
        while (begin<end&&nums[begin]<=key){
            begin++;
        }
        nums[prive]=nums[begin];
        prive=begin;
    }
    prive=begin;
    nums[prive]=key;
    return prive;
}
public static void quickSort_level_2(int[] nums,int left,int right){
    if(left>=right)return;

    int keyIndex=partSort2(nums,left,right);

    quickSort_level_2(nums,left,keyIndex-1);
    quickSort_level_2(nums,keyIndex+1,right);
}

//快排③_坑位法_2
public static int partSort3(int[] nums,int left,int right){
    int midIndex=getMidIndex(nums,left,right);
    swap(nums,midIndex,left);
    int begin=left;
    int end=right;
    int prev=left;
    int key=nums[left];
    while(begin<end){
        while(begin<end && nums[end]>=key){
            end--;
        }
        while (begin<end && nums[begin]<=key){
            begin++;
        }

        swap(nums,begin,end);
    }
    swap(nums,begin,prev);
    return begin;
}
public static void quickSort_level_3(int[] nums,int left,int right){
    if(left>=right)return;

    int key= partSort3(nums,left,right);

    quickSort_level_3(nums,left,key-1);
    quickSort_level_3(nums,key+1,right);
}

//快排④_双指针法
public static int partSort4(int[] nums,int left,int right){
    int midIndex=getMidIndex(nums,left,right);
    swap(nums,midIndex,left);
    int pre=left;
    int cur=left+1;
    int key=nums[left];
    while(cur<=right){
        if(nums[cur]<=key && (++pre!=cur)){
            swap(nums,pre,cur);
        }
        cur++;
    }
    swap(nums,pre,left);
    return pre;
}
public static void quickSort_level_4(int[] nums,int left,int right){
    if(left>=right)return;

    int key=partSort4(nums,left,right);

    quickSort_level_4(nums,left,key-1);
    quickSort_level_4(nums,key+1,right);
}

//快排⑤_非递归法
public static void quickSortNonRecursion(int[] nums,int left,int right){
    Deque<Integer> deque=new ArrayDeque<>();
    deque.push(right);
    deque.push(left);
    while (!deque.isEmpty()){
        int begin=deque.pop();
        int end=deque.pop();
        int key=partSort3(nums,begin,end);
        if(end-key>1){
            deque.push(end);
            deque.push(key+1);
        }
        if(key-begin>1){
            deque.push(key-1);
            deque.push(begin);
        }
    }
}

//希尔排序
public static void shellSort(int[] nums){
    int gap=n;
    while(gap>1){
        gap/=2;
        for(int i=0;i<n-gap;i++){
            int end=i;
            int target=nums[end+gap];
            while(end>=0){
                if(nums[end]>target){
                    nums[end+gap]=nums[end];
                    end-=gap;
                }else{
                    break;
                }
            }
            nums[end+gap]=target;
        }
    }
}

//建大顶堆
public static void adjustDown(int[] nums,int n,int parent){
    int child=parent*2+1;
    while(child<n){
        if(child+1 <n && nums[child]<nums[child+1]){
            child++;
        }

        if(nums[parent]<nums[child]){
            swap(nums,parent,child);
            parent=child;
            child=2*parent+1;
        }else break;
    }
}
//建小顶堆
public static void adjustUp(int[] nums,int n,int parent){
    int child=parent*2+1;
    while(child<n){
        if(child+1 <n && nums[child]>nums[child+1]){
            child++;
        }

        if(nums[parent]>nums[child]){
            swap(nums,parent,child);
            parent=child;
            child=2*parent+1;
        }else break;
    }
}
//堆排序
public static void heapSort(int[] nums){
    int n=nums.length;
    for(int i=(n-1-1)/2;i>=0;i--){
        adjustDown(nums,n,i);
    }

    int end=n-1;
    while(end>0){
        swap(nums,end,0);
        adjustDown(nums,end,0);
        end--;
    }
}

//堆排序
public static void mergeSort(int[] nums,int left,int right,int[] temp){
    if(left>=right)return;
    int mid=(left+right)>>1;
    mergeSort(nums,left,mid,temp);
    mergeSort(nums,mid+1,right,temp);
    int begin1=left;
    int end1=mid;
    int begin2=mid+1;
    int end2=right;
    int k=left;
    while(begin1<=end1 && begin2<=end2){
        if(nums[begin1]<nums[begin2]){
            temp[k++]=nums[begin1++];
        }else{
            temp[k++]=nums[begin2++];
        }
    }
    while(begin1<=end1){
        temp[k++]=nums[begin1++];
    }
    while (begin2<=end2){
        temp[k++]=nums[begin2++];
    }
    for (int i=left;i<=right;i++){
        nums[i]=temp[i];
    }
}

//计数排序
public static void countSort(int[] nums){
    int min=nums[0];
    int max=nums[0];
    for(int num:nums){
        if(num<min){
            min=num;
        }
        if(num>max){
            max=num;
        }
    }
    int range=max-min+1;
    int[] counts=new int[range];
    for(int num:nums){
        counts[num-min]++;
    }
    int k=0;
    for(int i=0;i<range;i++){
        while(counts[i]!=0){
            nums[k++]=i+min;
            counts[i]--;
        }
    }
}
public static void swap(int[] nums,int a,int b){
    int c=nums[a];
    nums[a]=nums[b];
    nums[b]=c;
}