算法设计 分治， 归并排序， 快速排序

算法思想：

分治方法与软件设计的模块化方法非常的相似。要解决一个大实例问题，可以（1）将它分解成多个更小的实例，（2）分别解决每个小实例，（3）将小实例的解组合成大实例的解。

例子：

寻找假硬币。一个袋子有16枚硬币，其中可能有一个假币，并且假币比真币要轻，现在要找出这个假币。

现在要找出假硬币，我们把两个或者三个硬币视为不可再分的小实例，只有一个硬币时，不能确定它的真假。

2. 金块问题：

从袋子中寻找出最重的和最轻的金块：希望用最少的比较次数找出最重和最轻的金块；

方法1： 使用max()函数经过n-1次比较，得到重量最大的，再通过n-2次比较得到重量最小的。共需要2n-3次比较

方法2：采用分治的方法：当金块的个数n较大的时候

第一步： 把金块先分成两部分A，B

第二步： 分别找出A，B中的最轻的和最重的金块， L_A,H_A, L_B,H_B

第三步： 比较L_A,L_B, 比较H_A,H_B

现在假设金块的数量n=8,整个比较的过程可以用下面的二叉树来描述:

图中的每个大写字母代表的节点表示一个实例，实例中的金块的个数等于以该节点为根的子树的所有叶子。

1. 沿着根至叶子的路径，把一个大实例划分成若干个大小为1或者2的实例

2. 在每一个大小为2的实例中，比较确定哪一个较轻，哪一个较重（节点DEFG中），大小为1的实例既是最轻的，也是最重的

3. 对较轻的金块比较哪一块是最轻的，对较重的金块比较哪一块是最重的（节点ABC）

找出最大值和最小值的分治非递归算法：

template<typename T>
bool minmax(T a[], int n, int& minIndex, int& maxIndex)
{
	// 元素个数
	if(n<1)
	{
		return false;
	} 
	if(n==1)
	{
		minIndex = 1;
		maxIndex = 1;
		return true;
	}
	
	// n>1的情况
	int s = 1;  // 比较的起点 
	if(n%2==1)   // n奇数
	{
		minIndex = 0;      // 这样是为了使得剩余的节点个数为偶数个 
		maxIndex = 0; 
	} 
	else
	{
		if(a[0]>a[1])
		{
			maxIndex = 0;
			minIndex = 1;
		}
		else
		{
			maxIndex = 1;
			minIndex = 0;
		}
		s = 2;    // 比较的起点 
	}
	
	// 比较剩余的元素    偶数和元素，每两个元素作为一个实例 
	for(int i=s; i<n; i+=2)
	{
		if(a[i]>a[i+1])
		{
			if(a[i]>a[maxIndex])
			{
				maxIndex = i;
			} 
			if(a[i+1]<minIndex)
			{
				minIndex = i+1;
			}
		}
		else
		{
			if(a[i]<a[minIndex])
			{
				minIndex = i;
			}
			if(a[i+1]>a[maxIndex])
			{
				maxIndex = i+1;
			}
		}
	}
	return true;
}

在算法开始的时候首先处理n=1和n<1的情况：

1. 当n为偶数的时候，先比较数组的前两个元素，作为最大最小元素的候选者，剩余的元素个数为偶数，再进行比较。

2. 当n为奇数的时候，将数组的第0个元素作为候选的元素，剩余的元素个数也为偶数

3. 接下来比较剩余的偶数个元素

复杂度分析：

当n为偶数的时候，在for循环的外部，有一次比较，内部有(n/2-1)*3此比较

当n为奇数的时候，在for循环的外部没有比较，内部有(n-1)/2*3次比较

所以总的比较次数为： 【3n/2】-2次比较，这是在寻找最大最小值的算法中比较次数最小的算法

归并排序：

可以使用分治的方法设计排序算法，这种方法的思路是将序列划分为k个子序列(k>=2), 先对每一个子序列排序，然后将有序子序列归并为一个序列。

假设A组包含n/k个元素，B组包含其余的元素，递归的应用分治对A，B两个序列进行排序，然后采用归并的过程，将有序子序列归并为一个序列。

在k=2时的排序称为归并排序，更准确的说，是二路归并排序。

例如： 对于序列：【10， 4，6， 3， 8，2，5，7】，选定k=2, 则子序列[10,4,6,3]和[8.2.5.7]需要分别独立排序，得到两个有序的子序列，在将这两个有序的子序列进行合并。

伪代码如下所示：

void sort(E, n)   // 对E中k个元素进行排序
{
    if(n>=k)
    {
       i=n/k;    // A的元素个数
       j = n-i;  // B的元素个数
       sort(A, i);
       sort(B, j);
       merge(A,B,E,i,j);   // 把AB合并到E中
    }
    else
    {
        对E进行插入排序
    }
}

归并n个元素所需的时间为O(n),假设t(n)为分治排序算法在最坏情况下的用时，则其递推公式为：

当两个小的实例所包含的元素个数近似相等时，分治算法通常具有最佳的性能。

在上面的递推公式中，取k=2, 且假设n为2的幂：

则递推公式可以简化为：

在n位其他数的时候，这个结论也适用：可以得到

这也是归并排序在最好和最坏情况下的时间复杂度；

归并排序的C++实现:

1. 一种方法可以将排序的元素存储到一个链表中，在n/2处将链表断开，分成两个大致相等的子链表。然后再将两个排序后的子链表归并到一起。

2. 使用数组存储元素

归并排序的非递归写法：

#include <iostream>

using namespace std;

