十种常见排序算法 JAVA版

十种常见排序算法可以分为两大类：

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。

线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

 

根据此表整理了排序对比图，其中

1. 柱状图蓝色表示是稳定的，柱状图黄色表示不稳定的；

2. 柱状图中间的数字表示时间复杂度，红色字体表示最差时，黑色字体表示平均复杂度；

3. 柱状图虚线表示最差时的时间复杂度，因为冒泡排序，交换排序，选择排序的最差和平均时间复杂度是一样的，都是O(n^2)，所以图中看不见虚线；

4. 实线柱状图，即平均时间复杂度，效率从低到高依次是： 

 冒泡排序 ≈ 交换排序 ≈选择排序 < 插入排序 <Shell排序 <堆排序 < 归并排序 <快速排序

 

    大多数情况下，快速排序效率最高，但如果数据已经基本有序的情况下，效率退化到O(n^2)。

 

1、冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 

 

1.1 算法描述

 

比较相邻的元素。如果第一个比第二个大，就交换它们两个；

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

针对所有的元素重复以上的步骤，除了最后一个；

重复步骤1~3，直到排序完成。

public static void BubbleSort(int arr[],int size){
    for (int i = size-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;
            }
        }
    }
}

2.插入排序是把序列中的值插入一个已经排序好的序列中，直到该序列的结束。它比冒泡排序快2倍。一般不适合数据量比较大的场合或数据重复比较多的场合。

public static void InsertionSort(int a[],int size){
     for (int i = 1; i < size; i++) {
         for (int j = 0; j < i; j++) {
             if (a[j]>a[i]){
                 int tmp = a[i];
                 for (int k = i; k > j; k--)
                     a[k]=a[k-1];
                 a[j]=tmp;
                 break;
             }
         }
     }
 }

3.快速排序

利用分治法，进行大规模递归的算法，具体见下面步骤：      步骤1： 如果不多于1个数据，直接返回。      步骤2：般选择序列最左边的值作为支点数据。

     步骤3： 将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。

    步骤4： 对两边利用递归排序数列。快速排序比大部分排序算法都要快。尽管在某些特殊的情况下有比快速排序快的算法，但通一般情况下，没有比它更快的。

快速排序比大部分排序算法都要快。尽管在某些特殊的情况下有比快速排序快的算法，但通一般情况下，没有比它更快的。

public static void Qsort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];*//*用字表的第一个记录作为枢轴*//*
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
        a[first] = a[last];*//*将比第一个小的移到低端*//*
        while(first < last && a[first] <= key)
        {
            ++first;
        }
        a[last] = a[first];
        *//*将比第一个大的移到高端*//*
    }
    a[first] = key;*//*枢轴记录到位*//*
    Qsort(a, low, first-1);
    Qsort(a, first+1, high);
}

4.选择排序在实际应用中和冒泡排序基本差不多，使用较少。

public static void SelectionSort(int a[], int size){
    for (int i = 0;i<size-1;i++){
        int tmpMin=i;
        for (int j=i+1; j<size; j++){
            if (a[j]<a[tmpMin])
                tmpMin = j;
        }
        int tmp = a[i];
        a[i] = a[tmpMin];
        a[tmpMin]=tmp;
    }
}

 

5.Shell排序是通过将数据分成不同的组，先对每一组进行排序，然后再对所有的元素进行一次插入排序，以减少数据交换和移动的次数，其中Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起快速排序，归并排序，堆排序慢很多。但shell算法比较简单，特别适合数据量在5000以下且性能要求不是很高的场合。

public static void ShellSort(int v[], int n){
        int gap, i, j, temp;
        for (gap = n / 2; gap > 0; gap /= 2){
            for (i = gap; i < n; i++){
                for (j = i - gap; j >= 0 && v[j]>v[j + gap];j-=gap){
                    temp = v[j];
                    v[j] = v[j + gap];
                    v[j + gap] = temp;
                }
            }
    }
}

 6.归并排序先分解要排序的序列，从1分成2，2分成4，依次分解，当分解到只有1个一组的时候，就可以排序这些分组，然后依次合并回原来的序列中，这样就可以排序所有数据。合并排序比堆排序稍微快一点，由于它需要一个额外的数组，因此需要比堆排序多一些内存空间。

/**
 * 　*　<pre>
 * 　*　二路归并
 * 　*　原理：将两个有序表合并和一个有序表
 * 　*　</pre>
 * 　*
 * 　*　@param　a
 * 　*　@param　s
 * 　*　第一个有序表的起始下标
 * 　*　@param　m
 * 　*　第二个有序表的起始下标
 * 　*　@param　t
 * 　*　第二个有序表的结束下标
 * 　*
 */
private static void merge(int[] a, int s, int m, int t) {
    int[] tmp = new int[t - s + 1];
    int i = s, j = m, k = 0;
    while (i < m && j <= t) {
        if (a[i] <= a[j]) {
            tmp[k] = a[i];
            k++;
            i++;
        } else {
            tmp[k] = a[j];
            j++;
            k++;
        }
    }
    while (i < m) {
        tmp[k] = a[i];
        i++;
        k++;
    }
    while (j <= t) {
        tmp[k] = a[j];
        j++;
        k++;
    }
    System.arraycopy(tmp, 0, a, s, tmp.length);
}

/**
 * 　*
 * 　*　@param　a
 * 　*　@param　s
 * 　*　@param　len
 * 　*　每次归并的有序集合的长度
 */
public static void mergeSort(int[] a, int s, int len) {
    int size = a.length;
    int mid = size / (len << 1);
    int c = size & ((len << 1) - 1);
    //　-------归并到只剩一个有序集合的时候结束算法-------//
    if (mid == 0)
        return;
    //　------进行一趟归并排序-------//
    for (int i = 0; i < mid; ++i) {
        s = i * 2 * len;
        merge(a, s, s + len, (len << 1) + s - 1);
    }
    //　-------将剩下的数和倒数一个有序集合归并-------//
    if (c != 0)
        merge(a, size - c - 2 * len, size - c, size - 1);
    //　-------递归执行下一趟归并排序------//
    mergeSort(a, 0, 2 * len);
}

7.堆排序将是所有的数据先建成一个堆，如大顶堆（最大的数据在堆顶），然后将堆顶数据和序列的最后一个数据交换，然后重新建堆，交换数据，依次下去，就可以排序所有的数据。由于不需要大量的递归或者多维的暂存数组，因此这对于数据量非常巨大的序列是很合适的，比如超过数百万条记录，因为快速排序，归并排序都使用递归来设计算法，在数据量非常大的时候，可能会发生堆栈溢出错误。

public static void adjustHeap(int[] a, int i, int len) {
    int temp, j;
    temp = a[i];
    for (j = 2 * i; j < len; j *= 2) {// 沿关键字较大的孩子结点向下筛选
        if (j < len && a[j] < a[j + 1])
            ++j; // j为关键字中较大记录的下标
        if (temp >= a[j])
            break;
        a[i] = a[j];
        i = j;
    }
    a[i] = temp;
}

public static void heapSort(int[] a) {
    int i;
    for (i = a.length / 2 - 1; i >= 0; i--) {// 构建一个大顶堆
        adjustHeap(a, i, a.length - 1);
    }
    for (i = a.length - 1; i >= 0; i--) {// 将堆顶记录和当前未经排序子序列的最后一个记录交换
        int temp = a[0];
        a[0] = a[i];
        a[i] = temp;
        adjustHeap(a, 0, i - 1);// 将a中前i-1个记录重新调整为大顶堆
    }
}

8.交换排序

 

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