C语言基础_递归函数

之前学习过的一些小算法，在许久不看之后又忘了。可能是当时学的时候追求速度，没有理解透彻，所以打算整理一下自己学习过的一些算法，先从递归函数开始吧！大二初学C语言遇到递归函数时，觉得很绕，虽然当时马马虎虎学了，但在我的印象深处总觉得递归函数是一个不大不小的高山，想翻越它需要费一些功夫，好了，废话不多说，开始整理吧！

递归函数

定义

什么是递归？
程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于：把大事化小。

可以使用递归的两个条件

1. 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2. 每次递归调用之后越来越接近这个限制条件。

注意：递归可能导致栈溢出,尽量使用迭代的方式来解决问题递归。（栈溢出，以后关于这个也得写个笔记！！）

我目前遇到的使用递归函数的情况，大多数是解决算法题，在写扫雷游戏的时候也能用到递归，后面关于扫雷也得写个笔记，到时候细细说是在哪，如何使用递归的。关于递归的定义大致就这么多，下面开始列举使用递归解决的算法题。

使用递归的例子

按顺序打印一个正数的每个位的数字

void print(int n)
{
	if (n > 9) // 判断输入数字是不是个位数，不是的话递归，是的话输出它
	{
		print(n / 10); // 一直调用函数到头，然后一层一层返回
	}
	printf("%d ", n % 10); // 输出这一位的数字
}

int main()
{
	unsigned int num = 0; //  
	scanf("%d", &num);
	print(num);

	return 0;
}

整体思路：我们要得到这个数的每个位的数字，然后按顺序打印出来，下面先来看如何拿到一个数的各个位的数字，假设输入位123，首先有下面的规律：

1. 123 % 10 = 3 ; 123 / 10 = 12 (因为是int型，所以小数部分会省去)
2. 12 %10 = 2 ; 12 / 10 = 1
3. 1 % 10 = 1 ; 1 / 10 = 0

由此可以发现，任意一个数字经历以上步骤，可以得到它的每个位的数字，我们需要从3->1按顺序打印得到的数字。可以看出，在以上步骤中，当输入数字为个位数时，这个数就是需要得到的个位数字，输出它即可，这个就相当于结束递归的条件。所以设计递归函数的时候，如果输入的数不是个位数字，那就让它继续递归，直到递归到是个位数字，然后打印它，打印完它之后，又会返回到上一步，继续往下执行代码，执行完又会返回上一步，再执行剩下的代码，直到回到第一步，然后执行剩下的代码。这个剩下的代码其实就是打印每一位的数字。（感觉说得好乱。。。）

递归求字符串长度

// 递归求字符串长度
int my_strlen(char* str)
{
	if (*str != '\0')
	{
		return 1 + my_strlen(str + 1);
	}
	else
	{
		return 0;
	}

}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d ", len);

	return 0;
}

分析：数组存储字符串时，会在字符串后面加’\0’, 所以判断字符串长度时，遇到’\0’就意味着字符串结束。因此判断长度时，先从数组第一个位置开始判断，如果不是’\0’，则长度+1，地址也+1跳到第二个元素处。如果用递归函数来实现的话，当输入一个数组，如果第一个位置不是’\0’，那么长度+1，进入递归，判断第二个位置，一直到’\0’处，返回0，然后上一层就返回0+1，每退一层长度就会+1，以此类推到第一层，然后就能返回字符串的长度。

计算斐波那契数

// 计算斐波那契数
int Fibo2(int n) // 循环的方法
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n > 2)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}

int Fibo1(int n)  // 递归的方法
{
	if (n < 3)
	{
		return 1;
	}
	else
	{
		return Fibo1(n - 1) + Fibo1(n - 2);
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);

	/*int ret_1 = Fibo1(n);
	printf("%d ", ret_1);*/

	int ret_2 = Fibo2(n);
	printf("%d ", ret_2);

	return 0;
	
}

说起来我和斐波那契数列有很大的渊源，本科毕业论文就是研究斐波那契数列的性质，有人说斐波那契数列蕴含着宇宙的奥秘，总之一句话，这个数列非常神奇。先来看一下什么是斐波那契数：1，1，2，3，5，8，13，21……这个数列称为斐波那契数列，数列的项称为斐波那契数，很显然，某一项等于前两项之和。
现在我们要算的是斐波那契数列的第n项，显然，当输入的n小于3时，直接返回1就行；如果n大于3，那么就返回它的前两项之和，然后前两项也会递归，一直递归到遇到第一项和第二项的值，开始倒退计算，一层层返回就能计算出我们要求的项。

