南京邮电大学算法分析与设计实验一（分治法）

1 相关简介

分治法是一种算法设计策略，它将一个复杂的问题分解成若干个较小的子问题，独立求解这些子问题，然后将它们的解合并以得到原问题的解。这种方法可以递归地应用，直到子问题足够简单以至于可以直接解决。

分治法的步骤

1. 分解：将原问题分解成n个规模较小、相互独立且与原问题形式相同的子问题。
2. 解决：递归地解这些子问题。若子问题足够小，则直接求解。
3. 合并：将子问题的解合并成原问题的解。

分治法的优点

• 简单性：分治法通常比其它算法设计方法更易于理解和实现。
• 效率：分治法在很多情况下可以产生高效的算法，特别是当它可以将问题分解成独立的子问题时。
• 并行性：分治法的子问题可以独立求解，因此很适合并行计算。

分治法的缺点

• 重叠子问题：如果子问题之间有大量的重叠，分治法可能不是最优的选择，因为它会重复解决相同的子问题。
• 不适用的问题：并非所有问题都可以有效地分解成独立的子问题。

分治法的应用实例

归并排序（Merge Sort）

归并排序是分治法的一个经典例子。它的基本步骤如下：

1. 分解：将数组从中间分成前后两部分。
2. 解决：递归地对这两部分分别进行归并排序。
3. 合并：将两个有序的子数组合并成一个有序的数组。

归并排序的时间复杂度为O(n log n)，空间复杂度为O(n)。

快速排序（Quick Sort）

快速排序也是分治法的一个应用，其步骤如下：

1. 分解：选定一个元素作为基准（pivot），重新排列数组，使得所有小于基准的元素都位于基准之前，而所有大于基准的元素都位于基准之后。
2. 解决：递归地对基准前后的两个子数组进行快速排序。
3. 合并：由于这两个子数组已经就地排序，所以不需要额外的合并步骤。

快速排序的平均时间复杂度为O(n log n)，但在最坏情况下为O(n^2)。

结论

分治法是一种强大的算法设计策略，适用于那些可以被分解成多个独立子问题的问题。通过递归地解决这些子问题并将它们的解合并，分治法可以高效地解决许多复杂问题。然而，对于存在大量重叠子问题的情况，分治法可能不是最佳选择，此时可以考虑使用动态规划等其他算法设计策略。

2 算法代码

1、两路合并算法

#include <iostream>
using namespace std;

void Merge(int, int, int, int*);

void Print(int* arr) {
	for (int i = 0; i < 10; i++) {
		cout << *(arr + i) << " ";
	}
	cout << endl;
}

void Sort(int* arr, int left, int right) {
	if (left < right) {
		int mid = (left + right) / 2;
		Sort(arr, left, mid);
		Sort(arr, mid + 1, right);
		Merge(left, mid, right, arr);
	}

}

void Merge(int left, int mid, int right, int* arr) {
	int* temp = new int[right - left + 1];
	int i = left, j = mid + 1, k = 0;
	while (i <= mid && j <= right) {
		if (arr[i] <= arr[j])
			temp[k++] = arr[i++];
		else
			temp[k++] = arr[j++];
	}
	while (i <= mid)
		temp[k++] = arr[i++];
	while (j <= right)
		temp[k++] = arr[j++];
	for (i = 0, k = left; k <= right;)
		arr[k++] = temp[i++];
}

int main()
{
	int arr[10] = { 1, 3, 6, 9, 2, 7, 4, 5, 0, 8 };
	Print(arr);
	Sort(arr, 0, 9);
	Print(arr);
	return 0;
}

2、快速排序算法

#include <iostream>
using namespace std;

int Partition(int*, int, int);

void Print(int* arr) {
	for (int i = 0; i < 10; i++) {
		cout << *(arr + i) << " ";
	}
	cout << endl;
}

void QuickSort(int* arr, int left, int right) {
	if (left < right) {
		int j = Partition(arr, left, right);
		QuickSort(arr, left, j - 1);
		QuickSort(arr, j + 1, right);
	}

}

int Partition(int* arr, int left, int right) {
	int i = left, j = right + 1, temp;
	do {
		do i++; while (arr[i] < arr[left]);
		do j--; while (arr[j] > arr[left]);
		if (i < j) swap(arr[i], arr[j]);
	} while (i < j);
	swap(arr[left], arr[j]);
	return j;
}

int main()
{
	int arr[10] = { 1, 3, 6, 9, 2, 7, 4, 5, 0, 8 };
	Print(arr);
	QuickSort(arr, 0, 9);
	Print(arr);
	return 0;
}

3 实验报告

word报告资源