基础排序算法总览--JAVA

基础排序算法如下：

1 插入类排序，如直接插入，折半插入，希尔排序等。
2 交换类排序，如冒泡排序，快速排序等。
3 选择类排序，如选择排序，堆排序等。
4 归并类排序，如归并排序等。
5 分配类排序，如基数排序等。

基础排序算法一览

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
直接插入	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
希尔排序	$O(nlog_{2}n)$~$O(n^2)$	$O(n^{1.3})$	$O(n^2)$	$O(1)$	不稳定
冒泡排序	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
快速排序	$O(nlog_{2}n)$	$O(nlog_{2}n)$	$O(n^2)$	$O(nlog_{2}n)$~$O(n)$	不稳定
简单选择	$O(n^2)$	$O(n^2)$	$O(n^2)$	$O(1)$	不稳定
堆排序	$O(nlog_{2}n)$	$O(nlog_{2}n)$	$O(nlog_{2}n)$	$O(1)$	不稳定
归并排序	$O(nlog_{2}n)$	$O(nlog_{2}n)$	$O(nlog_{2}n)$	$O(n)$	稳定
基数排序	$O(d(n+r))$	$O(d(n+r))$	$O(d(n+r))$	$O(rd))$	稳定

1 插入类排序

所谓插入排序，是指将无序序列中的各元素依次插入到已经有序的线性表中。

直接插入排序

假设线性中前k-1元素已经有序，现在要将线性表中第k个元素插入到前面的有序子表中。空间复杂度O(1),时间复杂度O($n^2$)，最好的情况时间复杂度O(n)。
代码如下：

void insertSort(int[] a) {
    int j, temp;
    for (int i = 1; i < a.length; i++) {
        j = i - 1;
        temp = a[i];
        while (j >= 0 && a[j] > temp) {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = temp;
    }
}

折半插入排序

折半插入排序，对直接插入排序算法的一种改进，由于前半部分为有序数列，不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。空间复杂度O(1)，由于折半仅减少了比较次数，移动次数并没有减少，所以时间复杂度还是O($n^2$)。
代码如下：

void binaryInsertSort(int[] a) {
    int temp, first, last, middle;
    for (int i = 1; i < a.length; i++) {
        first = 0;
        last = i - 1;
        while (first <= last) {
            middle = (first + last) / 2;
            if (a[middle] <= a[i])
                first = middle + 1;
            else
                last = middle - 1;
        }
        if (first != i) {
            temp = a[i];
            for (int j = i; j > first; j--)
                a[j] = a[j - 1];
            a[first] = temp;
        }
    }
}

希尔排序

由于直接插入排序，在排序记录较少时候，效率较高，希尔排序从这点出发进行改进的。
希尔排序，是将整个待排序列分割成若干个子序列，分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体进行一次直接插入排序。时间复杂度比O($n^2$)稍好。这里增量选择从数组一半开始。
代码如下：

void shellSort(int[] a) {
    int j, temp;
    for (int gap = a.length / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < a.length; i++) {
            temp = a[i];
            j = i - gap;
            while (j >= 0 && a[j] > temp) {
                a[j + gap] = a[j];
                j -= gap;
            }
            a[j + gap] = temp;
        }
    }
}

2 交换类排序

交换类排序，是通过一系列的交换元素过程，将线性表中乱序的元素交换为有序的排序方法。

冒泡排序

冒泡排序,重复的访问待排序数列，将临近的数字两两比较，按照大小顺序进行交换，直到没有元素交换发生。冒泡排序在最好的情况下(初始数列是正序)，时间复杂度为O(n),平均时间复杂度为O($n^2$)。
代码如下：

void bubbleSort(int[] a) {
    boolean flag = true;
    int temp = 0;
    for (int i = a.length - 1; i > 0; i--) {
        flag = true;
        for (int j = 0; j < i; j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
                flag = false;
            }
        }
        if (flag)
            return;
    }
}

快速排序

快速排序，通过一趟排序将待排序的数据分割成两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，达到整个序列变成有序。在最坏的情况下(待排序列已有序)，时间复杂度为O($n^2$)，平均时间复杂度为O(nlogn)。
代码如下：

void quickSort(int[] a, int low, int high) {
    if (low >= high) return;
    int temp = a[low], first = low, last = high;
    while (low < high) {
        while (a[high] >= temp && low < high) high--;
        a[low] = a[high];
        while (a[low] <= temp && low < high) low++;
        a[high] = a[low];
    }
    a[low] = temp;
    quickSort(a, first, low - 1);
    quickSort(a, low + 1, last);
}

3 选择类排序

选择排序，每一趟在n-i(i=0,1,…n-2)个记录中选择最大的记录作为有序序列的第n-i记录。

选择排序

选择排序，第i趟选择排序是指通过n-i次关键字的比较，从n-i个记录中选出关键字最大的记录，并和第n-i个记录进行交换。共需进行n-1趟比较，直到所有记录排序完成为止。时间复杂度为O($n^2$)。
代码如下：

void selectSort(int[] a) {
    int n = a.length - 1;
    int max;
    int loc = -1;
    for (int i = 0; i < n; i++) {
        max = Integer.MIN_VALUE;
        for (int j = 0; j < n - i; j++) {
            if (a[j] > max) {
                max = a[j];
                loc = j;
            }
        }
        a[loc] = a[n - i];
        a[n - i] = max;
    }
}

堆排序

堆排序，是树形选择排序方法。在排序中，将待排序列看作完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点的关系，在序列中选择最大或者最小的元素。时间复杂度为O(nlogn)。

