day09 2.数组作为函数参数传递 3.值传递与地址传递 4.递归函数

作业

1> 使用递归实现 求 n 的 k 次方

#include <stdio.h>

int dg(int n,int k)
{
	if(k == 0)
	{
		return 1;
	}else
	{
		return n*dg(n,k-1);
	}
}

int main(int argc, const char *argv[])
{

	int n=0,k=0;
	printf("请输入n的值:");
	scanf("%d",&n);
	printf("请输入n的次方数:");
	scanf("%d",&k);
	dg(n,k);                              //调用递归函数
	int sum=dg(n,k);                      //把递归函数返回值赋值给sum 
	printf("结果为:%d\n",sum);
	return 0;
}

2> 使用递归实现 strlen 的功能

#include <stdio.h>
#define N 20
int len(char *str)
{
	if(*str  == '\0')
	{
		return 0;
	}else
	{
		return len(str+1)+1;
	}
}

int main(int argc, const char *argv[])
{
	char arr[N]="ni hao";
	int length=len(arr);
	printf("%d\n",length);
	return 0;
}

 

#include <stdio.h>
#define N 20
int len(char arr[])
{
	if(arr[0]  == '\0')
	{
		return 0;
	}else
	{
		return len(arr+1)+1;
	}
}

int main(int argc, const char *argv[])
{
	char arr[N]="";
	printf("请输入一个字符串:");
	scanf("%s",arr);
	int sum=len(arr);
	printf("%d\n",sum);
	return 0;
}

 

3> 使用递归实现汉诺塔问题(君子作业)

4> 定义一个函数将一个字符串从大到小排序

#include <stdio.h>
#include <string.h>
#define M 20
void paixu(char arr[],int n)
{
    char str='0';
	for(int i=0;i<n-1;i++)
	{
		for(int j=0;j<n-i-1;j++)
		{
			if(arr[j]-arr[j+1]<0)
			{
				str=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=str;
			}
		}
	}
	printf("排序后:%s\n",arr);
}
int main(int argc, const char *argv[]) {
  	int len=0;
	char arr[M]="";
	printf("输入字符串为:");
	gets(arr);
	len = strlen(arr);
	paixu(arr,len);
    return 0;
}

5> 实现一个函数，用于检查一个字符串是否是回文字符串（正序和反序都相同）

#include <stdio.h>
#include <string.h>

//判断回文数函数
int huiwen(char drr[],int n)
{
	char brr[20]="";
	char crr[20]="";
	int i=0,j=0;

	for(i=0;i<n/2;i++)             //取出前一半的字符
	{
		brr[i]=drr[i];
	}

	if(n%2==0)						//取出后一半字符
	{
		for(i=n-1;i>=n/2;i--)
		{
			crr[j]=drr[i];
			j++;
		}
	}else
	{
		for(j=n-1;i>n/2;i--)
		{
			crr[j]=drr[i];
			j++;
		}
	}

	if(strcmp(brr,crr)==0)		//判断是否一致
	{
		return 1;
	}
}
int main(int argc, const char *argv[])
{
	int len=0,sum=0;
	char arr[20]="";
	printf("请输入字符串:");
	gets(arr);
	len=strlen(arr);
	sum=huiwen(arr,len);
	switch(sum)
	{
	case 1:
		{
			printf("该字符串是回文字符串\n");
		}
		break;
	default:
		{
			printf("该字符不是回文字符串\n");
		}
		break;
	}
	return 0;
}

6> 使用指针完成判断自己的主机存储多字节整数时，是大端存储还是小端存储

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int num = 1;
    char *ptr = (char *)&num;

    if (*ptr == 1) {
        printf("小端\n");
    } else {
        printf("大端\n");
    }

    return 0;
}

7>

#include <stdio.h>
#include <string.h>

//单词函数
void sum_str(char*p)
{
	char *str=p;
	int i=0,count =0;
	while(*str)
	{
		if((*str>=97)&&(*str<=122))
		{
		}
		else if((*str>=65)&&(*str<=90))
		{
		}
		else
		{
			count++;
		}
		str++;
	}
	printf("单词有%d个\n",count);
}

/**************************主函数***************************/
int main(int argc, const char *argv[])
{
	char str[30]="0";
	printf("请输入单词");
	gets(str);
	sum_str(str);
	return 0;
}

二、数组作为函数传递

1> 数组的要素：起始地址（数组名），数组的容量

2> 数组作为函数参数传递，属于地址传递，形参内容的改变，实参内容也会跟着改变

3> 定义形参接受数组时，接受数组名时，只需要定义一个变量标识数组即可

#include<myhead.h>
 
