归并排序
归并排序是经典算法Divide and Conquer的实际应用之一，具体实现就是建立在 归并操作的基础之上。将两个已然有序的子序列合并成为一个 更大的有序序列，所以前提：子序列要先行有序。通常我们将两个有序表合并成一个有序表，称之为2-路归并。
具体做法就是：把长度为n的无序序列，先分成两个长度为 n/2的子序列；对这两个子序列接着进行 归并排序；子序列有序之后，进行子序列的归并成最后结果。（大家这样一看，就有了一些 递归的意味了）不错，我在这里也分别给出 递归版本 和 非递归版本。
排序步骤就是：- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
- 重复步骤 3 直到某一指针达到序列尾；
- 将另一序列剩下的所有元素直接复制到合并序列尾。
| 分析具体实现： |
如上图所示（从菜鸟网站“拿”来的）：面对下面的一组数据：
1,50,38,5,47,15,36,26,27,2,46,4,19,44,48
| 分析具体算法： |
- 归并排序的算法时间复杂度最好情况为O(nlog2n)，最坏情况下也是O(nlog2n)。则其平均时间复杂度为O(nlog2n)。归并排序的空间复杂度就是申请的的临时数组所占用的空间：n；所以空间复杂度为: O(n)
- 归并排序的核心思想是分治法，即将待排序数据分成多个小块，对每个小块进行排序，然后在两两合并小块，最终完成对整体的排序。
- 归并排序复杂度分析：一趟归并需要将待排序列中的所有记录扫描一遍，因此耗费时间为O(n),而由完全二叉树的深度可知，整个归并排序需要惊醒[log2n],因此，总的时间复杂度为O(nlogn),而且这是归并排序算法中最好、最坏平均的时间性能。空间复杂度：由于归并过程中需要与原始记录序列同样数量级的存储空间去存放归并结果及递归深度为log2N的栈空间，因此空间复杂度为O(n+logN)也就是说，归并排序是一种比较占内存，但却效率高且稳定的算法。
| 算法递归实现的版本： |
递归实现：递归类似于对此方法的场景再现，即先对整体进行划分，然后对划分后的部分进行排序（对递归函数的理解可以认为是从上层向下层进入），排序好之后再进行合并（可以认为是从下层上层开始返回）。
//一直向下递归 左右两侧都return的时候，进行调整 完了之后返回上一层 继续
void Merge_sort_Recur(vector<int>& src, int low, int high)
{
if (low == high)//把检查边缘问题放在递归循环的外侧
return;
int mid = (high - low) / 2 + low;
Merge_sort_Recur(src, low, mid);
Merge_sort_Recur(src, mid + 1, high);
//接下来就是进行归并了（递归开始返回了）
vector<int> tem_vec;//这是起中间过渡的作用，放有序部分 数据
tem_vec.resize(high - low + 1);
int i = low, j = mid + 1, k = 0;//k是临时数组的下标
while (i <= mid && j <= high)
{
if (src[i] > src[j])
{
tem_vec[k++] = src[j++];
}
else
{
tem_vec[k++] = src[i++];
}
}
while (i <= mid)
{
tem_vec[k++] = src[i++];
}
while (j <= high)
{
tem_vec[k++] = src[j++];
}
//数据次序调整结束了
//处理结束了 得把有序数据还给src
k = 0;
for (int i = low; i <= high; ++i)
{
src[i] = tem_vec[k++];
}
}
void merge_sort1(vector<int>& src)//递归版本
{
int size = src.size();
if (size <= 1)
return;
Merge_sort_Recur(src, 0, size - 1);
}
| 算法迭代实现的版本： |
非递归的方法，避免了递归时深度为log2N的栈空间，空间只是用到归并临时申请的跟原来数组一样大小的空间，并且在时间性能上也有一定的提升，因此，使用归并排序时，尽量考虑用非递归的方法。
void MergeSortNonRecursion(vector<int>& src)
{
int size = src.size();
if (size <= 1)
return;
vector<int> tem_vec;//这是起中间过渡的作用，放有序部分 数据
tem_vec.resize(size);
//逐级上升，第一次比较2个，第二次比较4个，第三次比较8个。。。
for (int level = 1; level < size; level *= 2)
{
int left_min, left_max, right_min, right_max;
//每次都是从数组的头元素开始 i=0
for (left_min = 0; left_min < size - level;
left_min = right_max)
{
right_min = left_max = left_min + level;
right_max = left_max + level;
//右边的下标最大值只能为size
if (right_max > size)
{
right_max = size;
}
int k = 0;//k是临时数组的下标
//如果左边的数据还没达到分割线且右边的数组没到达分割线，开始循环
while (left_min < left_max && right_min < right_max)
{
if (src[left_min] < src[right_min])
{
tem_vec[k++] = src[left_min++];
}
else
{
tem_vec[k++] = src[right_min++];
}
}
//上面循环结束的条件有两个，如果是左边的游标尚未到达，那么需要把
//数组接回去，可能会有疑问，那如果右边的没到达呢，其实模拟一下就可以
//知道，如果右边没到达，那么说明右边的数据比较大，这时也就不用移动位置了
while (left_min < left_max)
{
//如果left_min小于left_max，说明现在左边的数据比较大
//直接把它们接到数组的min之前就行
src[--right_min] = src[--left_max];
}
while (k > 0)
{
//把排好序的那部分数组返回该k
src[--right_min] = tem_vec[--k];
}
}
}
}
void merge_sort2(vector<int>& src)//非递归的实现
{
MergeSortNonRecursion(src);
}
| 算法测试打印： |
#include <iostream>
#include <vector>
#include <iomanip>
#include <algorithm>
#include <assert.h>
using namespace std;
//一直向下递归 左右两侧都return的时候，进行调整 完了之后返回上一层 继续
void Merge_sort_Recur(vector<int>& src, int low, int high)
{
if (low == high)//把检查边缘问题放在递归循环的外侧
return;
int mid = (high - low) / 2 + low;
Merge_sort_Recur(src, low, mid);
Merge_sort_Recur(src, mid + 1, high);
//接下来就是进行归并了（递归开始返回了）
vector<int> tem_vec;//这是起中间过渡的作用，放有序部分 数据
tem_vec.resize(high - low + 1);
int i = low, j = mid + 1, k = 0;//k是临时数组的下标
while (i <= mid && j <= high)
{
if (src[i] > src[j])
{
tem_vec[k++] = src[j++];
}
else
{
tem_vec[k++] = src[i++];
}
}
while (i <= mid)
{
tem_vec[k++] = src[i++];
}
while (j <= high)
{
tem_vec[k++] = src[j++];
}
//数据次序调整结束了
//处理结束了 得把有序数据还给src
k = 0;
for (int i = low; i <= high; ++i)
{
src[i] = tem_vec[k++];
}
}
void merge_sort1(vector<int>& src)//递归版本
{
int size = src.size();
if (size <= 1)
return;
Merge_sort_Recur(src, 0, size - 1);
}
void MergeSortNonRecursion(vector<int>& src)
{
int size = src.size();
if (size <= 1)
return;
vector<int> tem_vec;//这是起中间过渡的作用，放有序部分 数据
tem_vec.resize(size);
//逐级上升，第一次比较2个，第二次比较4个，第三次比较8个。。。
for (int level = 1; level < size; level *= 2)
{
int left_min, left_max, right_min, right_max;
//每次都是从数组的头元素开始 i=0
for (left_min = 0; left_min < size - level;
left_min = right_max)
{
right_min = left_max = left_min + level;
right_max = left_max + level;
//右边的下标最大值只能为size
if (right_max > size)
{
right_max = size;
}
int k = 0;//k是临时数组的下标
//如果左边的数据还没达到分割线且右边的数组没到达分割线，开始循环
while (left_min < left_max && right_min < right_max)
{
if (src[left_min] < src[right_min])
{
tem_vec[k++] = src[left_min++];
}
else
{
tem_vec[k++] = src[right_min++];
}
}
//上面循环结束的条件有两个，如果是左边的游标尚未到达，那么需要把
//数组接回去，可能会有疑问，那如果右边的没到达呢，其实模拟一下就可以
//知道，如果右边没到达，那么说明右边的数据比较大，这时也就不用移动位置了
while (left_min < left_max)
{
//如果left_min小于left_max，说明现在左边的数据比较大
//直接把它们接到数组的min之前就行
src[--right_min] = src[--left_max];
}
while (k > 0)
{
//把排好序的那部分数组返回该k
src[--right_min] = tem_vec[--k];
}
}
}
}
void merge_sort2(vector<int>& src)//非递归的实现
{
MergeSortNonRecursion(src);
}
int main()
{
int Array[] = { 1,50,38,5,47,15,36,26,27,2,46,4,19,44,48 };
int Array2[] = { 3,2,4,6,5 };
vector<int>myvec(begin(Array), end(Array));
merge_sort1(myvec);
cout << "排序shell_sort1结束后，最终结果：";
for (int val : myvec)
{
cout << setw(2) << val << " ";
}
cout << endl;
cout << "**********************************" << endl;
vector<int>myvec2(begin(Array), end(Array));
merge_sort2(myvec2);
cout << "排序shell_sort2结束后，最终结果：";
for (int val : myvec2)
{
cout << setw(2) << val << " ";
}
cout << endl;
return 0;
}
2019年8月22日21:13:52
扫一扫
1216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
