数据结构--排序之归并排序

本节来讲讲归并排序

归并排序可谓是集速度与稳定性于一身了(时间复杂度O(n log n))，算是一种很强很棒的排序算法了（我个人觉得O(∩_∩)O哈哈~），但是最大的缺点就是花费的空间比较大，空间复杂度为O(n）

归并排序思想：

给定序列r[1...n]，先想想如何给区间r[left, right]内排序？

令mid = (left + right) / 2,将区间r[left, right]一分为二，r[left, mid] 和 r[mid + 1, right]， 分别对这两个区间排序，然后将这两个区间合并，就OK了。

有点摸不到头脑，不急，我们来分析一下：

那么现在的问题来了，如何对子区间r[left, mid] 和 r[mid + 1, right]排序？

对于子区间用上述同样的方法，拆分，再合并。

现在拆分会了，那如何合并呢？ 通过上面的递归拆分后就是相当于对子区间排玩序了，所以两个子区间是有序的，我们只要将两个区间的元素从小到大依次赋值给整个序列。具体操作见代码。

一顿操作后惊奇的发现序列有序了。

话不多说上代码：

#include <bits/stdc++.h>
using namespace std;

#define MAXSIZE 100
typedef int KeyType;
typedef struct///定义每个节点信息
{
    KeyType key;
//    InfoType otherinfo;
}RType;
typedef struct///定义顺序表
{
    RType r[MAXSIZE + 1];
    int length;
}SqList;

void Merge(SqList &L, int left, int mid, int right)
{
    RType *a = new RType[mid-left+2];
    RType *b = new RType[right-mid+1];
    int la = mid - left + 1, lb = right - mid;
    for(int i = 0; i < la; i ++)a[i] = L.r[i+left];
    for(int i = 0; i < lb; i ++)b[i] = L.r[mid+1+i];
    a[la].key = b[lb].key = 10000; ///将子区间的最后一个关键字置为无穷大

    la = lb = 0;
    ///将左右子区间从小到大赋值给待排序列
    for(int i = left; i <= right; i ++)
    {
        if(a[la].key < b[lb].key)L.r[i] = a[la++];
        else L.r[i] = b[lb++];
    }
    delete []a; delete[]b;
}

void MSort(SqList &L, int left, int right)
{
    int mid = (left + right) >> 1;
    if(left < right)
    {
        MSort(L, left, mid);///拆分区间
        MSort(L, mid + 1, right);
        Merge(L, left, mid, right);///合并区间
    }
}

void MergeSort(SqList &L)
{
    MSort(L, 1, L.length);
}
int main()
{
    SqList L;
    printf("请输入序列的个数：");
    scanf("%d", &L.length);
    printf("\n\n请输入序列:");
    for(int i = 1; i <= L.length; i ++)
    {
        scanf("%d", &L.r[i].key);
    }
    MergeSort(L);
    for(int i = 1; i <= L.length; i ++)
    {
        printf("%5d", L.r[i].key);
    }
    printf("\n");
    return 0;
}
/**
10
    70   30   52   29   25   62   49   86    2   13
**/

弱弱的说一下，归并排序是牺牲空间来换取时间上的高效，它既快又稳。