排序 | 归并排序(递归和迭代)

利用分治的思想,将问题不断地划分为相同但是规模更小的问题,利用相同的解法解小问题,最终大问题得以解决

一一合并完之后每一个元素个数为2的数组有序,然后两个两个的合并,四个四个的合并…直到最大容量,排序完成

递归版

void copy(int* src, int* dest, int left, int right)
{
	for (left; left <= right; ++left)
	{
		dest[left] = src[left];
	}
}

void merge(int* src, int* dest,int left, int mid, int right)
{
	int i = left; int j = mid+1;
	while (left <= mid && j <= right)
	{
		if (src[left] >= src[j]) dest[i++] = src[j++];
		else if (src[left] < src[j]) dest[i++] = src[left++];
	}
	while (left <= mid)
	{
		dest[i++] = src[left++];
	}
	while (j <= right)
	{
		dest[i++] = src[j++];
	}
}


void mergepass(int* src,int* dest, int left, int right)
{
	if (right > left)
	{
		int mid = (left + right) / 2;
		mergepass(src, dest,left, mid);
		mergepass(src, dest,mid + 1, right);
		merge(src,dest, left, mid, right);
		copy(dest, src, left, right);
	}
}

void mergesort(int* ar, int size)
{
	int* tmp = new int[size];
	mergepass(ar, tmp, 0, size - 1);
	delete[] tmp;
}

迭代版

void merge(int* ar, int* br, int left, int mid, int right)
{
	int i = left;
	int m = mid;
	while (left < mid && m <= right)
	{
		if (ar[left] >= ar[m])
		{
			br[i++] = ar[m++];
		}
		else
		{
			br[i++] = ar[left++];
		}
	}

	while (left < mid)
	{
		br[i++] = ar[left++];
	}
	while (m <= right)
	{
		br[i++] = ar[m++];
	}
}

void mergepass(int* ar,int *br, int gap,int size)
{
	int i = 0;
	for (i = 0; i + 2 * gap <= size; i += 2 * gap)
	{
		merge(ar, br, i, i + gap, i + 2 * gap - 1);
	}
	if (i + gap < size)
	{
		merge(ar, br, i, i + gap, size - 1);
	}
	else
	{
		while (i < size)
		{
			br[i] = ar[i];
			i += 1;
		}
	}
}



void mergesort(int* ar, int size)
{
	int* br = new int[size];
	for (int i = 1; i <= size; i += i)
	{
		mergepass(ar,br, i,size);
		i += i;
		mergepass(br, ar, i, size);
	}
	delete[] br;
}

迭代版的思路就是控制每次合并的个数,从1开始,进行大小为1的两个数组的合并,大小为1的合并完之后,数组元素两个为一组有序,然后两个两个合并,4有序,不断循环下去,直到大小为size有序.