算法学习之合并排序算法

合并排序算法，总共分三步：

1、分解：分解数据串，将数据串分解成若干个小型的数据串，最小单位为每个数据串中只有1个数据；

2、解决：也就是比较数据大小；

3、合并：将已经排序好的若干个小型数据串合并为最终数据串；

例如排序如下数据串【1 3 6 2 4 8 5 3 9 8 7 10】：

1、分解数据串，将分解为最小单元：

[1] [3] [6] [2] [4] [8] [5] [3] [9] [8] [7] [10]

2、解决并且合并：

[1 3]  [2 6]  [4 8]  [3 5]  [8 9]  [7 10]

3、继续解决并且合并数据串：[1 2 3 6]   [3 4 5 8]   [7 8 9 10]

4、继续：[1 2 3 6] 和 [3 4 5 7 8 8 910]

5、最后一步了，吼吼：[1 2 3 3 4 5 6 7 8 8 9 10]

合并排序算法，需要我们一直分割数据串，所以需要用递归。那么问题就来了，使用递归的时候，什么时候停止递归就是比较重要的了。当将数据串分割到只有一个单元，即：_beginIndex >= _endIndex时，Stop!

代码如下，欢迎请教：

<span style="font-family:SimHei;font-size:18px;">/*
*@ filename : merge-sort.cpp
*@ time : 2015 - 01 - 16
*
*/

#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TEST

void merge_insert(int *pArr, int _begin, int _middle, int _end)
{
	if (pArr == NULL)
		return;

	int LArrLength = _middle - _begin + 1;
	int RArrLength = _end - _middle;
	int AllArrLength = _end - _begin + 1;
	
	printf("LArrLength = %d, RArrLength = %d, AllArrLength = %d.\n", LArrLength, RArrLength, AllArrLength);

	if (LArrLength <= 0 || RArrLength <= 0)
		return;

	int *pLArr = new int[LArrLength];
	int *pRArr = new int[RArrLength];

	if (pLArr == NULL || pRArr == NULL)
		return;

	//copy from pArr
	for (int i = 0; i != LArrLength; i++)
	{
		pLArr[i] = *(pArr + _begin - 1 + i);
	}

	for (int j = 0; j != RArrLength; j++)
	{
		pRArr[j] = *(pArr + _middle + j);
	}

	//Test
#ifdef TEST
	for (int i = 0; i != LArrLength; i++)
	{
		printf("%d\t", pLArr[i]);
	}

	printf("\n");

	for (int j = 0; j != RArrLength; j++)
	{
		printf("%d\t", pRArr[j]);
	}
	printf("\n");
#endif
	//sort pLArr and pRArr

	int LIndex = 0; 
	int RIndex = 0;
	int index = 0;
	
	while (LIndex < LArrLength && RIndex < RArrLength && index < AllArrLength)
	{
		if (pLArr[LIndex] < pRArr[RIndex])
		{
			*(pArr + _begin - 1 + index) = pLArr[LIndex];
			LIndex++;
			index ++;
		}
		else if (pLArr[LIndex] >= pRArr[RIndex])
		{
			*(pArr + _begin - 1+ index) = pRArr[RIndex];
			RIndex++;
			index ++;
		}
	}
	
	if (index < AllArrLength)
	{
		while (LIndex < LArrLength)
		{
			*(pArr + _begin - 1 + index) =  pLArr[LIndex];
			LIndex++;
			index ++;
		}
		while(RIndex < RArrLength)
		{
			*(pArr + _begin  - 1+ index) = pRArr[RIndex];
			RIndex++;
			index ++;
		}
	}
	
	delete [] pLArr;
	delete [] pRArr;
	return;
}

void merge_sort(int *_pArr, int _begin, int _end)
{
	if (_begin < _end)
	{
		int middle = (_begin + _end) / 2;
		merge_sort(_pArr, _begin, middle);
		merge_sort(_pArr, middle + 1, _end);
		merge_insert(_pArr, _begin, middle, _end);
	}
}


int _tmain(int argc, _TCHAR* argv[])
{	
	int arr[] = {1, 3, 2, 6, 1, 2, 5, 3, 7, 8, 7};

	merge_sort(arr, 1,  sizeof(arr)/4);

#ifdef TEST
	for (int i = 0; i != sizeof(arr) / 4; i++)
	{
		printf("%d\t", arr[i]);
	}
	printf("\n");
#endif
	return 0;
}
</span>