算法：分治策略和递归1 | 通过迭代来学习递归

分治策略和递归

分治策略：
是将规模比较大的问题可分割成规模较小的相同问题。问题不变，规模变小。 这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。
递归：
若一个函数直接地或间接地调用自己，则称这个函数是递归的函数。(简单地描述为“自己调用自己”)。分治法所能解决的问题一般具有以下四个特征:

1. 该问题的规模缩小到一定的程度就可以容易地解决。
2. 该问题可以分解为若干个规模较小的相同问题。
3. 使用小规模的解,可以合并成该问题原规模的解。
4. 该问题所分解出的各个子规模是相互独立的。

分治策略的步骤

在分治策略中递归地求解一个问题，在每层递归中应用如
下三个步骤:

1. 分解︰将问题划分成一些子问题，子问题的形式与原问题一样，只是规模更小。
2. 解决︰递归地求解子问题。如果子问题的规模足够小，则停止递归，直接求解。
3. 合并︰将小规模的解组合成原规模问题的解。

如何理解？
示例：
需要数一堆硬币的个数，如果有一百枚硬币，一个人数需要很短时间，但如果是一亿个硬币，一个人不可能数完。分治策略就是把数这堆硬币的问题分解，分给几万人去数，这样问题本质没有改变，只是规模变小了，在每个人数完后，把结果合并，就完成了原来问题的解。

示例1：阶乘问题

题目：输入一个整数n，求n的阶乘

分析：通过规律可以得知可以定义为这样的函数，此时，fac(n - 1)代表从1乘到n - 1的阶乘。

循环写法：

int fac(int n)
{
	int sum = 1;
	for (int i = 1; i <= n; ++i)
	{
		sum *= i;
	}
	return sum;
}

递归写法：

 int fac(int n)
{
	if (n <= 1)
		return 1;
	else
		return fac(n - 1) * n;
}

他们的区别就是：
循环的时间复杂度为：O(n)，空间复杂度为：S(1)
而递归的时间复杂度和空间复杂度为： O(n), S(n). 因为在递归过程中，每次递归都是调用函数自己，所以每次都需要再次开辟栈帧，对于空间的开销大。并且如果在循环中写错了控制条件，程序并不会崩溃，如果递归的终止条件错误，那么会导致栈溢出。

示例2：打印数组的值

示例：

int main(void)
{
	int nums[] = { 12,23,34,45,56,67,78 };
	int numsSize = sizeof(nums) / sizeof(nums[0]);
	Print_nums(nums, numsSize);
	return 0;
}

循环写法：

void Print_nums(const int* nums, int numsSize)
{
	if (nums == nullptr) return;
	for (int i = 0; i < numsSize; ++i)
	{
		cout << nums[i] << " ";
	}
	cout << endl;
}

递归写法：

void Print(const int* nums, int numsSize)
{
	if (numsSize > 0)
	{
		Print(nums, numsSize - 1);
		cout << nums[numsSize - 1] << " ";
	}
}
void Print_nums(int* nums, int numsSize)
{
	if (nums == nullptr || numsSize < 1) return;
	Print(nums, numsSize);
	cout << endl;
}

对于递归过程的讲解：
实际上递归函数运行时分为两个过程，递推和回归。

图示：
红色线为递推过程，绿色线为回归过程。

示例3：在数组中查找目标值

示例3：在数组中查找目标值，存在则返回下标，不存在返回-1.

int main(void)
{
	int nums[] = { 12,23,34,45,56,67 };
	int numsSize = sizeof(nums) / sizeof(nums[0]);
	int target = 45;
	int pos = findTarget(nums, numsSize, target);

	cout << pos << endl;
	return 0;
}

循环写法：

int findTarget(const int* nums, int numsSize, int target)
{
	if (nums == nullptr || numsSize < 1) return -1;

	int pos = numsSize - 1;
	while (pos >= 0 && nums[pos] != target)
	{
		--pos;
	}
	return pos;
}

递归写法：

int Find(const int* nums, int numsSize, int target)
{
	if (numsSize <= 0 || nums[numsSize - 1] == target)
		return numsSize - 1;
	else
		return Find(nums, numsSize - 1, target);
}
int findTarget(const int* nums, int numsSize, int target)
{
	if (nums == nullptr || numsSize < 1) return -1;
	return Find(nums, numsSize, target);
}