数据结构——归并排序

最新推荐文章于 2022-05-19 21:34:03 发布

然后就去远行吧

最新推荐文章于 2022-05-19 21:34:03 发布

阅读量242

点赞数

分类专栏：数据结构——排序算法

本文链接：https://blog.csdn.net/qq_37388085/article/details/104452156

版权

数据结构——排序算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 归并排序

分治模型在每层递归时都有三个步骤：

分解原问题为若干子问题，这些子问题是原问题的规模较小的实例；
解决这些子问题，递归地求解各子问题。然而，若子问题的规模足够小，则直接求解；
合并这些子问题的解成原问题的解；

归并排序算法完全遵循分治模式。直观上其操作如下：

分解：分解待排序的n个元素的序列成各具有n/2个元素的两个子序列；
解决：使用归并排序递归地排序两个子序列；
合并：合并两个已排序的子序列以产生已排序的答案；

归并排序算法的关键操作是“合并”步骤中两个已经排序序列的合并。我们通过一个辅助过程MERGE(A, p, q, r)来完成合并，其中A是一个数组，p、q和r是数组下标，满足 $p\leq q \leq r$ 。该过程假设子数组A[p…q]和A[q+1…r]都已排好序。它合并这两个子数组形成单一的已排好序的子数组并代替当前的子数组A[p…r]。

过程MERGE需要 $\theta(n)$ 的时间，其中n=r-p+1是待合并元素的总数。它按以下方式工作。回到我们玩扑克牌的例子，假设桌子上有两堆牌面朝上的牌，每堆都已排好序，最小的牌在顶上。我们希望这两堆牌合并成单一的排好序的输出堆，牌面朝下地放在桌子上。

我们的基本步骤包括在牌面朝上的两堆牌的顶上两张牌中选取较小的一张，将该牌从其堆中移开（该堆的顶上将显露一张新牌）并牌面朝下地将该牌放置到输出堆。重复这个步骤，直到一个输出堆为空，这时，我们只是拿起剩余的输入堆并牌面朝下地将该堆放置到输出堆。因为我们只是比较顶上的两张牌，所以计算上每个基本步骤需要常量时间。因为我们最多执行n个基本步骤，所以合并需要 $\theta(n)$ 的时间。

下面的伪代码实现了上面的思想，但有一个额外的变化，以避免在每个基本步骤必须检查是否堆有空。在每个堆的底部放置一张哨兵牌，它包含一个特殊的值，用于简化代码。这里，我们使用无穷大作为哨兵值，结果每当显露一张值为无穷大的牌，它不可能为较小的牌，除非两个堆都已显露出其哨兵牌。但是，一旦发生这种情况，所有非哨兵牌都已被放置到输出堆。因为我们事先知道刚好r-p+1张牌被放置到输出堆，所以一旦已执行r-p+1个基本步骤，算法就可以停止。

MERGE(A, p, q, r)
n1 = q - p + 1
n2 = r - q
let L[1..n1+1] and R[1..n2+1] be new arrays
for i = 1 to n1
    L[i] = A[p + i -1]
for j = 1 to n2
    R[j] = A[q + j]
L[n1+1] = 无穷大
R[n2+1] = 无穷大
i = 1
j = 1
for k=p to r
    if L[i] <= R[j]
        A[k] = L[i]
        i = i + 1
    else A[k] = R[j]
        j = j + 1

从MERGE的伪代码中可以发现，时间复杂度为 $\theta(n)$ ，空间复杂度为 $\theta(n)$ ，因为需要n个额外空间进行数据的重排。

现在我们可以把过程MERGE作为归并排序算法中的一个子程序来用。下面的过程MERGE-SORT(A, p, r)排序子数组A[p…r]中的元素。若 $p\geq r$ ，则该子数组最多有一个元素，所以已经排好序。否则，分解步骤简单地计算一个下标q，将A[p…r]分成两个子数组A[p…q]和A[q+1…r]，前者包含 $\left \lfloor n/2 \right \rfloor$ 个元素，后者包含 $\left \lfloor n/2 \right \rfloor$ 个元素。

MERGE-SORT(A, p, r)
if p < r
    q = (p+r)/2（向下取整）
    MERGE-SORT(A, p, q)
    MERGE-SORT(A, q+1, r)
    MERGE(A, p, q, r)

C++代码实现：

#include <iostream>
#include<vector>
#include<math.h>
using namespace std;


void merge(vector<int>& arr, int p, int q, int r)
{
    int n1 = q-p+1;
    int n2 = r-q;
    vector<int> L;
    vector<int> R;
    for(int i=0;i<n1;++i)
    {
        L.push_back(arr[p+i]);
    }
    L.push_back(INT_MAX);
    for(int j=1;j<=n2;j++)
    {
        R.push_back(arr[q+j]);
    }
    R.push_back(INT_MAX);
    int i = 0;
    int j = 0;
    for(int k=p;k<=r;++k)
    {
        if(L[i]<=R[j]) {
            arr[k] = L[i];
            ++i;
        }
        else
        {
            arr[k] = R[j];
            ++j;
        }
    }
}

void merge_sort(vector<int>& arr, int p, int r)
{
    if(p<r)
    {
        int q = floor((r+p)/2);
        merge_sort(arr,p,q);
        merge_sort(arr,q+1,r);
        merge(arr,p,q,r);
    }
}

int main() {
    vector<int> arr;
    int num;
    int n=0;
    while(cin>>num )  //输入eof结束
    {
        arr.push_back(num);
        n++;
    }
    merge_sort(arr,0,n-1);
    for (int i = 0; i < arr.size(); i++) {
        cout << arr[i] << ",";
    }
    return 0;
}

python代码实现

def merge_sort(collection):

    def merge(left, right):
        result = []
        while left and right:
           result.append((left if left[0] <= right[0] else right).pop(0))
        return result + left + right
        
    if len(collection) <= 1:
        return collection
        
    mid = len(collection) // 2
    return merge(merge_sort(collection[:mid]), merge_sort(collection[mid:]))


if __name__ == "__main__":
    user_input = input("Enter numbers separated by a comma:\n").strip()
    unsorted = [int(item) for item in user_input.split(",")]
    print(*merge_sort(unsorted), sep=",")