// 归并排序：
/*
原理： 
初始段： [8] [4] [5] [6] [2] [1] [7] [3]
归并到b  [4,  8] [5,  6] [1,  2] [3,  7] 
复制到a  [4,  8] [5,  6] [1,  2] [3,  7]
归并到b  [4   5   5   8] [1   2   3   7]
复制带a  [4   5   5   8] [1   2   3   7]
归并到b  [1   2   4   5   6   7   7   8]
复制到a  [1   2   4   5   6   7   7   8]
*/ 
template<typename T>
void merge(T c[], T d[], int startOfFirst, int endOfFirst, int endOfSecond)
{
	// 数据段a,b
	int first = startOfFirst;
	int second = endOfFirst+1;
	int res = startOfFirst; 
	// 开始归并数据段
	// 反复将c归并到d中，再将d归并到a中 
	while(first<=endOfFirst && second<=endOfSecond)
	{
		if(c[first]<=c[second])
		{
			d[res++] = c[first++];
		}
		else
		{
			d[res++] = c[second++];
		}	
	}
	
	// 归并剩余的字段
	if(first>endOfFirst)     // 此时first段已经完全归并了，则考虑归并second,如果second有剩余的话
	{
		for(int i=second; i<=endOfSecond; i++)
		{
			d[res++] = c[i];
		}
	}
	else     // 相反
	{
		for(int i=first; i<=endOfFirst; i++)
		{
			d[res++] = c[i];
		}
	}
	 
}




template<typename T>
void mergePass(T x[], T y[], int n, int segment)
{
	// 从x到y归并相邻的数据段
	int i=0;   // 数据段起始位置
	while(i<=n-2*segment)
	{
		merge(x, y, i, i+segment-1, i+2*segment-1);    // x, y 数据段1 ：i起始位置, i+segment截至位置； 数据段2；结束位置： i+2*segment-1 
		i = i+2*segment;
	} 
	
	// 少于两个满数据段 
	if(i+segment<n)   // 少于两个数据段没有合并
	{
		merge(x, y, i, i+segment-1, n-1);    // n-1是最后一个元素的位置 
	} 
	else  // 只剩一个数据段 
	{
		for(int j=i; j<n; j++)
		{
			y[j] = x[j];
		}
	} 
}

template<typename T>
void mergeSort(T a[], int n)
{
	T* b = new T[n];
	int segmentSize = 1;
	while(segmentSize<n)
	{
		mergePass(a, b, n, segmentSize);   
		segmentSize += segmentSize;
		mergePass(b, a, n, segmentSize);
		segmentSize += segmentSize;
	}
	delete []b;
} 



int main(int argc, char *argv[])
{
	int array[] = {8,4,5,6,2,1,7,3};
	mergeSort(array, 8);
	for(int i=0; i<8; i++)
	{
		cout << array[i] << " ";
	}
	cout << endl;
	return 0;
}

快速排序：

用分治可以实现另一种排序方法，快速排序。把n个元素分为三段，left, middle, right,其中middle段仅有一个元素，left段中的元素都不大于中间段的元素，right段的元素都不小于middle段的元素。middle的元素称为支点。

算法思路：

1，从a[0:n-1]之间选择一个元素作为middle段

2. 把生于元素分成left和right两部分，是左段的元素都不大于middle，右段的元素都不小于middle。

3. 对left段递归快速排序

4. 对right段递归快速排序

C++实现：

#include <iostream>

using namespace std;

template<typename T>
void quickSort(T a[], int n)
{
	// a[]排序数组   n 元素个数
	if(n<=1)
	{
		return;
	} 
	// 找到最大的元素， 将其放到数组最右端
	int index = 0;
	for(int i=1; i<n; i++)
	{
		if(a[i]>a[index])
		{
			index = i;
		}
	} 
	T temp = a[index];
	a[index] = a[n-1];
	a[n-1] = temp;
	quickSort(a, 0, n-2);   // 调用递归函数quickSort 
}

template<typename T>
void quickSort(T a[], int leftend, int rightend)
{
	// a[leftend:rightend]排序
	if(leftend>=rightend)
	{
		return;
	} 
	int leftCursor = leftend;   // 从左到右移动搜索 
	int rightCursor = rightend+1;    // 从右到左移动搜索
	T pivot = a[leftend];     // 选择支点 
	while(1)
	{
		do     // 寻找左侧不小于支点的元素 
		{
			leftCursor++;
		} while(a[leftCursor]<pivot);
		
		do    // 寻找优策不大于支点的元素 
		{
			rightCursor--;
		} while(a[rightCursor]>pivot);
		
		if(leftCursor>=rightCursor)
		{
			break;
		}
		T temp = a[leftCursor];
		a[leftCursor] = a[rightCursor];
		a[rightCursor] = temp; 
	}
	
	// 放置支点
	a[leftend] = a[rightCursor];
	a[rightCursor] = pivot; 
	// 递归调用quickSort() 
	quickSort(a, leftend, rightCursor-1);
	quickSort(a, rightCursor+1, rightend);
} 


int main(int argc, char *argv[])
{
	int array[] = {8,4,5,6,2,1,7,3};
	quickSort(array, 8);
	for(int i=0; i<8; i++)
	{
		cout << array[i] << " ";
	}
	cout << endl;
	return 0;
}

复杂度分析：
快速排序的平均复杂度是，其中n为元素的个数

各种排序算法的时间复杂度对比：

排序算法	最坏情况下性能	最好情况下性能
冒泡排序
计数排序
插入排序
选择排序
堆排序
归并排序
快速排序

性能测量：

上图生成的曲线：