归并排序+Master公式+小和问题

归并排序+Master公式+小和问题

归并排序

先来谈谈代码很巧妙的一种排序，归并排序。

什么是归并排序？我喜欢先进行字面上的理解，先归纳整理好，再并在一起排序。

比如有一个乱序的数组，在底下标上角标：

我们将这个数组一分为二，分别将左右两侧的数排序好。然后开辟出一个临时的空间（数组）来存放我们最后排好序的元素。接着，我们分别用指针p1,p2指向左右两边的第一个数，如下：

现在，比较两个指针指向的数，如果p1<=p2，将p1放进临时空间里，并将p1向右移一位。随后，我们进行第二轮比较，即左边的2和右边的1比较，因为p1>p2，所以将p2指向的1放入空间里，并将p2向右移一位，以此类推。

当p1指针移动到了左侧的尽头，即越界了，那直接从p2指针的位置开始，将剩下的数依次放入临时空间里，完成归并排序。

---

来看具体代码

#include <stdio.h>

void sort(int a[], int L, int R)
{
    if (L == R)
        return;
    int mid = L + ((R - L) >> 1);//防止越界的求中值
    sort(a, L, mid);//递归，将左边的排好序
    sort(a, mid + 1, R);//排右边
    merge(a, L, mid, R);//带入归并
}

void merge(int a[], int L, int M, int R)
{
    int help[200];//临时存储的空间
    int i = 0;
    int p1 = L;//指针指向左边的最左位置
    int p2 = M + 1;//右指针
    while (p1 <= M && p2 <= R)
    {
        help[i++] = a[p1] <= a[p2] ? a[p1++] : a[p2++];//比较两个指针谁更小就放入临时空间，指针后移
    }
    while (p1 <= M)//以下两个whlie只会执行一个，即有一边已经越界，只需将剩下的数放入空间
        help[i++] = a[p1++];
    while (p2 <= R)
        help[i++] = a[p2++];

    for (i = 0; i < R - L + 1; i++)//将空间里排好的数放入原数组
        a[L + i] = help[i];
}

int main()
{
    int a[5];
    int i;
    for (i = 0; i < 5; i++)
    {
        scanf("%d", &a[i]);
    }
    sort(a, 0, 4);//这里带入4，不是5，最大角标为4
    for (i = 0; i < 5; i++)
        printf("%d ", a[i]);
    return 0;
}

这里补充一点关于求中值的问题，一般来说我们知道数组头尾的角标，求中值可以是(头+尾)/2，但是题目条件苛刻的话，头+尾的和在它们的数据类型中可能会溢出，导致得到的mid为负值，所以我们可以改良为头+(尾-头)/2,并结合位运算比算数运算快这一点，最终就可以变成：

mid = L + ((R - L) >> 1);

特别注意：加减乘除的优先级比位运算要高，在混合运算时注意加上括号！

---

归并排序很好的运用了递归的思想，并在细节上做出了优化，为了方便后续将它跟其他排序方法进行对比。这里介绍如何计算递归方法的时间复杂度——Master公式。

Master公式：T(N)=aT(N/b)+O(N^d)*

①当d<logb a时，时间复杂度为O(n^(logb a))
②当d=logb a时，时间复杂度为O((n^d)logn)
③当d>logb a时，时间复杂度为O(n^d)

这里的T(N)指的是母问题的规模是N，而T(N/b)指的是子问题都是等规模的，且一共有a个这样的子问题，末尾的O(N^d)指的是子问题之外剩下的语句调用的时间复杂规模。

来求一求归并排序的时间复杂度：

递归存在于sort函数里，第一次是将左边的排好序，第二次是将右边的排好序，它们的规模都是占数组的一半，所以有2*T(N/2)。那非递归的其他语句呢？不难注意到除了递归的语句集中在merge函数中，而merge函数的实质，是两个指针分别从左指向右，各遍历了一半的数据，等效于遍历一遍，所以这部分的时间复杂度是O(N)。即：

T(N)=2*T(N/2)+O(N^1);
logb a==d;
//所以时间复杂度为O(nlogn)

---

下面来看两个关于归并排序的问题

• 小和问题
  在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组 的小和。
  例子:[1,3,4,2,5] 1左边比1小的数，没有; 3左边比3小的数，1；4左边比4小的数，1、3；2左边比2小的数，1；5左边比5小的数，1、3、4、2；所以小和为1+1+3+1+1+3+4+2=16

