🌞欢迎来到机器学习的世界 
🌈博客主页：卿云阁

💌欢迎关注🎉点赞👍收藏⭐️留言📝

🌟本文由卿云阁原创！

🌠本阶段属于练气阶段，希望各位仙友顺利完成突破

📆首发时间：🌹2021年3月12日🌹

✉️希望可以和大家一起完成进阶之路！

🙏作者水平很有限，如果发现错误，请留言轰炸哦！万分感谢！

---

目的：减少代码量，便于编程和调试。

比如：计算5!+8!+7!+10!的值，并输出结果。

#include<stdio.h>
int fac(int n)
{   int i;
    int fac=1;
    for(i=1;i<=n;i++)
	  fac=fac*i;
	return fac;
}
int main(void)
{
	int n;
	int sum;
    sum=fac(1)+fac(2)+fac(3);
    printf("sum=%d",sum);
    return 0; 
} 

调用函数的过程：

#include <stdio.h>
int max(int x,int y)
{
	return x>y?x:y;   //条件表达式求出x和y的最大值，用return 返回。
}
int main(void)
{
   int a,b,c;
   a=max(10,20);    //调用函数max，10、20为实参。
   b=max(15,19);    //再次调用函数max，15、19为实参。
   c=max(a,b);      //再次调用函数max，a、b为实参。
   printf("%d\n",c);  
   return 0;
}

   令y=a*a+b*b，a和b是变量，定义一个函数，根据不同的a、b值计算y的值，并在main函数中输入两个值，调用该函数，输出计算的结果。

#include <stdio.h>
int yum(int x,int y)
{
	return x*x+y*y;   //条件表达式求出x和y的最大值，用return 返回。
}
int main(void)
{
   int y;
   int a,b,c;
   printf("请输入a和b的值：\n");
   scanf("%d%d",&a,&b);
   c=yum(a,b);      //再次调用函数max，a、b为实参。
   printf("y=%d\n",c);  
   return 0;
}

---

数组作为函数参数传参

1.计算字符数组中字符串的长度

#include<stdio.h>
/*注意形参的形式，加[]，表明mystr是一个存放地址的变量，这个地址所在空间存放的是char型的数据*/
int MyStrlen(char mystr[])  
{
	int len=0;  //len存放字符串的长度。
	for(len=0; mystr[len]!='\0';len++); //用循环求串长，注意最后是空语句。
	return len;
}
int main(void)
{
char str[100];
gets(str);
printf("%d\n",MyStrlen(str)); //实参str的值所在地址存放char型数据。
return 0;
}

2.使得调用函数exchange后能把main函数中的两个数互换。

#include<stdio.h>
/*注意形参的形式，加[]，表明mystr是一个存放地址的变量，这个地址所在空间存放的是char型的数据*/
int exchange(int a[],int b[])  
{
	int temp;
	temp=a[0];
	a[0]=b[0];
	b[0]=temp;
}
int main(void)
{
int a=1;
int b=2;
printf("---调换前a，b的值：%d %d---\n",a,b); 
exchange(&a,&b);
printf("---调换前a，b的值：%d %d---\n",a,b); 
return 0;
}

3.写一个函数，用于对main函数中的元素类型为int型的一维数组进行排序，然后在main函数中进行调用，并输出排序后的数组各元素值。

#include<stdio.h>
/*注意形参的形式，加[]，表明mystr是一个存放地址的变量，这个地址所在空间存放的是char型的数据*/
int sort(int a[],int len)  
{
	int i,j,temp;
	for(i=0;i<len-1;i++)
	    for(j=0;j<len-1-i;j++)
	    {
	    	if(a[j]>a[j+1])
	    	{
	    		temp=a[j];
	    		a[j]=a[j+1];
	    		a[j+1]=temp;
			}
		}
}
int main(void)
{
  int arr[10]={45,65,34,35,25,39,54,59,16,48};
  int i;
  sort(arr,10);
  printf("---原来的数组---\n"); 
  for(i=0;i<10;i++)
      printf("%d ",arr[i]);
  putchar('\n');
  printf("---排序后的数组---\n"); 
  for(i=0;i<10;i++)
      printf("%d ",arr[i]);
  return 0;
}

---

二维数组作为函数参数

1.定义一个函数，功能是计算一个4*3的二维矩阵中所有数据的和，并在main函数中调用，假设这个矩阵中的数据都是int型。

#include<stdio.h>
int sum(int a[][3],int r,int l)
{
	int i,j;
	int sum;
	for(i=0;i<r;i++)
	    for(j=0;j<l;j++)
	        sum=sum+a[i][j];
	return sum;
}
int main()
{
  int Arr[4][3]={1,2,3,4,5,6,7,8,9,10,11,12};
  int su;
  su=sum(Arr,4,3);
  printf("数组的元素的和：%d",su);	                      
  return 0;
}

 

