C递归函数

分治策略:

是将规模比较大的问题可分割成规模较小的相同问题。问题不变，规模变小。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。

递归:
若一个函数直接地或间接地调用自己，则称这个函数是递归的函数。(简单地描述为“自己调用自己”)。

分治法所能解决的问题一般具有以下四个特征:

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

分治法步骤:

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

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

递归函数

• 递归函数的执行分为 “ 递推 ” 和“回归”两个过程，这两个过程由递归终止条件控制，即逐层递推，直至递归终止条件满足，终止递归，然后逐层回归。
• 递归调用同普通的函数调用一样，每当调用发生时，就要分配新的栈帧（形参数据，现场保护，局部变量)﹔而与普通的函数调用不同的是，由于递推的过程是一个逐层调用的过程，因此存在一个逐层连续的分配栈帧过程，直至遇到递归终止条件时，才开始回归，这时才逐层释放栈帧空间，返回到上一层，直至最后返回到主调函数。
• 因为栈帧在Windons系统下分配1M，故栈帧空间有限，所以不存在无限递归；但是可以有无限循环，无限循环浪费的是CPU资源，CPU实际占用的是时间资源。
  

循环的时间复杂度：O（n)
空间复杂度S（1）

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

递归的时间复杂度为：O (n)
空间复杂度S (n)

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

注：函数代码只有一份，分析时拷贝多份以方便递归调用分析，该程序在回归的过程中进行计算

栈帧的动态调用过程：

递归训练：

（1）输入一个整数（无符号整型)，用递归算法将整数倒序输出

//输入一个整数（无符号整型)，用递归算法将整数倒序输出。

void Print(unsigned int x)
{
	while (x != 0)
	{
		printf("%4d", x % 10);
		x = x / 10;
	}
}

void Print_D(unsigned int x)
{
	if (x != 0)
	{
		//递推的过程中打印
		printf("%4d", x % 10);
		Print_D(x / 10);//3,2,1
	}
}

void Print_D1(unsigned int x)
{
	if (x != 0)
	{
		//回归的过程中打印
		Print_D(x / 10);
		printf("%4d", x % 10);//1,2,3
	}
}

int main()
{
	unsigned int x;//123
	scanf_s("%d", &x);
	Print_D(x);
	return 0;
}

（2）计算俩个数的最大公约数

//计算俩个数的最大公约数
int fun(int a, int b)
{
	int c = 0;
	while (b != 0)
	{
		c = a % b;
		a = b;
		b = c;
	}
	return a;
}

int fun_D(int a, int b)
{
	if (b == 0)
	{
		return a;
	}
	else
	{
		return fun_D(b, a % b);
		
	}
}


int main()
{
	int a, b;
	scanf_s("%d %d", &a, &b);
	printf("%d \n", fun(a, b));
	return 0;
}

（3）数组逆置打印

//数组逆置打印
void Print(int* br, int n)
{
	assert(br != nullptr);
	while (n > 0)
	{
		printf("%4d", br[n - 1]);
		--n;
	}
}

void Print_D(int* br, int n)
{
	assert(br != nullptr);
	if (n > 0)
	{
		printf("%4d", br[n - 1]);
		--n;
		Print_D(br, n);
	}
}


int main()
{
	int ar[3] = { 1,23,3 };
	Print_D(ar,3);
	return 0;
}

（4）斐波拉契数列

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

// 斐波拉契数列
int main()
{
	const int n = 30;
	int ar[n] = { 1,1 };
	for (int i = 2;i < n;++i)
	{
		ar[i] = ar[i - 1] + ar[i - 2];
	}

	for (int i = 0;i < n;++i)
	{
		printf("%d \n", ar[i]);
	}
	for (int i = 3;i < n - 1;++i)//打印的值近似于黄金分割数0.618
	{
		printf("%d/%d=>%f\n", ar[i], ar[i + 1], (double)ar[i] / ar[i + 1]);
	}



	return 0;
}

//计算第n位斐波拉契数

int fun(int n)
{
	int a = 1, b = 1, c = 1;
	for (int i = 3;i <= n;++i)//O(n)
	{
		c = a + b;
		a = b;
		b = c;
	}
	return c;
}

int fun_D(int n)//时间复杂度：O（2^n);空间复杂度：S（n)
{
	if (n <= 2)
	{
		return 1;
	}
	else
	{
		return fun_D(n - 1) + fun_D(n - 2);
	}
}

int main()
{
	int n = 0, sum = 0;
	scanf_s("%d", &n);
	sum = fun(n);
	printf("%d", sum);
	return 0;
}

