算法-分治法（C++)

一. 分治法

1. 归并排序

分而治之——分

void mergeSort(int x[], int l, int r)
{
	if (l < r)
	{
		int mid = (l + r) / 2;
		mergeSort(x, l, mid);
		mergeSort(x, mid + 1, r);
		merge(x, l, mid, r);
	}
}

 分而治之——治

以最后一步为对象，思考“治”的算法

//可以先将正确顺序存于Temp数组，最后再更新原数组
void SortClass::merge(vector<int>& a, int L, int M, int R)
{
	vector<int> temp(R - L + 1);
	int i = 0;
	int p1 = L;
	int p2 = M + 1;
	while (p1 <= M && p2 <= R)
	{
		temp[i++] = a[p1] < a[p2] ? a[p1++] : a[p2++];
	}
	while (p1 <= M)
	{
		temp[i++] = a[p1++];
	}
	while (p2 <= R)
	{
		temp[i++] = a[p2++];
	}
	for (unsigned int i = 0; i < temp.size(); i++)
	{
		a[L + i] = temp[i];
	}
}
//----------------------------------------------------------//

//也可以将L R部分先拷贝出来，再直接按正确顺序写回原数组
    //分三部分处理
void merge(int x[], int l, int mid, int r)
{
	int L[50]{}, R[50]{};
	for (int i = 0; i < mid - l + 1; i++)
	{
		L[i] = x[l + i];
	}
	for (int j = 0; j < r - mid; j++)
	{
		R[j] = x[mid + 1 + j];
	}
	int i = 0, j = 0, k = 0;
	while (i < mid - l + 1 && j < r - mid)
	{
		x[l + k++] = L[i] < R[j] ? L[i++] : R[j++];
	}
	while (i < mid - l + 1)
	{
		x[l + k++] = L[i++];
	}
	while (j < r - mid)
	{
		x[l + k++] = R[j++];
	}
}

    //也可直接一步到底
void merge(int x[], int l, int mid, int r)
{
	int L[50]{}, R[50]{};
	for (int i = 0; i < mid - l + 1; i++)
	{
		L[i] = x[l + i];
	}
	for (int j = 0; j < r - mid; j++)
	{
		R[j] = x[mid + 1 + j];
	}
	L[mid - l + 1] = INT_MAX;//从小到大排则将其有效部分的下一位置为最大
	R[r - mid] = INT_MAX;
	int i = 0, j = 0;
	for (int k = l; k < r + 1; k++)
	{
		x[k] = L[i] < R[j] ? L[i++] : R[j++];
	}
}

最后算法整体为

void merge(int x[], int l, int mid, int r)
{
	int L[50]{}, R[50]{};
	for (int i = 0; i < mid - l + 1; i++)
	{
		L[i] = x[l + i];
	}
	for (int j = 0; j < r - mid; j++)
	{
		R[j] = x[mid + 1 + j];
	}
	L[mid - l + 1] = INT_MAX;//从小到大排
	R[r - mid] = INT_MAX;
	int i = 0, j = 0;
	for (int k = l; k < r + 1; k++)
	{
		x[k] = L[i] < R[j] ? L[i++] : R[j++];//从小到大排
	}
}
void mergeSort(int x[], int l, int r)
{
	if (l < r)
	{
		int mid = (l + r) / 2;
		mergeSort(x, l, mid);
		mergeSort(x, mid + 1, r);
		merge(x, l, mid, r);
	}
}

另外：

时间复杂度：
归并排序把集合进行层层拆半分组。如果集合长度为n，那么拆半的层数就是logn，每一层进行归并操作的运算量是n。所以，归并排序的时间复杂度等于每一层的运算量×层级数，即O(nlogn)。

空间复杂度：
归并排序是需要用到额外空间的，但是每次归并所创建的额外空间都会随着方法结束而释放，因此单次归并操作开辟的最大空间是n。所以，归并排序的空间复杂度是O(n)。

算法稳定性：
归并排序是稳定的排序算法。temp[len++]=arr[i_start]<arr[j_start]?arr[i_start++]:arr[j_start++];，这行代码可以保证当左右两部分的值相等的时候，先复制左边的值，这样可以保证值相等的时候两个元素的相对位置不变。

2. 最大子段和

给定n个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时定义子段和为0，依此定义，所求的最优值为： Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n 例如，当（a[1],a[2],a[3],a[4],a[5],a[6]）=(-20,11,-4,13,-5,-2)时，最大子段和为20。

暴力解法：双重循环

int maxSum2(int x[], int l, int r)
{
	int tempMax, maxNum = 0, temp;
	for (int i = l; i <= r; i++)
	{
		temp = 0;
		tempMax = 0;
		for (int j = i; j < r; j++)
		{
			temp += x[j];
			tempMax = max(tempMax, temp);
		}
		maxNum = max(maxNum, tempMax);
	}
	return maxNum;
}

如果将所给的序列a[1:n]分为长度相等的两段a[1:n/2]和a[n/2+1:n],分别求出这两段的最大子段和，则a[1:n]的最大子段和有三种情况：

（1） a[1:n]的最大子段和与a[1:n/2]的最大子段和相同

（2） a[1:n]的最大子段和与a[n/2+1:n]的最大子段和相同

（3） a[1:n]的最大子段和为a[i]+…+a[j]，并且1<=i<=n/2，n/2+1<=j<=n。

对于（1）和（2）两种情况可递归求得，但是对于情况（3），容易看出a[n/2]，a[n/2+1]在最大子段中。因此，我们可以在a[1:n/2]中计算出s1=max(a[n/2]+a[n/2-1]+…+a[i]),0<=i<=n/2，并在a[n/2+1:n]中计算出s2= max(a[n/2+1]+a[n/2+2]+…+a[i])，n/2+1<=i<=n。则s1+s2为出现情况（3）的最大子段和。

 分治法

int maxLR(int x[], int l, int r)
{
	int mid = (l + r) / 2;
	int sumL = 0, sumR = 0, maxL = 0, maxR = 0;
	for (int i = mid; i >= l; i--)
	{
		sumL += x[i];
		maxL = max(sumL, maxL);
	}
	for (int i = mid + 1; i <= r; i++)
	{
		sumR += x[i];
		maxR = max(sumR, maxR);
	}
	return maxL + maxR;
}
int maxSum(int x[], int l, int r)
{
	if (l == r) return x[l] >= 0 ? x[l] : 0;
	int mid = (l + r) / 2;
	int L = maxSum(x, l, mid);
	int R = maxSum(x, mid + 1, r);
	int LR = maxLR(x, l, r);
	int max = L > R ? L : R;
	return max = LR > max ? LR : max;
}