Many online merging and sorting articles focus on the principle of merging and sorting, but they don't pay much attention to the code implementation, so let's take a look at the code implementation of merging algorithm in this chapter.

principle

To learn an algorithm, you must first learn its principle~

Merge sort, using the idea of divide and conquer, first divide the array into half groups until there is only one element in each group, then sort and merge the array, and finally turn it into a completely ordered array.

In the last animation demonstration, the dynamic diagram of the up main of "five minute learning algorithm" is quoted here. I think it's good

Although the animation demonstration is grouped at the same time, when you debug the code, you will find that it is divided into one side first and then the other side

There is also a picture that I think is quite good, which well reflects the idea of divide and conquer.

code implementation

Let's first look at the implementation of the merge section

void merge(int low,int mid,int high)
{
	int left = low;	//Array pointer in the left part
	int right = mid + 1;	//Right part pointer
	int k = low;	//Pointer to the temp array

	while (left < mid + 1 && right < high + 1) {  /*This while is used to combine two arrays into a new one			 				
													Array, which is temporarily stored in temp []*/
		if (nums[left] > nums[right]) {
			temp[k++] = nums[right++];	//k + + and right + + here mean to assign values first and then add 1
		}								//It's equivalent to the following else
		else {
			temp[k] = nums[left];
			k++;
			left++;
		}
	}

	//Check whether the left sequence is empty
	while (left < mid + 1) {		/*These two while are used to store the values of one array and leave the other array											
										The elements are stored in sequence*/
		temp[k++] = nums[left++];
	}

	//Check whether the sequence on the right is empty
	while (right < high + 1) {
		temp[k++] = nums[right++];
	}

	//Move back to the original array. num[i] is the array defined in the global area to be sorted
	for (int i = low; i <= high; i++) {	//i=low here. It can't be equal to 0
		nums[i] = temp[i];
	}
}

Code implementation of the mergeSort part

void mergeSort(int low,int high)	//Use recursion
{
	if(low >= high) {	//It is equivalent to a group of single elements. Just return it directly
		return;
	}
	int mid = low + ((high - low) >> 1);/*Prevent low and high from crossing the boundary. 1 is the same as dividing by 2, but	
											Faster than / 1 efficiency*/
	//branch
	mergeSort(low, mid);	//First on the left
	mergeSort(mid + 1, high);	//Finish left and right

	//cure
	merge(low, mid, high);	//Merge layer by layer, and small arrays are gradually merged into large arrays
}

Finally, let's take a look at the complete specific code

#include <iostream>
using namespace std;

int nums[7] = { 7,3,5,2,9,8 };//Array to be sorted
int temp[7];//Temporary storage array

void merge(int low,int mid,int high)
{
	int left = low;	//Array pointer in the left part
	int right = mid + 1;	//Right part pointer
	int k = low;	//Pointer to the temp array

	while (left < mid + 1 && right < high + 1) {
		if (nums[left] > nums[right]) {
			temp[k++] = nums[right++];
		}
		else {
			temp[k] = nums[left];
			k++;
			left++;
		}
	}

	//Check whether the left sequence is empty
	while (left < mid + 1) {
		temp[k++] = nums[left++];
	}

	//Check whether the sequence on the right is empty
	while (right < high + 1) {
		temp[k++] = nums[right++];
	}

	//Move back to the original array
	for (int i = low; i <= high; i++) {	//i=low here. It can't be equal to 0
		nums[i] = temp[i];
	}
}

void mergeSort(int low,int high)
{
	if(low >= high) {
		return;
	}
	int mid = low + ((high - low) >> 1);//To prevent low and high from crossing the boundary, 1 is the same as dividing by 2, but it is faster than / 2
	//branch
	mergeSort(low, mid);
	mergeSort(mid + 1, high);

	//cure
	merge(low, mid, high);
}

int main()
{
	mergeSort(0, 5);
	for (int i = 0; i <=5; i++) {
		cout << nums[i] << " ";
	}
	cout << endl;
	return 0;
}

It is better to debug the code and see the change of variable value, which will make the implementation of merging algorithm more clear.

Complexity analysis

• Time complexity:
  
  From this recursive tree, we can see that the time cost of the first layer is cn, the time cost of the second layer is cn/2+cn/2=cn... The cost of each layer is cn, and there are a total of logn+1 layers, so the total time cost is cn*(logn+1). The time complexity is O(nlogn)

• Space complexity: the merge sort algorithm requires an additional sequence temp [] to store the sorted results. The space occupied is n, so the space complexity is O(n)

• Stability: in the worst, best and average cases, the time complexity of merging and sorting is O(nlogn). It can be seen from the merging process that the merging and sorting is stable.

Summary:

Merge sort algorithm is efficient, because its time complexity is only O(nlogn), so when there is a large amount of data, merge sort is a good choice. For C friends who don't know much about the divide and conquer idea in the algorithm, you can check the concept first, and then understand the code implementation with the help of debugging.