深度剖析归并排序中的双递归

本篇文章为笔者的读书笔记，未经允许请勿转载。如果对你有帮助记得点个赞(●’◡’●)
本文主要对双递归中的抽象细节进行图形式的展示。
源码如下：

main.cpp

// 1排序.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
void random(vector<int>& vec)//随机数生成器
{
	random_device r;
	for (auto& e : vec)
	{
		e = r() % vec.size() + 1;
	}
}

void out(const vector<int>& vec)//输出函数
{
	for (const auto& e : vec)
	{
		cout << e << " ";
	}
	cout << endl;
}

void sortTest(function<void(vector<int>&)> sortFn)//测试函数
{
	vector<int> vec(100);
	random(vec);
	out(vec);
	auto start = clock();//测试时间
	sortFn(vec);
	auto end = clock();
	out(vec);
	auto diff = (float)(end - start) / 1000;
	cout << diff << endl;
}

int _tmain(int argc, _TCHAR* argv[])//主函数，采用了预编译头（个人习惯）
{
	sortTest(sort::mergeSort);
	system("pause");
	return 0;
}
//结果显示
//97 76 21 39 77 89 4 87 26 17 59 54 22 7 64 3 38 70 9 45 24 98 89 2 85 60 41 13 26 89 68 31 68 49 92 27 31 76 8 58 84 57 10 87 30 62 68 92 60 9 7 58 19 4 52 23 64 41 60 51 63 39 58 90 79 71 93 6 61 17 44 19 61 91 71 26 51 97 84 19 80 19 64 39 45 27 44 55 90 21 27 96 46 71 91 95 1 84 88 41
//1 2 3 4 4 6 7 7 8 9 9 10 13 17 17 19 19 19 19 21 21 22 23 24 26 26 26 27 27 27 30 31 31 38 39 39 39 41 41 41 44 44 45 45 46 49 51 51 52 54 55 57 58 58 58 59 60 60 60 61 61 62 63 64 64 64 68 68 68 70 71 71 71 76 76 77 79 80 84 84 84 85 87 87 88 89 89 89 90 90 91 91 92 92 93 95 96 97 97 98
//0.001s

sort.h

#pragma once
#include<vector>
using std::vector;
class sort
{
private:
	static void merge(vector<int>& vec,int l,int mid,int r);
	static void reSolve(vector<int>& vec,int l,int r);
public:
	static void mergeSort(vector<int>& vec);
};

sort.cpp

#include "stdafx.h"
#include "sort.h"
#include<algorithm>
using namespace std;
void sort::mergeSort(vector<int>& vec)
{
	reSolve(vec, 0, vec.size() - 1);
}

void sort::reSolve(vector<int>& vec,int l,int r)
{
	if (l >= r) return;
	int mid = (r - l) / 2 + l;//避免算数溢出
	reSolve(vec, l, mid);	  //拆分左边数据
	reSolve(vec, mid + 1, r); //拆分右边数据
	merge(vec, l, mid, r);    //合并
}

void sort::merge(vector<int>& vec,int l,int mid,int r)
{
	//创建一个临时vector
	vector<int> temp(vec.begin() + l, vec.begin() + r + 1); //注意区分L和1
	int lk = l;      //左边数据的起始下标    
	int rk = mid + 1;//右边数据的起始下标
	for (size_t i = l; i <= r; i++)//这里是代码的核心，参考笔记理解起来很容易。
	{
		if (lk>mid)//左边已经排序完毕的情况下，直接将右边的数据加入进去
		{
			vec[i] = temp[rk - l];
			rk++;
		} 
		else if (rk>r)//右边已经排序完毕的情况下，直接将右边的数据加入进去
		{
			vec[i] = temp[lk - l];
			lk++;
		}
		else if (temp[lk-l]<temp[rk-l])//比较copy过来的vec，对比左右两边的数据大小；这里是左大于右。
		{
			vec[i] = temp[lk - l];
			lk++;
		}
		else
		{
			vec[i] = temp[rk - l];
			rk++;
		}
	}
}

下面是resolve函数的详细解释
采用的是5个数据的例子，更多数据以此类推即可



总的来说，明白一条路走到底再回来就差不多懂递归了（大佬原话）