C++实现排序算法之归并排序

一、算法思想
该算法是典型的分治策略算法，基本思想是将待排序数组分成若干个小数组，直到为单个数组（即为有序数组）后（分阶段），再将前面得到的单个数组依次拼接在一起，组成有序数组（治阶段）。
动态效果示意图如下：

按步骤来看：



先来实现将一个数组分成两部分：
代码如下：

#include <iostream>
using namespace std;

void merge(int arr[], int left, int mid, int right)
{
	int left_size = mid - left;    //设置左边部分数组的范围
	int right_size = right - mid + 1;  //设置右边数组部分的范围
	int left_num[100];    //创建左右两个数组，用来存储原数组分成的两部分
	int right_num[100];
	int i, j, k;

	//将输入的数组前半部分复制到left_num中
	for (i = left; i < mid; i++)
	{
		left_num[i - left] = arr[i];
	}
	//将输入的数组前半部分复制到right_num中
	for (i = mid; i <= right; i++)
	{
		right_num[i - mid] = arr[i];
	}
	for (i = 0; i < left_size; i++)  //将左侧数组输出
	{
		cout << left_num[i] << " ";
	}
int main()
{
	int arr[] = { 2, 5, 4, 3, 9, 1 };
	int left = 0;
	int mid = 3;
	int right = 5;
	merge(arr, left, mid, right);
	//mergeSort(arr, left,  right);

	/*for (int s = 0; s <= right; s++)
	{
		cout << arr[s] ;
	}*/
	system("pause");
	return 0;
}

运行结果：

再来实现将分割后的数组进行合并的操作

#include <iostream>
using namespace std;
void merge(int arr[], int left, int mid, int right)
{
	int left_size = mid - left;
	int right_size = right - mid + 1;
	int left_num[100];
	int right_num[100];
	int i, j, k;

	//将输入的数组前半部分复制到left_num中
	for (i = left; i < mid; i++)
	{
		left_num[i - left] = arr[i];
	}
	//将输入的数组前半部分复制到right_num中
	for (i = mid; i <= right; i++)
	{
		right_num[i - mid] = arr[i];
	}

	for (i = 0; i < left_size; i++)
	{
		cout << left_num[i] << " ";
	}

	//将上边的左右数组比较大小后合并到一个数组中
	i = 0, j = 0, k = left;
	while (i < left_size && j < right_size)  
	{
		if (left_num[i] < right_num[j])  //按照从小到大的顺序将元素一次放到arr中
		{
			arr[k] = left_num[i];
			i++;
			k++;
		}
		else
		{
			arr[k] = right_num[j];
			j++;
			k++;
		}
	}
	while (i < left_size)   //如果右边部分的数组都放进arr中而左边部分的还有未放入的，就将左边剩余的全部放入
	{
		arr[k] = left_num[i];
		i++;
		k++;
	}
	while (j < right_size)
	{
		arr[k] = right_num[j];
		j++;
		k++;
	}

}
int main()
{
	int arr[] = { 2, 5, 4, 3, 9, 1 };
	int left = 0;
	int mid = 3;
	int right = 5;
	//merge(arr, left, mid, right);
	//mergeSort(arr, left,  right);

	for (int s = 0; s <= right; s++)
	{
		cout << arr[s] ;
	}
	system("pause");
	return 0;
}

运行结果如下：

此时合并成的数组并不是完全有序的，问题在哪呢？我们还没有将原始数组分隔到最小个数，即每个子数组只剩下一个元素的时候，这时候的数组必定是有序的，之后我们再一个一个的将他们比较大小后存储到新的数组中，就完成了排序：
代码如下：

#include <iostream>
using namespace std;

void merge(int arr[], int left, int mid, int right)
{
	int left_size = mid - left;
	int right_size = right - mid + 1;
	int left_num[100];
	int right_num[100];
	int i, j, k;

	//将输入的数组前半部分复制到left_num中
	for (i = left; i < mid; i++)
	{
		left_num[i - left] = arr[i];
	}
	//将输入的数组前半部分复制到right_num中
	for (i = mid; i <= right; i++)
	{
		right_num[i - mid] = arr[i];
	}

	/*for (i = 0; i < left_size; i++)
	{
		cout << left_num[i] << " ";
	}*/

	//将上边的左右数组比较大小后合并到一个数组中
	i = 0, j = 0, k = left;
	while (i < left_size && j < right_size)  
	{
		if (left_num[i] < right_num[j])  //按照从小到大的顺序将元素一次放到arr中
		{
			arr[k] = left_num[i];
			i++;
			k++;
		}
		else
		{
			arr[k] = right_num[j];
			j++;
			k++;
		}
	}
	while (i < left_size)   //如果右边部分的数组都放进arr中而左边部分的还有未放入的，就将左边剩余的全部放入
	{
		arr[k] = left_num[i];
		i++;
		k++;
	}
	while (j < right_size)
	{
		arr[k] = right_num[j];
		j++;
		k++;
	}

}

void mergeSort(int arr[], int left, int right)
{
	if (left == right)
	{
		return;
	}
	else {
		int mid = (left + right) / 2;
		mergeSort(arr, left, mid);
		mergeSort(arr, mid + 1, right);
		merge(arr, left, mid + 1, right);
	}
	
}
int main()
{
	int arr[] = { 2, 5, 4, 3, 9, 1 };
	int left = 0;
	int mid = 3;
	int right = 5;
	//merge(arr, left, mid, right);
	mergeSort(arr, left,  right);

	for (int s = 0; s <= right; s++)
	{
		cout << arr[s] ;
	}
	system("pause");
	return 0;
}

运行结果如下：

此处需要注意：
在进行对分割之后的含有单个元素的数组进行合并的时候，需要分清楚界限，如下

void mergeSort(int arr[], int left, int right)
{
	if (left == right)
	{
		return;
	}
	else {
		int mid = (left + right) / 2;
		mergeSort(arr, left, mid);
		mergeSort(arr, mid + 1, right);
		merge(arr, left, mid + 1, right);
	}
	
}

上面代码的merge()函数中的mid+1参数，一定要和前边分割数组时候的中间界限所对应，不然会排不成正确的顺序。
二、算法分析：
1、时间复杂度
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(n*log2n)。

2、空间复杂度
由前面的算法说明可知，算法处理过程中，需要开辟两个临时数组分别用于存放原属数组的左右两部分。
3、算法稳定性
在归并排序中，相等的元素的顺序不会改变，所以它是稳定的算法。

参考：
https://cuijiahua.com/blog/2018/01/algorithm_7.html
https://www.bilibili.com/video/BV1Ax411U7Xx?from=search&seid=16351317226075614844