（5）循环遍历数组查找数据（二分查询的极致运用）

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

int FindValue_F(const int* br, int n, int val)//for循环遍历数组查找val
{
	assert(br != nullptr);
	int pos = -1;
	for (int i = 0;i < n;++i)
	{
		if (br[i] == val)
		{
			pos = i;
			break;
		}
	}
	return pos;
}

int FindValue_W(const int* br, int n, int val)//while循环遍历数组查找val
{
	assert(br != nullptr);
	int pos = n - 1;
	while (pos >= 0 && br[pos] != val)
	{
		--pos;
	}
	return pos;
}


//O(log2^n)
// 二分查询遍历数组查找val（数组中无重复数据）
int FindValue_2(const int* br, int n, int val)
{//二分查询要求：数据在数组中连续，数据在数组中有顺序
	assert(br != nullptr);
	int pos = -1;
	int left = 0;int right = n - 1;

	while (left <= right)
	{
		//int mid = (left + right) / 2;    如果下标太大，left+right会越界
		//int mid=((right-left)>>1)+left;   不建议这样写
		int mid = (right - left) / 2 + left;
		if (val < br[mid])
		{
			right = mid - 1;
		}
		else if (val > br[mid])
		{
			left = mid + 1;
		}
		else
		{
			pos = mid;
			break;
		}
	}
	return pos;
}


// 二分查询遍历数组查找val（数组中存在重复数据，要求返回重复数据最左边的下标）
int FindValue_22(const int* br, int n, int val)
{
	assert(br != nullptr);
	int pos = -1;
	int left = 0;int right = n - 1;

	while (left <= right)
	{
		int mid = (right - left) / 2 + left;
		if (val < br[mid])
		{
			right = mid - 1;
		}
		else if (val > br[mid])
		{
			left = mid + 1;
		}
		//else
		//{//一个下标一个下标的比较，效率低
		//	while (mid > left && br[mid-1] == val) { mid--; }//找到最左边的下标
		//	//while (mid <right && br[mid+1] == val) { mid++; }//找到最右边的下标
		//	pos = mid;
		//	break;
		//}

		else
		{
			if (mid >= left && br[mid - 1] != val)//数组会越界
			{
				pos = mid;
				break;
			}
			right = mid - 1;//对于重复的数据依旧进行二分查询，效率提高
		}


	}
	return pos;
}


//                   n:代表数组规模，数组中元素个数
int Find(int* br, int n, int val)
{
	//if (n <=0 || br[n - 1] == val)  n<=0:n有两层含义（1）：规模；(2)下标
	if (n < 1 || br[n - 1] == val)
	{
		return n - 1;
	}
	else
	{
		return Find(br, n - 1, val);
	}
}


int FindValue_D(int* br, int n, int val)
{
	assert(br != nullptr);
	return Find(br, n, val);
}

int main()
{
	int ar[] = { 12,56,89,23,45,100,90 };
	int n = sizeof(ar) / sizeof(ar[0]);

	int br[] = {12,12,12,12,12,56,56,56,56,89,89,89,90,90 };
	int m = sizeof(br) / sizeof(br[0]);
	/*int val;
	scanf_s("%d", &val);
	int pos = FindValue_D(ar, n, val);

	printf("%d", pos);*/

	/*for (int i = 0;i < n;++i)
	{
		printf("%d=>%d", ar[i], FindValue_D(ar, n, ar[i]));
	}*/
	int a = FindValue_22(br, n, 12);
	printf("%d", a);


	return 0;
}

代码改进：防止数组越界

// 二分查询遍历数组查找val（数组中存在重复数据，要求返回重复数据最左边的下标）
int FindValue_22(const int* br, int n, int val)
{
	assert(br != nullptr);
	int pos = -1;
	int left = 0;int right = n - 1;

	while (left <= right)
	{
		int mid = (right - left) / 2 + left;
		if (val < br[mid])
		{
			right = mid - 1;
		}
		else if (val > br[mid])
		{
			left = mid + 1;
		}
		//else
		//{//一个下标一个下标的比较，效率低
		//	while (mid > left && br[mid-1] == val) { mid--; }//找到最左边的下标
		//	//while (mid <right && br[mid+1] == val) { mid++; }//找到最右边的下标
		//	pos = mid;
		//	break;
		//}

		else
		{
			if (mid > left && br[mid - 1] == val)
			{
				right = mid - 1;//对于重复的数据依旧进行二分查询，效率提高
			}
			else
			{
				pos = mid;
				break;
			}
			
		}


	}
	return pos;
}