递归、字符串反转与数组操作：概念与实例解析,-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_63260114/article/details/138212420

42-1 函数的递归

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

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

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

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

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

答：C

解析：无限递归会造成死循环和栈溢出

2、问：下列递归函数调用Fun(2)结果是多少？

int Fun(int n)
{
	if (n == 5)
	{
		return 2;
	}
	else
	{
		return 2 * Fun(n + 1);
	}
}
int main()
{
	int ret = Fun(2);
	printf("%d\n", ret);
	return 0;
}

答：16

解析：

3、字符串逆序

代码1：迭代实现

思路：a b c d e f -> f e d c b a，其实就是第一个和最后一个互换位置，第二个和倒数第二个互换位置，以此类推

代码：

int main()
{
	char arr[] = "abcdef";
	int sz = sizeof(arr) / sizeof(arr[0]);
	int left = 0 ;
	int right = sz-2;  //多了一个\0
	while(left<=right)
	{
		char tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;

		left++;
		right--;
	}
	printf("%s\n", arr);
	return 0;
}

结果：

代码2：使用strlen

代码：

int main()
{
	char arr[] = "abcdef";
	int left = 0;
	int right = strlen(arr) - 1;  //没有\0
	while (left <= right)
	{
		char tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;

		left++;
		right--;
	}
	printf("%s\n", arr);
	return 0;
}

结果：

代码3：递归实现

思路：

交换a和g，逆序bcdef

交换b和f，逆序cde……

并且交换的时候，如交换a和g的时候，a不能立刻代替g的位置，因为需要有\0作为字符串bcdef的结尾。所以先把a放在临时变量中，g的位置要赋值为\0，最后把a放在最初g的位置

步骤：

1、将第一个字符存在临时变量里

2、将最后一个字符赋给第一个字符

3、将最后一个字符赋为\0

4、利用reverse函数逆序字符串

5、将存在临时变量的第一个字符赋给最后一个字符

递归的条件：中间剩余字符串的长度大于等于2时，需要逆序

代码：

void reverse(char* arr)
{
	char tmp = *arr;  //1
	int len = strlen(arr);
	*arr = *(arr+len-1);  //2
	*(arr + len - 1 )= '\0';  //3
	if(strlen(arr+1)>=2)
		reverse(arr + 1);  //4
	*(arr + len - 1) = tmp;//5
}
int main()
{
	char arr[] = "abcdefg";
	reverse(arr);
	printf("%s\n", arr);
	return 0;
}

结果：

代码4：题目不让使用strlen函数

思路：自己写一个my_strlen函数实现strlen的效果

代码：

int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

void reverse(char* arr)
{
	char tmp = *arr;  //1
	int len = my_strlen(arr);
	*arr = *(arr + len - 1);  //2
	*(arr + len - 1) = '\0';  //3
	if (my_strlen(arr + 1) >= 2)
		reverse(arr + 1);  //4
	*(arr + len - 1) = tmp;//5
}

int main()
{
	char arr[] = "abcdefg";
	reverse(arr);
	printf("%s\n", arr);
	return 0;
}

结果：

代码5：使用多个参数

代码：

void reverse(char str[], int left, int right)
{
	char tmp = str[left];
	str[left] = str[right];
	str[right] = tmp;
	if(left < right)
	{
		reverse(str,left + 1, right - 1);
	}
}
int main()
{
	char str[] = "abcdefg";
	int left = 0;
	int right = strlen(str) - 1;
	reverse(str, left, right);
	printf("%s\n", str);
	return 0;
}

结果：

4、计算一个数的每位之和

代码：

int DigitalSum(unsigned int n)
{
	if (n > 9)
		return DigitalSum(n / 10) + n % 10;
	else
		return n;
}
int main()
{
	int n = 0;
	scanf("%u", &n);
	int sum = DigitalSum(n);
	printf("sum=%d\n", sum);
	return 0;
}

结果：

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

思路：实质上是实现pow函数

k>0，ret=n*Pow(n,k-1)

k==0，ret=1

