八大排序

1.冒泡排序

一组无序数组，从后面往前进行两个数的交换，如果后面的数小于前面的数就交换，直到将最小的数换到最前面。

public class Main{
    public static void main(String[] args) {
        int[] a=new int[]{23,4,67,56,87,6,13,25,44,0};
        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }

    public  static void bubbleSort(int[] a) {
        for(int i=0;i<a.length-1;i++){
            for(int j=a.length-1;j>i;j--){
                if(a[j]<a[j-1]){
                    int temp=a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                }
            }
        }
    }

}

 

 

 

2.插入排序

假设前Ñ个数为已排状态，依次往后将后面的数插入到前面来保证前Ñ个数一直为已排状态。

public class Main{
    public static void main(String[] args) {
        int[] a=new int[]{23,4,67,56,87,6,13,25,44,0};
        insertSort(a);
        System.out.println(Arrays.toString(a));
    }

    private static void insertSort(int[] a) {
        for(int i=0;i<a.length-1;i++){
            for (int j=i+1;j>0;j--){
                if(a[j]<a[j-1]){
                    a[j-1]=a[j];
                }
                
            }

        }
    }
}

 

3.希尔排序 

比较相同间距的元素来排序，每一个周期的间距都会减小直到比较相邻的两个数

 

public class Main{
    public static void main(String[] args) {
        int[] a=new int[]{23,4,67,56,87,6,13,25,44,0};
        shellSort(a);
        System.out.println(Arrays.toString(a));
    }

    private static void shellSort(int[] a) {
        for(int gap=a.length/2;gap>0;gap=gap/2){
            for(int i=gap;i<a.length;i++){
            
                for (int j=i;j>i;j=j-gap){
                    if(a[j]<a[j-gap]){
                        a[j]=a[j-gap];
                    }

                }
                }

            }
        }
    }

 

 

4.选择排序

在无序数组中，第一次将第一个后面数中最小的数和第一个数交换，

第二次将第二个数后面中最小的数的与第二个数交换

依次类推

public class Main{
    public static void main(String[] args) {
        int[] a=new int[]{23,4,67,56,87,6,13,25,44,0};
        selectSort(a);
        System.out.println(Arrays.toString(a));
    }

    public  static void selectSort(int[] a) {
        for(int i=0;i<a.length;i++){

            int minIndex=i;
            for(int j=i+1;j<a.length;j++){

                if(a[j]<a[minIndex]){
                    minIndex=j;
                }
            }
            if(i!=minIndex){
                int temp=a[i];
                a[i]=a[minIndex];
                a[minIndex]=temp;
            }

        }
    }

}

 

 

 

5.快速排序

挖数填坑

取出一个密钥值（一般是第一个），把比它小的值放在它的左边，比它大的数放在它的右边。然后按照此方法，排列它左右两个子列，以此类推。

public class Main{
    public static void main(String[] args) {
        int[] a=new int[]{23,4,67,56,87,6,13,25,44,0};
        int l=0;
        int r=a.length-1;
        quck_Sort(a,l,r);
        System.out.println(Arrays.toString(a));
    }

    private static void quck_Sort(int[] a,int l,int r) {
        if (r>=l){return;}
        int i=r;
        int j=l;
        int key=a[l];

        while(i<j){
            while (i<j&&a[j]>=key){
                j--;
            }
            if(i<j){
                a[i]=a[j];
                i++;
            }
            while(i<j&&a[i]<key){
                i++;
            }
            if (i<j){
                a[j]=a[i];
                j--;
            }
            }
            a[i]=key;
            quck_Sort(a,l,i-1);
            quck_Sort(a,i+1,l);
    }
}

 

6.归并排序

将数组平分成左右两组，再每组数分成左右两组，利用递归直到将整个数组分成每组只有一个数的数组，每个数组就可看成一个有序数组，然后将其中两两进行有序归并为一组，放在临时数组中，（对比每组的第一个数，小的放第一个，然后另一组的第一个数放第二个中，依次往后）。

public class Main {


