归并排序，是分治法的一个重要例子。分治法可以分为三个步骤：

1. 分解，将原问题分解为更小的子问题
2. 解决，解决划分的子问题
3. 合并，将子问题的解合并成原问题的解
归并排序是最快的一类排序算法，其时间复杂度为 O(nlgn), 可以通过主方法或者递归数法来证明，主方法我们将会在后面的博客中说到

#include<iostream>  
using namespace std;

void merge(int *arr, int left, int mid, int right)
{
	int i, j,k;
	int numL = mid - left + 1;
	int numR = right - mid;
	int *arrL = new int[numL+1];
	int *arrR = new int[numR+1];
	for (i = 0; i < numL; i++)  //将数组左边的数复制到arrL中
	{
		arrL[i] = arr[left+i];
		//cout << arrL[i];
	}
	arrL[i] = 1000000000;     //放置一个极大的数，用来作哨兵牌
	for (j = 0; j < numR; j++)  //将数组右边的数复制到arrR中
	{
		arrR[j] = arr[mid +1+ j];
		//cout << arrR[j];
	}
	arrR[j] = 1000000000;
	i = j = 0;
	for ( k = left;k<=right;k++)  //将数组arr从小到大排序
	{
		if (arrL[i] <= arrR[j])  //如果arrL[i]小于等于arrR[j]
		{
			arr[k] = arrL[i];
			i++;
		}
		else
		{
			arr[k] = arrR[j];
			j++;
		}
	}
}

void mergeSort(int *arr, int left, int right)
{
	int mid;
	if (left < right)
	{
		mid = (left + right) / 2;  //获取中间数
		mergeSort(arr, left, mid);  //分解数组左边
		mergeSort(arr,mid+1,right);  //分解数组右边
		merge(arr, left, mid, right);  //合并
	}
}

int main()
{
	int arr[8] = {2,4,5,7,1,2,3,6};
	mergeSort(arr, 0, 7);
	//merge(arr,0,3,7);
	for (int i = 0; i < 8; i++)
		cout << arr[i];
	cout << endl;
}

　　

  1. using namespace std;  
  2.   
  3. void merge(int *arr, int left, int mid, int right)  
  4. {  
  5.     int i, j,k;  
  6.     int numL = mid – left + 1;  
  7.     int numR = right – mid;  
  8.     int *arrL = new int[numL+1];  
  9.     int *arrR = new int[numR+1];  
  10.     for (i = 0; i < numL; i++)  //将数组左边的数复制到arrL中  
  11.     {  
  12.         arrL[i] = arr[left+i];  
  13.         //cout << arrL[i];  
  14.     }  
  15.     arrL[i] = 1000000000;     //放置一个极大的数，用来作哨兵牌  
  16.     for (j = 0; j < numR; j++)  //将数组右边的数复制到arrR中  
  17.     {  
  18.         arrR[j] = arr[mid +1+ j];  
  19.         //cout << arrR[j];  
  20.     }  
  21.     arrR[j] = 1000000000;  
  22.     i = j = 0;  
  23.     for ( k = left;k<=right;k++)  //将数组arr从小到大排序  
  24.     {  
  25.         if (arrL[i] <= arrR[j])  //如果arrL[i]小于等于arrR[j]  
  26.         {  
  27.             arr[k] = arrL[i];  
  28.             i++;  
  29.         }  
  30.         else  
  31.         {  
  32.             arr[k] = arrR[j];  
  33.             j++;  
  34.         }  
  35.     }  
  36. }  
  37.   
  38. void mergeSort(int *arr, int left, int right)  
  39. {  
  40.     int mid;  
  41.     if (left < right)  
  42.     {  
  43.         mid = (left + right) / 2;  //获取中间数  
  44.         mergeSort(arr, left, mid);  //分解数组左边  
  45.         mergeSort(arr,mid+1,right);  //分解数组右边  
  46.         merge(arr, left, mid, right);  //合并  
  47.     }  
  48. }  
  49.   
  50. int main()  
  51. {  
  52.     int arr[8] = {2,4,5,7,1,2,3,6};  
  53.     mergeSort(arr, 0, 7);  
  54.     //merge(arr,0,3,7);  
  55.     for (int i = 0; i < 8; i++)  
  56.         cout << arr[i];  
  57.     cout << endl;  
  58. }  

版权声明：本文为Lxiaoyouling原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Lxiaoyouling/p/8617551.html