堆：n个记录的序列L[1…n]称为堆，当且仅当该序列满足下面两个条件任意一个。(1 $\le$ i $\le$ $\left\lfloor\frac{n}{2}\right \rfloor$)
1. L[i] $\le$ L[2i] && L[i] $\le$ L[2i+1] (小堆)
2. L[i] $\ge$ L[2i] && L[i] $\ge$ L[2i+1] (大堆）

以大堆为例，代码如下：

//重复堆调整，按大小输出记录
void heapSort(int[] a) {
    buildMaxHeap(a, a.length);
    for (int i = 0; i < a.length; i++) {
        System.out.println(a[0]);
        a[0] = a[a.length - i - 1];
        adjustDown(a,0,a.length - i - 1);
    }
}
//创建一个大堆
void buildMaxHeap(int[] a, int len) {
    for (int i = len / 2 - 1; i >= 0; i--) {
        adjustDown(a, i, len);
    }
}
//调整堆
void adjustDown(int[] a, int k, int len) {
    int temp = a[k];
    int i = 2 * k + 1;
    while (i < len) {
        if (i + 1 < len && a[i] < a[i + 1]) i++;
        if (temp >= a[i]) break;
        else {
            a[k] = a[i];
            k = i;
        }
        i = 2 * i + 1;
    }
    a[k] = temp;
}

4 归并类排序

归并类排序，是建立在归并操作上的一种有效的排序算法，该算法是采用分治法(Divide and Conquer)的典型应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

归并排序

归并排序，将待排序序列L[0…n-1]看成是n个长度为1的有序序列，两两归并，得到$\left\lceil\frac{n}{2}\right \rceil$个长度为2或者1的有序表；再两两归并，如此反复进行下去，最后得到一个长度为n的有序序列，这称为二路归并排序。空间复杂度为O(n),每一趟时间复杂度为O(n),共logn趟，所以时间复杂度为O(nlogn)。
代码如下：

//递归实现
void mergeSort(int[] a, int low, int high) {
    if (low < high) {
        int mid = (low + high) / 2;
        mergeSort(a, low, mid);
        mergeSort(a, mid + 1, high);
        merge(a, low, mid, high);
    }
}
//非递归实现
void mergeSort(int[] a) {
    int len = a.length;
    int gap = 1;
    int low, mid, high;
    while (gap < len) {
        low = 0;
        while (low + gap <= len - 1) {
            mid = low + gap - 1;
            high = mid + gap;
            if (high > len - 1)
                high = len - 1;
            merge(a, low, mid, high);
            low = high + 1;
        }
        gap *= 2;
    }
}
void merge(int[] a, int low, int mid, int high) {
    int[] b = new int[a.length];
    for (int i = low; i <= high; i++) {
        b[i] = a[i];
    }
    int i = low, j = mid + 1, k = low;
    for (; i <= mid && j <= high; k++) {
        if (b[i] <= b[j])
            a[k] = b[i++];
        else
            a[k] = b[j++];
    }
    while (i <= mid) a[k++] = b[i++];
    while (j <= high) a[k++] = b[j++];
}

5 分配类排序

分配排序，排序过程无须比较关键字，而是通过用额外的空间来”分配”和”收集”来实现排序，它们的时间复杂度可达到线性O(n)。

基数排序

以r为基数的最低位优先排序过程：假设待排序列L[0…n-1]，每个记录L[i]由d元组($k^{d-1}_{i}$,$k^{d-2}_{i}$,…,$k^{0}_{i}$)组成，其中$c_{0}$$\le$ $k^{j}_{i}$$\le$$c_{r-1}$ (0$\le$i < <script type="math/tex" id="MathJax-Element-58"><</script>n,0$\le$j < <script type="math/tex" id="MathJax-Element-60"><</script>d)。在排序过程中需要利用r个数组。
关键字为数字时，r=10, 0$\le$$c_{j}$$\le$9，0$\le$j < <script type="math/tex" id="MathJax-Element-65"><</script>d；
关键字为字母时，r=26, ’A’$\le$$c_{j}$$\le$’Z’，0$\le$j < <script type="math/tex" id="MathJax-Element-70"><</script>d。
排序过程如下：

对 j=0,…,d-1，依次做一次”分配”和”收集”。
分配：开始时，先把r个数组置为空，然后依次考察L中每个L[i],如果L[i]的记录$k^{j}_{i}$=k,就把L[i]放入第k个数组中。
收集：把r个数组中的记录依次取出来，组成一个新的序列。

基数排序，需要r个数组，空间复杂度为O(r)。进行了d趟分配和收集，一趟分配需要O(n)，一趟收集需要O(r)，所以时间复杂度为O(d(n+r))。
代码如下：

void radixSort(int[] a, int d) {
    int[][] array = new int[10][a.length];
    for (int i = 0; i < 10; i++) {
        array[i][0] = 0;
    }
    //d为代表d元组
    for (int i = 0; i < d; i++) {
        for (int j = 0; j < a.length; j++) {//分配过程
            // 取第i位数
            int data = (int) (a[j] / (Math.pow(10, i) == 0 ? 1 : Math.pow(10, i))) % 10;
            int index = ++array[data][0];
            array[data][index] = a[j];
        }
        for (int t = 0, j = 0; t < 10; t++) {//收集过程
            for (int k = 1; k <= array[t][0]; k++)
                a[j++] = array[t][k];
            array[t][0] = 0;
        }
    }
}