    public static void main(String[] args) {
        int[] a={23,4,67,56,87,6,13,25,44,0};
        int first=0;
        int last=a.length-1;
        int[] temp=new int[a.length];
        merge_Sort(a,first,last,temp);
        System.out.println(Arrays.toString(a));

    }
    static void merge_Sort(int[] a,int first,int last,int[] temp){
        if(first<last) {
            int middle = (first + last) / 2;
            merge_Sort(a,first,middle,temp);
            merge_Sort(a,middle+1,last,temp);
            mergeArray(a,first,middle,last,temp);
        }
    }


     static void mergeArray(int[] a, int first, int middle,int end, int[] temp) {
        int i=first;
        int m=middle;
        int j=middle+1;
        int k=0;
        int n=end;
        while(i<=m&&j<=n) {
            if (a[i] <= a[j]) {
                temp[k] = a[i];
                k++;
                i++;
            } else {
                temp[k] = a[j];
                k++;
                j++;
            }
        }
            while(i<=m){
                temp[k]=a[i];
                k++;
                i++;
            }
            while(j<=n){
                temp[k]=a[j];
                k++;
                j++;
            }

        for(int ii=0;ii<k;ii++){
            a[first+ii]=temp[ii];
        }
    }
}

 

 

 

7.基数排序

先新一个0〜9的基数数组，第一轮将无序数组按照末数放在基数的相应数字下面，第二轮将无序数组按照倒数第二位数放在基数的相应数字下面。

public class Main{
public static void main(String[] args){
    int[] a={23,4,67,56,87,6,13,25,44,0};
    int k=2;//未排数组的位数
    int r=10;//基数数组中有10个空间即10个箱子
    int[] cnt=new int[r];//基数数组
    int[] temp=new int[a.length];
    radixSort(a,k,r,cnt,temp);
    System.out.println(Arrays.toString(a));
        }

    public static void radixSort(int[] a,int k,int r,int[] cnt,int[] temp) {

    for(int i=0,rtok=1;i<k;i++,rtok=rtok*r){
        //初始化
        for(int j=0;j<r;j++){
            cnt[j]=0;
        }
        //计算每个箱子里面存放多少数字
        for(int j=0;j<a.length;j++){
            cnt[(a[j]/rtok)%r]++;
        }
        //将从cnt[j]的个数修改为前j个箱子里有多少个数字。
        for(int j=1;j<r;j++){
            cnt[j]=cnt[j-1]+cnt[j];
        }
        //首先每个箱子里面存放了前j个箱子里的数字个数，
        //按照原数组从后往前将箱子里面的数取出来放进临时数组，并且该箱子里面的数字减少1个。
        for(int j=a.length-1;j>0;j--){
            cnt[(a[j]/rtok)%r]--;
            temp[cnt[(a[j]/rtok)%r]]=a[j];//为了将a[j]放到合适的位置。
        }
        for(int j=0;j<a.length;j++){
            a[j]=temp[j];
        }
    }
    }
}

 

8.堆排序（以升序为例）

先将无序数组构造成大顶堆，再将首尾数字交换，此时末尾的数字是最大的，再将剩下的数字调整使其满足大顶堆，继续调换第一个和倒数第二个数，此时倒数第二个数是次大的，再将剩下的数字调整使其满足大顶堆，依次类推

public class Main{
    public static void main(String[] args) {
        int[] arr={28,23,42,1,54,22,77,55,4};
        heap_Sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void heap_Sort(int[] arr){
        for (int i=arr.length/2-1;i>=0;i--){
            adjustHeap(arr,i,arr.length);
        }
        for (int j=arr.length-1;j>0;j--){
            swap(arr,0,j);
            adjustHeap(arr,0,j);
        }
    }

    private static void swap(int[] arr, int a, int b) {
        int temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
    }

    private static void adjustHeap(int[] arr,int i,int length) {
        int temp=arr[i];
        for (int k=2*i+1;k<length;k=2*k+1){

            if (k+1<length&&arr[k]<arr[k+1]){
                k++;
            }
            if (arr[k]>temp){
                arr[i]=arr[k];
                i=k;//在这不需要进行交换
            }
            else{
                break;
            }
            }
            arr[i]=temp;
    }
}