Double recursion in deep analysis merge sort

This article is the author's reading notes , Please do not reprint without permission . If it helps you, remember to praise it (●’◡’●)
This paper mainly shows the abstract details of double recursion in the form of graph .
Source code is as follows ：

main.cpp

// 1 Sort .cpp :  Defines the entry point for the console application .
#include "stdafx.h"
void random(vector<int>& vec)// Random number generator 
{
    
	random_device r;
	for (auto& e : vec)
	{
    
		e = r() % vec.size() + 1;
	}
}

void out(const vector<int>& vec)// Output function 
{
    
	for (const auto& e : vec)
	{
    
		cout << e << " ";
	}
	cout << endl;
}

void sortTest(function<void(vector<int>&)> sortFn)// Test functions 
{
    
	vector<int> vec(100);
	random(vec);
	out(vec);
	auto start = clock();// Test time 
	sortFn(vec);
	auto end = clock();
	out(vec);
	auto diff = (float)(end - start) / 1000;
	cout << diff << endl;
}

int _tmain(int argc, _TCHAR* argv[])// The main function , Precompiled headers are used （ Personal habits ）
{
    
	sortTest(sort::mergeSort);
	system("pause");
	return 0;
}
// Results show 
//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;// Avoid arithmetic overflow 
	reSolve(vec, l, mid);	  // Split the data on the left 
	reSolve(vec, mid + 1, r); // Split the data on the right 
	merge(vec, l, mid, r);    // Merge 
}

void sort::merge(vector<int>& vec,int l,int mid,int r)
{
    
	// Create a temporary vector
	vector<int> temp(vec.begin() + l, vec.begin() + r + 1); // Pay attention to distinguish between L and 1
	int lk = l;      // The starting subscript of the data on the left  
	int rk = mid + 1;// The starting subscript of the data on the right 
	for (size_t i = l; i <= r; i++)// Here is the core of the code , Reference notes are easy to understand .
	{
    
		if (lk>mid)// When the left has been sorted , Directly add the data on the right 
		{
    
			vec[i] = temp[rk - l];
			rk++;
		} 
		else if (rk>r)// When the right has been sorted , Directly add the data on the right 
		{
    
			vec[i] = temp[lk - l];
			lk++;
		}
		else if (temp[lk-l]<temp[rk-l])// Compare copy Over here vec, Compare the data size of the left and right sides ; Here the left is greater than the right .
		{
    
			vec[i] = temp[lk - l];
			lk++;
		}
		else
		{
    
			vec[i] = temp[rk - l];
			rk++;
		}
	}
}

Here is resolve Detailed explanation of function
It's using 5 Examples of data , More data and so on



in general , Understand a path to the end and come back to almost understand recursion （ Big brother's original words ）