对于该问题，题意解释的是一种看法，想到的方法有用一个指针向右移，一个变量负责统计小和，指针每移动一个数，就遍历该数左边的所有数是否小于当前指针所指向的数。这样做固然能得到小和，但显然每一次的遍历量增加，构成等差数列，时间复杂度将来到O(N^2)，如何将时间复杂度降低？

对此可以换一种看法：即向右看，有几个数比当前数大，后续就将产生几个当前数统计进小和里，比如，对于3来说，后续有4,5比自己大，所以在此将两个3加进小和里。但如果就此打住，这种看法和原始的问题是等效的。

所以，我们还可以运用归并的思想进行简化。

以1 3 4 2 5为例

先是递归将它们不断对半拆分，拆分后在merge，见图：

在底下的merge中，同样用两个指针指向左右两侧的第一个数，然后对指针所指向的数进行分析，在两个指针都没有越界的情况下，比较p1和p2指向的数谁大，如果p2大，则默认p2以后所有数都比p1大，即将这些数加入小和中，由此发现有一个前提，merge过程中顺序是排好了的，才能默认。

接着将p1指向的数放入临时空间里。如开始指向的1和3，先将1放入空间里，p1越界，再将p3放入空间里，进入上一层merge——1、3和4。

上代码：

int process(int a[], int L, int R)
{
    if (L == R)
        return 0;
    int mid = L + ((R - L) >> 1);//防越界求中点

    return (process(a, L, mid) +
            process(a, mid + 1, R) +
            merge(a, L, mid, R));//左边的小和+右边的小和+左右归并后的小和
}

int merge(int a[], int L, int M, int R)
{
    int help[100];//申请一块空间来存储数据
    int i = 0;
    int p1 = L;
    int p2 = M + 1;
    int res = 0;

    while (p1 <= M && p2 <= R)
    {//如果p2>p1，则直接有右侧的角标相减得到需要加入小和的数的个数
        res += a[p1] < a[p2] ? (R - p2 + 1) * a[p1] : 0;
        help[i++] = a[p1] < a[p2] ? a[p1++] : a[p2++];
    }
    while (p1 <= M)
    {
        help[i++] = a[p1++];
    }
    while (p2 <= R)
    {
        help[i++] = a[p2++];
    }
    for (i = 0; i < R - L + 1; i++)
        a[L + i] = help[i];

    return res;//返回统计的小和值
}

int main()
{
    int a[5] = {1, 3, 4, 2, 5};
    int r = sizeof(a) / sizeof(int);
    int b = process(a, 0, r - 1);
    printf("%d", b);//打印小和值

    return 0;
}

因为每一层递归的右边的数都是不同的，又小和判断的实质是“右边相较于左边而言…”，所以不存在重复统计的现象。

结合归并排序和master公式，这样求小和的时间复杂度是降到了O(n*logn)。

• 逆序对问题

在一个数组中，左边的数比右边的大，则这两个数构成一个逆序对，请求出逆序对的个数。

如数组[3,2,4,5,1]，存在的逆序对有(3,2),(3,1),(2,1),(4,1),(5,1)，一共5对。可以发现这个问题其实就和小和问题反了条件，这次判断左边的数是否比右边的数大了。

int process(int a[], int l, int r)
{
	if (l == r)
	{
		return 0;
	}
	int mid = l + ((r - l) >> 1);//这里要注意加减乘除的优先级比位运算要高，一定要加括号
	return process(a, l, mid) + process(a, mid + 1, r) + merge(a, l, mid, r);
}

int merge(int a[], int l, int m, int r)
{
	int p1 = l;
	int p2 = m + 1;
	int res = 0; // res是result的缩写，代表最终答案，这里作计数器
	int i = 0;
	int help[200]; //临时空间，放置递归后排好序的数

	while (p1 <= m && p2 <= r)
	{
		res += a[p1] > a[p2] ? (m - p1 + 1) : 0;
		help[i++] = a[p1] > a[p2] ? a[p2++] : a[p1++];
	}
	while (p1 <= m)
	{
		help[i++] = a[p1++];
	}
	while (p2 <= r)
	{
		help[i++] = a[p2++];
	}
	for (i = 0; i < r - l + 1; i++)
	{
		a[l + i] = help[i];
	}
	return res;
}

int main()
{
	int a[5] = {3, 2, 4, 5, 1};
	int length = sizeof(a) / sizeof(int);
	int b = process(a, 0, length - 1);

	printf("%d", b);
	return 0;
}

感谢你看到这里，希望对你有帮助！