常见七种排序算法java代码

1、冒泡排序：从头到尾依次将相邻两个数比较，每次把较大的数放在后面，直到把最大的数放在最后
时间复杂度：O(n2) 空间复杂度：O(1) 稳定度：稳定

稳定度解释：相同大小的数字排序后相对位置是否变化。

 /**
     * 冒泡排序
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        int temp=0;
        boolean flag=false;
        for (int i =0;i<arr.length-1;i++) {
            for (int j = 0; j < arr.length-(i+1); j++) {
                if (arr[j]>arr[j+1]){//3, -1, 5, 9, -2
                    flag=true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            if (!flag){
                break;
            }else {
                flag=false;
            }
        }
    }

2、选择排序：从头到尾遍历，每次把最小的数交换到最前面
时间复杂度：O(n2) 空间复杂度：O(1) 稳定度：不稳定

/**
     * 选择排序算法
     * @param arr
     */
    public static void selectSort(int[] arr){
        for (int i = 0; i <arr.length-1 ; i++) {
            int min=arr[i];
            int minIndex=i;
            for (int j = i+1; j <arr.length ; j++) {
                if (min>arr[j]){
                    min=arr[j];
                    minIndex=j;
                }
            }
            if (min!=arr[i]){
                arr[minIndex]=arr[i]; //交换位置
                arr[i]=min;
            }
        }
    }

3、插入排序：把n个待排序的元素看作是一个有序表和一个无序表，开始时，有序表只有一个元素，然后从无序表中依次取出元素插入到有序表中
时间复杂度：O(n2) 空间复杂度：O(1) 稳定度：稳定

 public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertIndex=i-1;
            int insertValue=arr[i];
            while (insertIndex>=0 && arr[insertIndex]>insertValue){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;

            }
            arr[insertIndex+1]=insertValue;

        }
    }

4、快速排序：通过一趟排序把待排序的数分成两个独立的组，其中一组的所有数都小于另一组数，然后按照此方法两组进行排序。用递归的方式实现
时间复杂度：O(nlogn) 空间复杂度：O(nlogn) 稳定度：不稳定

public static void quickSort(int[] arr,int left,int right){
        if (left>right) return;

        int l=left;
        int r=right;
        int pivot=arr[left];
        while (l!=r){
            while (arr[r]>pivot && r>l){
                r--;
            }//必须先判断r
            while (arr[l]<=pivot && l<r){
                l++;
            }

            int temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;
        }
        arr[left]=arr[l];
        arr[l]=pivot;
        quickSort(arr,left,l-1);
        quickSort(arr,l+1,right);
    }

5、希尔排序：按组交换，由小组到大组
时间复杂度：O(nlogn) 空间复杂度：O(1) 稳定度：不稳定

 /**
     * 希尔排序。交换式
     * @param arr
     */
    public static void shellSort(int[] arr){
        int temp=0;
        for (int gap = arr.length/2; gap >0 ; gap/=2) {
            for (int i = gap; i < arr.length; i++) {
                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;
                    }
                }
            }
        }
    }

   /**
     * 希尔排序，移位式
     * @param arr
     */
    public static void shell(int[] arr){
        for (int gap = arr.length/2; gap >0 ; gap/=2) {
            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;
                }
            }
        }
    }

6、 归并排序：分而治之的思想。太难了- -有想法的小伙伴可以一起交流交流
时间复杂度：O(nlogn) 空间复杂度：O(1) 稳定度：稳定

 /**
     * 分+并
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    public static void mergeSort(int[] arr,int left,int right,int[] temp){
        if (left<right){
            int mid=(left+right)/2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid+1,right,temp);
            merge(arr,left,mid,right,temp);
        }
    }

    /**
     * 合并
     * @param arr
     * @param left
     * @param mid
     * @param right
     * @param temp
     */
    public static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i=left;
        int j=mid+1;
        int t=0;
        //(一)
        //先把左右两边(有序)的数据按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i<=mid && j<=right){
            if (arr[i]<arr[j]){
                temp[t++]=arr[i++];
            }
            if (arr[i]>arr[j]){
                temp[t++]=arr[j++];
            }
        }
        //(二)
        //把有剩余数据的一边的数据依次全部填充到temp
        while (i<=mid){
            temp[t++]=arr[i++];
        }
        while (j<=right){
            temp[t++]=arr[j++];
        }
        //(三)
        //将temp数组的元素拷贝到arr
        //注意，并不是每次都拷贝所有
        t=0;
        int tempLeft=left;
        while (tempLeft<=right){
            arr[tempLeft++]=temp[t++];
        }
    }

7、基数排序
时间复杂度：O(logRB) R是基数（个十百）B是真数（0-9）
空间复杂度：O(n) 稳定度：稳定

  /**
     * 基数排序算法
     * @param arr
     */
    public static void radix(int[] arr){
        int[][] bucket=new int[10][arr.length];//用于进行分类的10个桶
        int[] count=new int[10];//记录每一个桶中有多少个数据
        int max=arr[0];//求出数组中最大的数
        for (int i = 1; i <arr.length ; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        int maxLength=(max+"").length();//求出最大数的位数
        //一共需要排序maxLength次
        for (int i = 0,n=1; i <maxLength ; i++,n *=10) {
            for (int j = 0; j < arr.length; j++) { //遍历arr数组中的每一个数据
                int k = arr[j] / n % 10; //求出每个数据的个位数
                bucket[k][count[k]] = arr[j];//放到对应的桶中
                count[k]++;//对应桶的数据数量++
            }
            //把桶里面的数据取出放回原数组
            int index = 0;
            for (int l = 0; l < count.length; l++) {
                if (count[l] != 0) {
                    for (int j = 0; j < count[l]; j++) {
                        arr[index++] = bucket[l][j];
                    }
                }
                count[l] = 0;//每经过一轮处理后，需要将记录个数的数组清零
            }
        }

    }