2022-04-22_函数（三）

第 1 题（单选题）

题目名称：

关于递归的描述错误的是：（ ）

题目内容：

A .存在限制条件，当满足这个限制条件的时候，递归便不再继续

B .每次递归调用之后越来越接近这个限制条件

C .递归可以无限递归下去

D .递归层次太深，会出现栈溢出现象

递归的两个条件：

1. 将问题转化为其子问题，子问题要与原问题具有相同的解法
2. 递归的出口

A：正确，限制条件即递归的出口，如果限制条件满足，递归程序就可以退出了

B：正确，因为每次递归，都是将原问题进一步缩小，缩小到限制条件时，就可以往回返，直到第一次递归调用

C：错误，递归不能无限递归下去，否则会造成死循环和栈溢出

D：正确，因为每次递归，相当于都是一次新的函数调用，而每次函数调用系统必须给该函数划分栈帧空间，内部的递 归函数没有退出，上层的递归就不能退出，栈帧就会累积许多块，如果累积超过栈的总大小，就会栈溢出。

第 2 题（单选题）

题目名称：

根据下面递归函数：调用函数Fun(2)，返回值是多少（ ）

int Fun(int n)      
{ 
  if(n==5)   
    return 2;     
  else     
    return 2*Fun(n+1);      
}

题目内容：

A .2

B .4

C .8

D .16

2 * Fun(3)

2 * 2 * Fun(4)

2 * 2 * 2 * Fun(5)

2 * 2 * 2 * 2 = 16

第 3 题（编程题）

题目名称：

打印一个数的每一位

题目内容：

递归方式实现打印一个整数的每一位

void print(int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}

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

	print(a);

	return 0;
}

第 4 题（编程题）

题目名称：

求阶乘

题目内容：

递归和非递归分别实现求n的阶乘（不考虑溢出的问题）

//递归
int Fac(int n)
{
	if (n < 1)
		return 1;
	else
		return n * Fac(n - 1);
}

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

	int ret = Fac(a);
	printf("%d", ret);

	return 0;
}

//非递归
int Fac(int n)
{
	int result = 1;
	while (n > 1)
	{
		result *= n;
		n -= 1;
	}
	return result;
}


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

	int ret = Fac(a);
	printf("%d", ret);

	return 0;
}

第 5 题（编程题）

题目名称：

strlen的模拟（递归实现）

题目内容：

递归和非递归分别实现strlen

/*
strlen的含义是：求字符串中有效字符的长度，不包括\0。
*/

/*
循环实现：
1. 给一个计数，用来统计有效字符的个数
2. 遍历字符串，只要没有遇到\0, 遇到一个字符给计数加1，直到遇到\0
*/

//非递归实现strlen
int my_strlen_1(char* str)
{
    int count = 0;
    while ('\0' != *str)
    {
        count++;
        str++;
    }
    return count;
}


//递归实现strlen
int my_strlen_2(char* str)
{
    if (*str == '\0')
        return 0;
    else
		return 1 + my_strlen_2(str + 1);
}
int main()
{
    int ret1 = my_strlen_1("abcd");
    printf("%d\n", ret1);

    int ret2 = my_strlen_2("abcd");
    printf("%d\n", ret2);

    return 0;
}

第 6 题（编程题）

题目名称：

字符串逆序（递归实现）

题目内容：

编写一个函数 reverse_string(char * string)（递归实现）

实现：将参数字符串中的字符反向排列，不是逆序打印。

**要求：**不能使用C函数库中的字符串操作函数。

比如:

char arr[] = "abcdef";

逆序之后数组的内容变成：fedcba

/*
思路：
逆置字符串，循环的方式实现非常简单
  1. 给两个指针，left放在字符串左侧，right放在最后一个有效字符位置
  2. 交换两个指针位置上的字符
  3. left指针往后走，right指针往前走，只要两个指针没有相遇，继续2，两个指针相遇后，逆置结束
*/
void reverse_string(char arr[])
{
	int left = 0;
	int right = strlen(arr) - 1;

	while (left < right)
	{
		char tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;

		left++;
		right--;
	}
}

/*
递归方式：
对于字符串“abcdefg”，递归实现的大概原理：
  1. 交换a和g，
  2. 以递归的方式逆置源字符串的剩余部分，剩余部分可以看成一个有效的字符串，再以类似的方式逆置
*/
//题目递归代码
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
void reverse_string(char* string)
{
	int len = my_strlen(string);
	char tmp = *string;

	*string = *(string + len - 1);
	*(string + len - 1) = '\0';
	if (my_strlen(string + 1) >= 2)
		reverse_string(string + 1);
	*(string + len - 1) = tmp;
}

int main()
{
	char arr[] = "abcdef"; // [a b c d e f \0]

	reverse_string(arr);

	printf("%s", arr);

	return 0;
}

//优化递归代码
void reverse_string(char arr[], int left, int right)
{
	if (left < right)
	{
		char tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		reverse_string(arr, left + 1, right - 1);
	}

}
int main()
{
	char arr[] = "abcdef"; // [a b c d e f \0]
	int left = 0;
	int right = strlen(arr) - 1;
	reverse_string(arr, left, right);

	printf("%s", arr);

	return 0;
}

第 7 题（编程题）

题目名称：

计算一个数的每位之和（递归实现）

题目内容：

写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和

例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19

输入：1729，输出：19

int DigitSum(unsigned int n)
{
	if (n > 9)
	{
		return DigitSum(n / 10) + n % 10;
	}
	else
	{
		return n;
	}
}

int main()
{
	unsigned int n = 0;
	scanf("%d", &n);
	int sum = DigitSum(n);
	printf("%d\n", sum);

	return 0;
}

第 8 题（编程题）

题目名称：

递归实现n的k次方

题目内容：

编写一个函数实现n的k次方，使用递归实现。

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

int main()
{
	int n = 0;
	int k = 0;
	scanf("%d %d", &n, &k);
	double ret = Pow(n, k);

	printf("%lf\n", ret);

	return 0;
}

第 9 题（编程题）

题目名称：

计算斐波那契数

题目内容：

递归和非递归分别实现求第n个斐波那契数

例如：

输入：5 输出：5

输入：10， 输出：55

输入：2， 输出：1

//非递归
int Fac(int n) {
	if (n == 0 || n == 1) {
		return 1;
	}
	else {
		int left1 = 1, left2 = 1;
		int add = 0;
		for (int i = 3; i <= n; i++) {
			add = left1 + left2;
			left2 = left1;
			left1 = add;
		}
		return add;
	}
}
int main() {
	int n = 0;
	scanf("%d", &n);
	
	int ret = Fac(n);
    printf("%d", ret);

	return 0;
}

//递归
int Fac(int n)
{
    if (n == 1 || n == 2)
    {
        return 1;
    }
    else
    {
        return Fac(n - 1) + Fac(n - 2);
    }
}

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

    int ret = Fac(n);
    printf("%ld", ret);

    return 0;
}