十大排序算法

1.快速排序

参考链接

public class QuickSort {

    public static void quick(int[] arr,int left,int right){
        int i,j,tmp;
        
        if (left>right){ return;}
        i=left;
        j=right;
        tmp=arr[left];//tmp就是基准位

        while (i<j){
            //先看右边，依次往左递减,找出小于tmp的数
            while (i<j && arr[j]>=tmp){
                j--;
            }
            //再看左边，依次往右递增，找出大于tmp的数
            while (i<j && arr[i]<=tmp){
                i++;
            }
            //若从右往左找出小于tmp的数，从左往右找出大于tmp的数，则将他们进行交换
            if (i<j){
                int t=arr[i];
                arr[i]=arr[j];
                arr[j]=t;
            }
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[left]=arr[i];
        arr[i]=tmp;

        quick(arr,left,j-1);//递归调用左半数组
        quick(arr,j+1,right); //递归调用右半数组
    }
    
    
    public static void main(String[] args) {
        int k[]={1,4,2,8,3,9,7};
        quick(k, 0, 6);
        for(int i=0;i<k.length;i++) System.out.println(k[i]);
    }
}

2.归并排序

归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的

public class MergeSort {

    public static void  MergeSort1(int[] arr,int left,int mid,int right){
        //赋值
        int[] tmp=new int[arr.length];
        int p1=left;
        int p2=mid+1;
        int k=left;
        //左边和右边两个模块进行比较
        while (p1<=mid && p2<=right){
            //左边的数小先添加
            if (arr[p1]<=arr[p2]){
                tmp[k++]=arr[p1++];
            }
            //右边的数小先添加
            else {
                tmp[k++]=arr[p2++];
            }
        }

        //如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while (p1<=mid) tmp[k++]=arr[p1++];
        while (p2<=right)  tmp[k++]=arr[p2++];

        //复制回原素组
        for (int i = left; i <=right ; i++) {
            arr[i]=tmp[i];
        }

    }

    
    public static void merge(int []arr,int left,int right){
        if (left<right){//当子序列中只有一个元素时结束递归
            int mid=(left+right)/2;//划分子序列
            merge(arr,left,mid);//对左侧子序列进行递归排序
            merge(arr,mid+1,right);//对右侧子序列进行递归排序
            MergeSort1(arr,left,mid,right);//合并
        }
    }


    public static void main(String[] args) {
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        merge(a,0,a.length-1);
        for (int i:a){
            System.out.println(i);
        }
    }
}

3.选择排序

public class selectSort {

    public static int[] select(int[] arr){
        //确定遍历的范围
        for (int i = 0; i < arr.length - 1; i++) {
            int min=i;//进行一轮选择排序前最小值暂定为第一个

            //将暂定的最小值与其后面的数进行比较
            for (int k=min;k<=arr.length-1;k++){
                if (arr[min]>arr[k]){//将每个遍历到的元素与arr[min]比较
                    min=k;
                }
            }

            //将得到的最小值的索引min上的元素与我们初始遍历的位置上的元素交换
            int tmp=arr[min];
            arr[min]=arr[i];
            arr[i]=tmp;
        }
        return arr;
    }

    public static void main(String[] args) {

    int arr[]={2,6,3,9,5,7,4};
    select(arr);

    for (int a:arr){
        System.out.println(a);
    }

    }
    
}

4.冒泡排序

核心思想：将临近的两个元素互相比较，将大的元素放在后面，依次循环下去，第一趟完成比较后，最大的元素会排在最后，第二趟后第二大的元素会排在倒数第二位，n-1趟后元素全部被排完

public class BubbleSort {

    public static int[] bubble(int[] arr ){
        //设置每次遍历的长度,每遍历一次，长度 - 1
        for (int i=arr.length-1;i>=0;i--){
            //从最左边的数开始，依次比较相邻元素
            for (int j=0;j<i;j++){
                //如果左边的数大于右边的数，则交换一下两个元素
                if (arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
        }
        return arr;
    }


    public static void main(String[] args) {
        int arr[]={2,6,3,9,5,7,4};
        bubble(arr);
        
        for (int a:arr){
            System.out.println(a);
        }
    }
    
}

5.插入排序

维护一个有序区，将数据一个一个插入到有序区的适当位置，直到整个数组都有序。
先把首元素 5 作为有序区，此时有序区只有一个元素。

public class InsertionSort {

    public static void insert(int[] arr){
        //先把首元素作为有序区,然后从索引为1的元素开始逐个插入有序区
        for (int i = 1; i < arr.length; i++) {
            int insertValue=arr[i];//暂存需要插入元素
            int j=i-1;//与需要插入元素进行比较的元素的索引
            //当插入元素小于有序区某个元素时则进行交换，否则就索引减1，与上一个继续对比
            for (;j>0&&insertValue<arr[j];j--){
                arr[j+1]=arr[j];
            }
            //插入元素大于有序区最右边元素(最大元素)时则不进行交换，直接插入在它后面
            arr[j+1]=insertValue;
        }
    }

    public static void main(String[] args) {
        int arr[]={2,6,3,9,5,7,4};
        insert(arr);

        for (int a:arr){
            System.out.println(a);
        }
    }
}

6.希尔排序

public class ShellSort {

    public static void shellInsert(int[] arr,int dk){
        for (int i = dk; i < arr.length; ++i) {
            //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入
            if (arr[i]<arr[i-dk]){
                int j=i-dk;
                int x=arr[i];//复制为哨兵，即存储待排序元素
                arr[i]=arr[i-dk];//首先后移一个元素

                while(j>=0 &&x<arr[j]){//查找在有序表的插入位置
                    arr[j+dk]=arr[j];
                    j-=dk;//元素后移
                }
                arr[j+dk]=x;//插入到正确位置
            }
        }
    }

    public static void shell(int[] arr){
        int length=arr.length;
        int dk=length/2;
        while (dk>=1){
            shellInsert(arr,dk);
            dk=dk/2;
        }
    }

    public static void main(String[] args) {
        int[] a = {3,1,5,7,2,4,9,6};
        shell(a);
        for (int i:a){
            System.out.println(i);
        }
    }

}

7.堆排序

参考链接

8.计数排序

public class CountSort {

    public static int[] count(int[] arr){
        //1.得到数列的最大值
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        //2.根据数列最大值确定统计数组的长度
        int[] countArray=new int[max+1];
        //3.遍历统计数组，填充统计数组
        for (int i = 0; i < arr.length; i++) {
            countArray[arr[i]]++;
        }
        //4.遍历统计数组，输出结果
        int index=0;
        int[] lastArray=new int[arr.length];
        for (int i = 0; i < countArray.length; i++) {
            for (int j=0;j<countArray[i];j++){
                lastArray[index++]=i;
            }
        }
        return lastArray;
    }

    public static void main(String[] args) {
        int[] array = new int[] {4,4,6,5,3,2,8,1,7,5,6,0,10};
        int[] sortedArray = count(array);
        System.out.println(Arrays.toString(sortedArray));
    }

}

9.基数排序

参考链接

10.桶排序