汉诺塔游戏

问题描述：在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置64个金盘。游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。

// 汉诺塔

void move(int n, char a, char b, char c)
{
	if (n == 1)
		printf("\t%c->%c\n", a, c);    //当n只有1个的时候直接从a移动到c 
	else
	{
		move(n - 1, a, c, b);            //把a的n-1个盘子通过c移动到b 
		printf("\t%c->%c\n", a, c);   //把a的最后1个盘(最大的盘)移动到c 
		move(n - 1, b, a, c);            //把b上面的n-1个盘通过a移动到c 
	}
}

main()
{
	int n;
	printf("请输入要移动的块数：");
	scanf("%d", &n);
	move(n, 'a', 'b', 'c');
}

这玩意感觉好复杂，可以画三个盘子试一下，我觉得用文字描述不来这个过程，如果要细细说的话，需要单独写个博客，等后面有时间的话再写。发现了一个有趣的事情，汉诺塔游戏的发明者是卢卡斯，而卢卡斯是研究斐波那契数列的一个著名人物。

逆序字符串

// 用递归的方式逆序字符串
void reverse(char* arr)
{
	char tmp = arr[0];
	int len = strlen(arr);
	arr[0] = arr[len - 1];
	arr[len - 1] = '\0';
	if (strlen(arr + 1) > 1)
		reverse(arr + 1);
	arr[len - 1] = tmp;
}

int main()
{
	char arr[] = "abcdef";
	reverse(arr);

	return 0;
}

/

// 常规方法逆序字符串
void reverse(char* arr)
{
	int len = strlen(arr);
	char tmp = 0;
	int left = 0;
	int right = len - 1;

	while (left < right)
	{
		tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
}

int main()
{
	char arr[] = "abcdefghi";
	
	reverse(arr);
	printf("%s", arr);

	return 0;
}

思路：用递归逆序字符串的大致思想就是把字符串第一个字符跟最后一个拿出来，给剩下的字符串的最后一个字符赋为’\0’，然后对剩下的字符串进行递归，直到字符串剩下一个字符后停止，然后一层一层返回，返回时交换第一个位置和最后一个位置的字符，到第一层时字符串就倒序排列了。
上面的代码还用迭代法实现了字符串逆序，我觉得这个方法比较直观。

计算一个int型数的每位数字之和

// 用递归计算一个数各个位数字之和
int DigitSum(int n)
{
	// 分析：用拆分的方式分析递归逻辑
	// DigitSum(1234) =            DigitSum(123)          +  1234%10
	//				  =      DigitSum(12)   + 123%10      +  1234%10
	//				  = DigitSum(1) + 12%10 + 123%10   +     1234%10
	//
	//
	int sum = 0;
	if (n > 9)
	{
		return DigitSum(n / 10) + n % 10;
	}
	else
	{
		return n;
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);

	int ret = DigitSum(n);
	printf("%d", ret);
	return 0;
}

递归计算一个数的n次方

double pow(int num, int k)
{
	if (0 == k)
	{
		return 1.0;
	}
	else if (k > 0)
	{
		return (double)num * pow(num, k - 1);
	}
	else
	{
		return 1.0 / pow(num, -k);
	}
}

int main()
{
	int num = 0, k = 0;
	scanf("%d %d", &num, &k);

	double ret = pow(num, k);

	printf("%lf", ret);
}

分析：这个题用递归的话很容易理解，值得注意的是n小于零时的情况，为了满足这种情况，代码中需要用到很多小知识点。首先，在这块定义类型时要用double类型——浮点类型，因为一个数的负数次方是它的正数次方的倒数，计算时会出现除法，若是定义成int型，那么计算时只会得到整数部分，计算造成很大误差，所以要用浮点类型。其次，C语言中，除法两边有一个数位浮点型，那么结果就会是浮点型。

结尾

好了，终于整理完了，感觉自己的梳理过程还是不太顺畅，很多算法感觉自己是想不到的，大概就是看代码能懂，自己写不出来，还是学得不到位啊，任重而道远！