2.主调函数中定义有二维数组char str[5][10]; 看一下左边的实参数据类型和右边的形参数据类型是否一致？可作练习题思考。

1. str          char ch[][10]（元素类型是由10个char类型数据组成的一维数组类型）
2. &str[0][0]    char ch[]（元素类型是char类型）
3. str[1]        char ch[]（元素类型是char类型）
4. str           char ch（不是，ch的元素类型是char类型）
5. str[0]        char ch[]（元素类型是char类型）
6. str[0][0]      char ch（元素类型是char类型）
7. str           char ch[][8]（不是）

---

函数的嵌套调用

1.用函数的嵌套调用实现求四个值中的最大值。

#include<stdio.h>
int max1(int a,int b) 
{
	return a>b?a:b;
}
int max2(int a,int b,int c,int d)
{
	int m;
	m=max1(a,b);
	m=max1(m,c);
	m=max1(m,d);
	return m;
}
int main()
{
  int ma;
  ma=max2(1,2,3,4);
  printf("四个数中最大的值：%d",ma);	                      
  return 0;
}

 

2.两个班的成绩数据以两个一维数组形式存放。编程计算两个班的平均成绩。

#include<stdio.h>
float avgScore(float a[],int b) 
{   float sum=0,avg=0;
    int i;
    for(i=0;i<b;i++)
        sum=sum+a[i];
    avg=sum/b;
	return avg;
}

int main()
{
  float score1[5]={98.5,97,91.5,60,55}; 
  float score2[10]={67.5,89.5,99,69.5,77,89.5,76.5,54,60,99.5}; 
  printf("The average of class A is %-6.2f\n", avgScore (score1,5)); 
  printf("The average of class B is %-6.2f\n", avgScore (score2,10));	                      
  return 0;
}

---

函数的递归调用

  (1)划分子问题（解决的方法是一样的）

（2）解决子问题

（3）基础解

1.定义一个递归函数，返回n!的值。

#include<stdio.h>
int fac(int n)
{   
    if(1==n)
        return 1;//基础解 
    fac1=fac(n-1);//划分子问题 
    if(n!=1)
	    return fac1*n;//用子问题解决主问题 
}
int main()
{
  int n=4;
  printf("n阶乘的值是：%d\n", fac(n));                    
  return 0;
}

 

2.一个递归函数，求一个int型一维数组中元素的最大值。

#include<stdio.h>
int ArrayMax(int a[],int N)//求数组a中前N个元素的最大值
{
	int max;
	if (1==N) 
	    return a[0];     //基础解 
	max=ArrayMax(a,N-1);//划分子问题 
	if(max>a[N-1])  //在子问题解决的基础之上解决总问题。
		return max;
	else 
       return a[N-1];
}
int main()
{
  int a[4]={1,2,3,4};
  printf("数组中的最大值是：%d\n", ArrayMax(a,4));                    
  return 0;
}

3.

#include<stdio.h>
int add(int n)
{   
    int add1;
    if(1==n)
        return 1;//基础解 
    add1=add(n-1);//划分子问题 
    if(n!=1)
	    return add1+n;//用子问题解决主问题 
}
int main()
{
  int n=4;
  printf("前四项的和：%d\n", add(n));                    
  return 0;
}

3.Hanoi（汉诺）塔问题。古代有一个梵塔，塔内有3个座A,B,C。开始时A座上有64个盘子，盘子大小不等，大的在下，小的在上。有一个老和尚想把这64个盘子借助B座从A座移都到C座，但规定每次只允许移动一个盘，且在移动过程中3个座上都始终保持大盘在下，小盘在上。要求编程输出移动盘子的过程。如图7-9所示为Hanoi塔示意图。

#include<stdio.h>
//外部变量 
int a=0;
//主函数 
int main(){
 
    void hanoi(int i,char one,char two,char three);
    int n;
    printf("请输入盘子数：");
    scanf("%d",&n);
    hanoi(n,'A','B','C');
    printf("共需要%d步",a);
    return 0;
}
 
//递归加嵌套函数 
void hanoi(int i,char one,char two,char three){
    void move(int x,int y);
    if(i==1)
        move(one,three);
    if(i!=1)
    {
        hanoi(i-1,one,three,two);
        move(one,three);
        hanoi(i-1,two,one,three); 	
	}          
}
 
//步骤和步数 
void move(int x,int y){
    a++;
    printf("%c-->%c\n",x,y);
 
}