详解java排序算法

排序算法：

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序，若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。博主主要介绍内部排序算法。

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
冒泡排序	O(n2)	O(n)	O(n2)	O（1）	稳定
选择排序	O(n2)	O(n)	O(n2)	O（1）	不 稳定
插入排序	O(n2)	O(n)	O(n2)	O（1）	稳定
希尔排序	O(n2)	O(n)	O(n2)	O（1）	不稳定
归并排序	O(n2)	O(n)	O(n2)	O（n）	稳定
快速排序	O(n2)	O(n)	O(n2)	O（log n）	不 稳定
堆排序	O(n2)	O(n)	O(n2)	O（1）	不稳定
计数排序	O(n2)	O(n)	O(n2)	O（k）	稳定
桶排序	O(n + k)	O(n + k	O(n2)	O（n+k）	稳定
基数排序	O(n * k)	O(n * k)	O(n * k)	O（n+k）	稳定

一、交换排序

1.1冒泡排序：

基本思想:通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

public static void bubbleSort(int a[]) {
//外循环控制躺数
        for (int i = 0; i < a.length - 1; i++) {
        //内循环控制比较得次数
            for (int j = 1; j <= a.length - i - 1; j++) {
                if (a[j] < a[j - 1]) {
                    int temp = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

1.2快速排序

基本思想:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

public static void quickSort(int a[], int l, int r) {
        if(l >= r)
            return ;
        int x =a[l];
        int i = l - 1;
        int j = r + 1;
        while(i<j){
          do i++;
          while(a[i]<x);
          do j--;
          while(a[j]>x);
          if(i < j){
              int temp = a[j];
              a[j] = a[i];
              a[i] = temp;
          }
        }
        quickSort(a,l,j);
        quickSort(a,j+1,r);
    }

二、插入排序

2.1插入排序

基本思想:把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排
序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

 public static void insertSort(int a[]) {
        for (int i = 1; i < a.length; i++) {
            int insertVal = a[i]; //待插入的数
            int insertIndex = i - 1; //待插入数前面的数的下标
            //insertIndex >= 0 保证插入位置没有越界
            // insertVal < a[insertIndex] 未找到合适的位置
            while (insertIndex >= 0 && insertVal < a[insertIndex]) {
                a[insertIndex + 1] = a[insertIndex];
                insertIndex--;
            }
            //判断是否需要赋值,若不赋值则说明待插入前的数有序,反之,将待插入的数插入适当的位置.
            if (i != insertIndex) {
                a[insertIndex + 1] = insertVal;
            }
        }
    }

2.2希尔排序

基本思想:把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止

  static void shellSort(int a[]) {
        for (int gap = a.length / 2; gap > 0; gap /= 2) {
            //分成gap个组,分别对组中元素进行插入排序
            for (int i = gap; i < a.length; i++) {
                int j = i;
                int temp = a[j];
                if (a[j] < a[j - gap]) {
                    while (j - gap >= 0 && temp < a[j - gap]) {
                        //移动
                        a[j] = a[j - gap];
                        j -= gap;
                    }
                    //退出循环,找到插入位置
                    a[j] = temp;
                }
            }
        }
    }

三、选择排序

3.1简单选择排序

基本思想是：第一次从 arr[0]~arr[n-1]中选取最小值，与 arr[0]交换，第二次从 arr[1]~arr[n-1]中选取最小值，与 arr[1]交换，第三次从 arr[2]~arr[n-1]中选取最小值，与 arr[2]交换，…，第 i 次从 arr[i-1]~arr[n-1]中选取最小值，与 arr[i-1]交换，…, 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值，与 arr[n-2]交换，总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列。

    static void selectSort(int a[]) {
        for (int i = 0; i < a.length; i++) {
            int min = a[i];
            int midIndex = i;
            for (int j = i + 1; j < a.length; j++) {
                if (min > a[j]) {
                    min = a[j];
                    midIndex = j;
                }
            }
            if (midIndex != i) {
                a[midIndex] = a[i];
                a[i] = min;
            }
        }
    }

四、归并排序

 public static void merge(int a[],int l,int r){
        if(l>=r) //结果只有一个退出
            return;
        int mid = l+r >>1;
        merge(a,l,mid);
        merge(a,mid+1,r);
        int k = 0,i=l,j=mid+1;
        while(i<=mid&&j<=r){   //合并
            if(a[i]<=a[j]) res[k++] = a[i++];
            else res[k++] = a[j++];
        }
        while(i <= mid) res[k++] = a[i++];
        while(j<=r) res[k++] = a[j++];

        for(i=l,j=0;i<=r;i++,j++){
            a[i] = res[j];
        }
    }

五、基数排序

基本思想:将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

 public static void radixSort(int[] a) {
        int[][] res = new int[10][a.length];//二维数组作为桶
        int[] k = new int[10];//记录每个桶中的数的个数
        int max = Integer.MIN_VALUE;
        for (int temp : a) {
            if (temp > max) {
                max = temp;
            }
        }
        int times = (max + "").length();
        //排序的次数根据数组中最大值的位数决定
        for (int m = 0, n = 1; m < times; m++, n *= 10){
            //分别根据个位、十位、百位、、进行排序
            for (int i = 0; i < a.length; i++) {
                int temp = a[i] / n % 10;
                res[temp][k[temp]] = a[i];//将当前数据加入对应的桶中
                k[temp]++;//对应桶中的数据+1
            }
            int index = 0;
            //将桶中的数据重新加入到a数组中
            for (int l = 0; l < 10; l++) {
                if (k[l] != 0) {//判断桶中数据是否为空
                    for (int j = 0; j < k[l]; j++) {
                        a[index] = res[l][j];
                        index++;
                    }
                }
                k[l] = 0;//将当前桶中的数的个数清0
            }
        }

    }

六、 堆排序