k<0，ret=1.0/Pow(n,-k)

double Pow(int n, int k)
{
	if (k > 0)
	{
		return n*Pow( n, k - 1);
	}
	else if (k == 0)
	{
		return 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;
}

测试 1：

测试2：

测试3：

42-2 数组

1、问：关于一维数组初始化，下面哪个定义是错误的?（）

A .int arr[10]=[1,2,3,4,5,6};

B .int arr[]= {1,2,3,4,5,6};

C.int arr[]=(1,2,3,4,5,6);

D.int arr[10]= {0};

答：C

2、问：定义了一维int型数组a[10]后。下面错误的引用是（）

A .a[0]=1;

B.a[0] = 5*2;

C.a[10]=2;

D. a[1] = a[2] * a[0];

答：C

解析：数组a[10]的元素应该是a[0]到a[9]\

3、问：若定义int a[2][3]=[1.2.3.4.5.6)，则值为4的数组元素是()

A .a[0][0]

B.a[1][0]

C.a[1][1]

D.a[2][1]

答：B

4、问：下列代码的执行结果是多少？

int main()
{
	int arr[] = { 1,2,(3,4),5 };
	printf("%d\n", sizeof(arr));
	return 0;
}

答：16

解析：（3，4）是逗号表达式，结果是最后一个数，即为4。所以该数组一共四个整型，4*4=16

拓展：问：int arr[10]={0}的类型是什么？

答：int [10] （去掉名字就是它的类型）

5、问：下列代码的结果是？

int main()
{
	char str[] = "hello bit";
	printf("%d %d\n", sizeof(str), strlen(str));
	return 0;
}

答：10 9

解析：

sizeof和strlen

①sizeof是一个操作符，用来计算变量（类型）所占空间的大小，不关注内存中存在的具体内容，\0也会被算进去，单位是字节

②strlen是一个库函数，是专门求字符串长度的，只能针对字符串。从参数给定的地址向后一直找\0，统计\0之前出现的字符的个数

6、问：给出以下定义:

char acX[]="abcdefg";
char acY[]={ 'a','b”,'c”,'d”, 'e”,'f','g'};

以下说法正确的是()

A.数组acX和数组acY等价

B.数组acX和数组acY的长度相同

C.数组acX的长度大于数组acY的长度

D.数组acX的长度小于数组acY的长度

答：C

解析：这里统计的不是字符串的长度，而是数组长度。并且字符串长度大小不确定，因为acY里面还没有给出\0，字符串长度未知

7、问：关于一维数组描述不正确的是()

A .数组的下标是从0开始的

B.数组在内存中是连续存放的

C.数组名表示首元素的地址

D.随着数组下标由小到大，地址由高到低

答：D

8、问：以下能对二维数组a进行正确初始化的语句是（）

A.int a[2][]={{0,1,2},{3,4,5}};

B.int a[][3]={{0,1,2},{3,4,5}};

C.int a[2][4]={{0,1,2},{3,4),{5}};

D .int a[][3]={{0,2},{},{3,4,5}};

答：B

9、将数组A中的内容和数组B中的内容进行交换。(数组一样大）

代码：

int main()
{
	int arr1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	int arr2[10] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		int tmp = arr1[i];
		arr1[i] = arr2[i];
		arr2[i] = tmp;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

结果：

10、创建一个整形数组，完成对数组的操作

①实现函数init()初始化数组为全0

②实现print()打印数组的每个元素

③实现reverse(）函数完成数组元素的逆置

代码：

//①实现函数init()初始化数组为全0
void init(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		arr[i] = 0;
	}
}


//②实现print()打印数组的每个元素
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}


//③实现reverse(）函数完成数组元素的逆置
void reverse(int arr[],int sz)
{
	int left = 0;
	int right = sz - 1;
	while (left < right)
	{
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;

		left++;
		right--;
	}
}
int main()
{
	int arr[] = { 0,2,4,6,8,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	reverse(arr, sz);
	print(arr, sz);
	init(arr, sz);
	print(arr, sz);
	return 0;
}

结果：