各种排序算法分析比较

先研究典型的吧，归并与快排。

遇到一个问题，要求利用常数阶的空间、在时间复杂度为O(NLogN)的情况下为一个单链表排序。

回忆：时间复杂度为O(NLogN)的排序算法有：快速排序、归并排序、堆排序，它们的空间复杂度O(1) 、O(N) 、O(N) 。（快排不稳定，归并稳定，堆排序不稳定）

            其中快排最坏的情况下，时间复杂度为O(N^2)，显然某些测试用例下不满足O(NLogN)。而考虑归并排序，空间复杂度之所以不满足，在在数组的合并排序操作，需要额外的O(N)辅助空间；但是若是在单链表中进行两个有序数列的合并，并不需要额外的空间，使用指针操作即可。因此，这里选择归并比较合适。对排序空间复杂度不满足。

==============================================================================================================================

分治法：将规模较大的问题，分解为若干个与原问题性质相同的子问题；求解子问题；并将子问题的解合并，得到最后的解。

由此可见分治法的一般步骤：分解、求解、合并。由于子问题与原问题性质相同，采用递归是较为简单的方法。

==============================================================================================================================

归并排序

模板预览：
void DaC(int *a, int p, int q) {
if(p == q) return;//最小有序序列
m = divide(p, q);//分解问题
DaC(a, p, m);
DaC(a, m + 1, q);
merge(vt, p, m, q);//合并
}

解释：将数组A[p, q]平分问两部分A[p, m]  A[m+1, q]， 分别求解这两个子数组使它们们有序，最后将它们合并成有序序列。

            其中两个子数组序列会被分为更小的子序列，直到只剩下一个数据，代表排成了有序序列。

代码：

class Solution{
public:
	void MergeSort(vector<int> &vt){
		sort(vt, 0, vt.size() - 1);
	}


	void sort(vector<int> &vt, int p, int q) {
		if(q == p) return;

		int m = (p + q) / 2;//divide(p, q);
		sort(vt, p, m);
		sort(vt, m + 1, q);
		merge(vt, p, m, q);
	}


	void merge(vector<int> &vt, int p, int m, int q) {

		vector<int> vtmp(q-p+1, 0);

		int i = p;
		int j = m + 1;

		int n = 0;
		while(i <= m && j <= q) {
			if(vt[i] <= vt[j]) { 
				vtmp[n++] = vt[i++];
			} else {
				vtmp[n++] = vt[j++];
			}
		}
		while(i <= m) {
			vtmp[n++] = vt[i++];
		}
		
		while(j <= q) {
			vtmp[n++] = vt[j++];
		}
		for(n = 0; n < q-p+1; n++) {
			vt[n + p] = vtmp[n];
		}
	}

	void swap(int &a, int &b) {
		int tmp;
		tmp = a;
		a = b;
		b = tmp;
	}
};