排序算法总结

排序算法学习总结

本文中的思路代码皆借鉴于《大话数据结构》

冒泡排序法

算法描述：
给一个待排序的数组，固定其中一端，从另一端开始两两比较，如果反序则交换，直到没有反序的记录为止。在此过程中，数字较小（或较大）的慢慢从数组的一端向另一端移动，如同气泡慢慢浮上水面。

代码实现：

boolean flag = true;public void sort() {    for (int i = 0; i < array.length - 1 && flag; i++) {        //每次循环初始为false，若在一个循环里没有发生数据交换，则排序结束。        flag = false;        for (int j = array.length - 1; j > i; j--) {            if (array[j - 1] > array[j]) {                Swap.swap(array, j - 1, j);                flag = true;            }        }    }}

复杂度分析：
- 对于长度为N的数组，在初始有序的情况下，循环次数为N-1，交换次数为0；
- 初始反序的情况下，循环次数为(N-1)N/2次，交换次数为(N-1)N/2；

---

简单选择排序

算法描述：
每一次循环在n-i+1个记录里选取最小的记录，并和第i个记录交换，作为有序序列的第i个记录。

代码实现：

public void sort( ){    int min = 0;    for(int i = 0;i<length();i++){        min = i;        for(int j = i+1;j<length();j++){            if(array[min]>array[j]){                min = j;            }        }        if(min!=i){            Swap.swap(array, min, i);        }    }}

复杂度分析：
- 给定一个长为N的数组，若初始为有序，则循环次数为(N-1)N/2，交换次数为0；
- 若初始反序，则循环次数为(N-1)N/2，交换次数为N/2；

---

直接插入排序

算法描述：
将一个数据插入到已经排序好的有序数组中。

代码实现：

public void sort(){    int temp = 0;    int i,j=0;    for(i = 1;i<length();i++){        if(array[i]<array[i-1]){            temp = array[i];//记录待插入的数            for(j = i-1;j>=0&&array[j]>temp;j--){                array[j+1] = array[j];//比待插入的数大的往后移            }            array[j+1] = temp;//将待插入的数插入正确的位置        }    }}

复杂度分析：
- 给定一个长为N的数组，若初始为有序，则比较次数为N-1，移动次数为0；
- 若初始反序，则比较次数为(N-1)+(N-1)N/2=(N+2)(N-1)/2次，移动次数为(N+2)(N-1)/2次。

---

希尔排序

算法描述：
将待排序数组分成几块，对每一块进行直接插入排序，当整个序列基本有序后，再进行一次总的直接插入排序。

代码实现：

public void sort() {    int i, j = 0;    int temp = 0;    //increment为增量，初始为数组长度，代表将每个数据看做一个子块，再在每次循环中减小increment的大小，即将数组看成若干块，直至为1循环结束，排序结束    int increment = length();    do {        increment = increment / 3 + 1;//经验公式        for (i = increment ; i < length(); i++) {            if (array[i - increment] > array[i]) {                temp = array[i];                for (j = i - increment; j >= 0 && array[j] > temp; j -= increment) {                    array[j + increment] = array[j];                }                array[j + increment] = temp;            }        }    } while (increment > 1);}

复杂度分析：
时间复杂度为O(n^(3/2))

---

堆排序

算法分析：
堆排序就是利用堆（如大顶堆）进行排序的方法。它的基本思想是将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将其与序列最后一个数交换，此时最后一个数就是最大值。然后将剩余n-1个数构造成一个大顶堆，重复上述过程，完成排序。

代码实现：

/*** * 堆调整 * @param node 待调整的节点 * @param end 堆的最后一个节点 */private void heapAdjust(int node , int end){    int temp = array[node];    //对于节点i，若有子节点，则第2i+1个节点为其左节点，2(i+1)个节点为其右节点    for(int i = node*2+1;i<end;i=2*i+1){        if(i<end-1&&array[i]<array[i+1]) i++;//若右节点较大，则与右节点互换        if(temp>array[i]) break;//若根节点更大，则不调整，结束循环        array[node] = array[i];        node = i;    }    array[node] = temp;}public void sort(){    //构建大顶堆    for(int i = length()/2-1;i>=0;i--){        heapAdjust(i,length());    }    //排序    for(int j = length()-1;j>0;j--){        Swap.swap(array, j, 0);        heapAdjust(0,j);    }} 

复杂度分析：
- 构建堆时，每个非终端节点最多进行两次比较和互换，因此构建堆的时间复杂度为O(n)；
- 排序时，第i次取堆顶记录重建堆要用O(logi)的时间（完全二叉树的某节点i到根节点的距离为logi+1），并且需要取n-1次堆顶数据，因此时间复杂度为O(nlogn)；
- 故总体来说，堆排序的时间复杂度为O(nlogn)。

---

归并排序

算法分析：
假设初始序列有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或1的有序子序列，再两两归并……直至得到一个长度为n的有序序列为止，此为2路归并排序。

代码实现：

public void sort() {    mergeSort(array, array, 0, length() - 1);}//将sr[s..t]归并排序为tr1[s..t]public void mergeSort(int[] sr, int[] tr1, int s, int t) {    int m = (s + t) / 2;//将sr[s..t]平分为sr[s..m]和sr[m+1..t]    int[] tr2 = new int[length()];    if (s == t) {        tr1[s] = sr[s];    } else {        mergeSort(sr, tr2, s, m);        mergeSort(sr, tr2, m + 1, t);        merge(tr2, tr1, s, m, t);//将tr[s..m]和sr[m+1..t]归并待tr1[s..t]    }}public void merge(int[] sr, int[] tr, int s, int m, int t) {    int j, k, l;    //将sr中记录由小到大归并到tr    for (j = m + 1, k = s; s <= m && j <= t; k++) {        if (sr[s] < sr[j]) {            tr[k] = sr[s++];        } else {            tr[k] = sr[j++];        }    }    //将剩余的sr[s..m]复制到tr    if (s <= m) {        for (l = k ; l <= t; l++) {            tr[l] = sr[s++];        }    }    //将剩余的sr[j..n]复制到tr    if (j <= t) {        for (l = k ; l <= t; l++) {            tr[l] = sr[j++];        }    }}

复杂度分析：

• 一趟归并需要将sr[0]~sr[n-1]中相邻的长度为h的有序序列进行两两归并。并将结果放到tr[0]~tr[n-1]中，这需要将待排序列中的所有记录扫描一遍，因此耗费O(n)时间；
• 由完全二叉树的深度可知，整个归并排序需要进行logn次；
• 故总的时间复杂度为O(nlogn）。
• 归并过程中需要与待排序序列同样大小的存储空间以及递归深度为logn的栈空间，因此空间复杂度为O(n+logn)。
• 此外，因为需要两两比较，不存在跳跃，因此是一种稳定的排序算法。

归并排序的非递归实现：

public void sort(int[] tr) {    int k = 1;    while (k < length()) {        mergePass(array, tr, k, length() - 1);        k = k << 1;        mergePass(tr, array, k, length() - 1);        k = k << 1;    }}public void mergePass(int[] sr, int[] tr, int s, int n) {    int i = 0;    while (i < n - 2 * s + 1) {        merge(sr, tr, i, i + s - 1, i + 2 * s - 1);//两两归并        i = i + 2 * s;    }    if (i <= n - s + 1) {//归并最后两个序列        merge(sr, tr, i, i + s - 1, n);    } else {//最后只剩一个序列        for (int j = i; j < n; j++) {            tr[j] = sr[j];        }    }}

复杂度分析：

• 非递归的迭代方法，避免了递归时深度为logn的栈空间，因此空间复杂度为O(n)，避免地柜时间性能上也有一定的提升（递归时函数进出栈需要消耗时间）。

---

快速排序

算法分析：
通过一趟排序将待排序记录分割成独立的两部分，其中一部分均比另一部分小，则可分别对这两部分继续进行排序，直至整个序列有序。

代码实现：

public void sort(){    qSort(0, length()-1);}protected void qSort(int low , int high){    int pivot;    if(low<high){        pivot = partition(low,high);//将array[low..high]分为两部分，在枢纽值pivot之前的都比其小，在其后的都比其大        qSort(low, pivot-1);        qSort(pivot+1, high);    }}protected int partition(int low , int high){    int pivotKey = array[low];//将待排序部分的第一个值作为枢纽值    while(low<high){//从两端交替向中间扫描        while(low<high&&array[high]>pivotKey)            high--;        Swap.swap(array, low, high);//将比枢纽值小的交换到前端        while(low<high&&array[low]<=pivotKey)            low++;        Swap.swap(array, low, high);//将比枢纽值大的交换到后端    }    //最终low=high，返回枢纽值    return low;}

复杂度分析：

• 在最优情况下，即每次枢纽值都能将待排序序列平分两半，时间复杂度为O(nlogn)，递归造成的栈空间为递归树的深度logn，即空间复杂度为O(logn)；
• 在最坏情况下，即待排序序列为正序或倒序，时间复杂度为O(n^2)，需要进行n-1次调用，空间复杂度为O(n);
• 平均情况下，时间复杂度为O(nlogn)，空间复杂度为O(logn)；
• 由于关键字的比较和交换是跳跃进行的，所以快速排序是一种不稳定的排序方法。

优化：

• 枢纽选取优化：取头、尾和中间值中的中间值

int mid = low+(high-low)/2;if(array[low]>array[high])//左值较小    Swap.swap(array, low, high);if(array[mid]>array[high])//右值最大    Swap.swap(array, mid, high);if(array[mid]>array[low])//中值最小    Swap.swap(array, mid, high);int pivotKey = array[low];

• 不必要的交换优化：替换操作取代交换操作

int pivotKey = array[low];while(low<high){    while(low<high&&array[high]>pivotKey)        high--;    array[low] = array[high];    while(low<high&&array[low]<=pivotKey)        low++;    array[high] = array[low];}array[low] = pivotKey;

• 优化递归操作：尾递归

protected void qSort(int low , int high){    int pivot;    while(low<high){//if改成了while        pivot = partition(low,high);        qSort(low, pivot-1);        low = pivot+1;//尾递归        //qSort(pivot+1, high);    }}

7种算法的指标：

排序方法 平均情况 最好情况 最坏情况 辅助空间 稳定性 冒泡排序 O(n^2) O(n) o(n^2) O(1) 稳定 简单选择排序 O(n^2) O(n^2) o(n^2) O(1) 稳定 直接插入排序 O(n^2) O(n) o(n^2) O(1) 稳定 希尔排序 O(nlogn)~O(n^2) O(n^1/3) o(n^2) O(1) 不稳定 堆排序 O(nlogn) O(nlogn) O(nlogn) O(1) 不稳定 归并排序 O(nlogn) O(nlogn) O(nlogn) O(n) 稳定 快速排序 O(nlogn) O(nlogn) o(n^2) O(logn)~O(n) 不稳定