//定义输出函数
void print_arr(int brr[], int n)
{
	printf("数组元素分别是：");
	for(int i=0; i<n; i++)
	{
		printf("%d\t", brr[i]);
	}
	puts("");
}
 
 
//定义排序函数
void sort_arr(int brr[], int n, int flag)
{
	for(int i=1; i<n; i++)
	{
		for(int j=0; j<n-i; j++)
		{
			if(flag == 0)      //升序
			{
				if(brr[j]>brr[j+1])
				{
					int temp = brr[j];
					brr[j] = brr[j+1];
					brr[j+1] = temp;
				}
			}else
			{
				if(brr[j]<brr[j+1])
				{
					int temp = brr[j];
					brr[j] = brr[j+1];
					brr[j+1] = temp;
				}
			}
 
		}
	}
}
 
 
//定义输出brr的函数
void print_brr(char brr[][20], int n)
{
	printf("传入的字符串分别是：");
	for(int i=0; i<n; i++)
	{
		printf("%s\t", brr[i]);
	}
	puts("");
}
 
/******************主程序***************************/
int main(int argc, const char *argv[])
{
	int arr[8] = {1,3,2,6,7,9,5,10};        //定义一个数组并初始化
 
	//调用函数完成对该数组的输出
	print_arr(arr, 8);               //传递数组时，只需要传递数组名和数组容量
	
	//调用排序函数
	sort_arr(arr, 8, 0);    //升序排序
 
	//输出排序后的结果
	print_arr(arr, 8);
 
	//定义二维字符数组
	char brr[][20] = {"banana", "apple", "zhangsan"};
	//调用函数输出数组
	print_brr(brr, 3);
 
	return 0;
}

三、值传递与地址传递

3.1 值传递

1> 值传递的原理

值传递由主函数对定义的函数进行参数传递，不改变主函数的实参

2> 说明：

值传递过程中，形参与实参操作的是不同的内存空间

当普通变量作为函数参数传递时，是单向的值传递，仅仅只是将实参的值，复制一份给形参使用，形参的改变不会影响到实参的值

3> 代码实现

#include<myhead.h>
 
//定义交换函数
void swap_1(int m, int n)
{
	//完成两个数的交换
	int temp = m; 
	m = n; 
	n = temp;
 
	printf("交换后，swap_1:: m = %d, n = %d\n", m, n);
}
 
 
/*********************主程序*********************/
int main(int argc, const char *argv[])
{
	//定义两个变量
	int num = 520;
	int key = 1314;
 
	//调用交换函数
	swap_1(num, key);
	printf("交换后，main:: num = %d, key = %d\n", num, key);
 
 
	return 0;
}

3.2 地址传递

1> 说明：

当实参传递的是数组名、指针或变量的地址（&num）时，可以理解成是地址传递

地址传递过程中，形参与实参操作的是同一块内存空间

形参对内存空间进行改变时，实参也跟着一起改变

2> 程序实现

#include<myhead.h>
 
//定义冒泡排序函数
void sort_up(int brr[], int n)
{
	printf("sizeof(brr) = %ld\n", sizeof(brr));   //
	//进行冒泡排序
	for(int i=1; i<n; i++)
	{
		for(int j=0; j<n-i; j++)
		{
			if(brr[j] > brr[j+1])
			{
				int temp = brr[j];
				brr[j] = brr[j+1];
				brr[j+1] = temp;
			}
		}
	}
	printf("排序结束\n");
}
 
 
 
/****************主程序********************/
int main(int argc, const char *argv[])
{
	//定义一个一位数组并初始化
	int arr[5] = {2,8,1,6,7};
	printf("sizeof(arr) = %ld\n", sizeof(arr));    //20
 
	//调用冒泡排序函数，完成升序排序
	sort_up(arr, 5);
 
	//输出排序后的结果
	printf("排序后：");
	for(int i=0; i<5; i++)
	{
		printf("%d\t", arr[i]);
	}
	printf("\n");
 
	return 0;
}

四、递归函数

4.1 递归的概念

所谓递归，就是一个函数直接或间接的形式调用自身，这样的函数调用，我们称为递归调用

#include<myhead.h>
 
//定义一个讲故事函数
void say_story()
{
	printf("从前有座山，山里有个庙，庙里有个老和尚给小和尚讲故事，故事里说：");
 
	say_story();
}
 
 
 
 
int main(int argc, const char *argv[])
{
	
	//调用讲故事函数
	say_story();
 
	return 0;
}

4.2 递归条件

1> 递归出口：用于终止递归进行进行的条件

2> 递归表达式：能够让递归继续进行的函数调用

4.3 递归思想

当直接解决规模比较大的问题不能进行时，需要先解决规模较小的原理一致的问题后，大的问题得以解决时，可以考虑使用递归

逐层分解，逐层合并