函数2

时间：2022-12-30 15:09:40

前言：

上一篇函数1我们已将了解了函数的大部分知识，接下来我们继续学习剩下的知识

1.函数的声明和定义

1.1 函数声明：

  1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
  2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
  3. 函数的声明一般要放在头文件中的。

6.2 函数定义：

函数的定义是指函数的具体实现，交待函数的功能实现。

test.h的内容
放置函数的声明

#ifndef __TEST_H__
#define __TEST_H__
//函数的声明
int Add(int x, int y);
#endif //__TEST_H__

test.c的内容

放置函数的实现

#include "test.h"
//函数Add的实现
int Add(int x, int y)
{
return x+y;
}

这种分文件的书写形式，在三字棋和扫雷的时候，分模块来写。（后面详细讲解）

2. 函数递归

2.1 什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。

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

2.2 递归的两个必要条件

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

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

2.2.1 练习1：（画图讲解）

接受一个整型值（无符号），按照顺序打印它的每一位。

例如：

输入：1234，输出 1 2 3 4.

函数2

函数2

递归在c语言中是一个非常复杂的概念，但是递归的作用有很大，本题题意参考图解，大致意思是print函数的自我调用

参考代码：

void print(int n)
{
if(n>9)
 {
print(n/10);
 }
printf("%d ", n%10);
}
int main()
{
int num = 1234;
print(num);
return 0;
}

函数2

2.2.2 练习2

编写函数不允许创建临时变量，求字符串的长度。

函数2

//编写函数不允许创建临时变量，求字符串的长度。
//递归的方法
// my_strlen("bit")
//1+my_strlen("it")
//1+1+my_strlen("t")
//1+1+1+my_strlen("")
// 1+1+1+0
// 3
int Strlen(const char* str)
{
if (*str == '\0')
return 0;
else
return 1 + Strlen(str + 1);
}
int main()
{
char* p = "bit";
int len = Strlen(p);
printf("%d\n", len);
return 0;
}

函数2

3.递归与迭代

3.1 练习3：

求n的阶乘。（不考虑溢出）

参考代码：

每调用一次fac2(n - 1)函数，n的值都会减一，直到n=1时不在调用然后层层函数开始返回

//求n的阶乘，递归的方法
int fac2(int n)
{
if (n <= 1)
  {
return 1;
  }
else
  {
return n * fac2(n - 1);
  }
}
int main()
{
int a = 0;
scanf("%d", &a);
int ret = fac2(a);
printf("%d\n", ret);
return 0;
}

函数2

3.2 练习4：

求第n个斐波那契数。（不考虑溢出）

参考代码：

递归求斐波那契数列：1 1 2 3 5 8 13 21 34 55·····即后一个数是前两个数之和

//递归求斐波那契数列：1 1 2 3 5 8 13 21 34 55·····即后一个数是前两个数之和
int fib(int n)
{
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret=fib(n);
printf("%d\n", ret);
return 0;
}

函数2

但是我们发现有问题；

在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。 使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？

我们发现 fib 函数在调用的过程中很多计算其实在一直重复。

如果我们把代码修改一下：

int count = 0;//全局变量
int fib(int n)
{
if(n == 3)
count++;
if (n <= 2)         
return 1;
else
return fib(n - 1) + fib(n - 2);
}

最后我们输出看看count，是一个很大很大的值。

那我们如何改进呢？

在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出） 这样的信息。 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一 直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。

那如何解决上述的问题：

  1. 将递归改写成非递归。
  2. 使用static对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问

比如，下面代码就采用了，非递归的方式来实现：

//求n的阶乘
int factorial(int n)
{
int result = 1;
while (n > 1)
       {
result *= n ;
n -= 1;
       }
return result;
}
//求第n个斐波那契数
int fib(int n)
{
int result;
int pre_result;
int next_older_result;
result = pre_result = 1;
while (n > 2)
     {
n -= 1;
next_older_result = pre_result;
pre_result = result;
result = pre_result + next_older_result;
     }
return result;
}

提示：

  1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
  2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
  3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开
    销。

4.函数递归的几个经典题目：

4.1 汉诺塔问题

感兴趣的可以研究一下

//汉诺塔
void hannuo(int n, char a, char b, char c)//char a, char b, char c三个只代表形参并非真是值，而实参是传递过来的是真实值
{                 
if (n == 1)//如果只有一个盘子，直接把盘子从a->c
  {
printf(" %c->%c ", a, c);
  }
else//如果有多个盘子
  {
hannuo(n - 1, a, c, b);//先把n-1个盘子从a通过c移动到b
printf(" %c->%c ", a, c);//这是n-1个盘子已经挪到了b，只需要把a上剩的盘子移动到c上即可
hannuo(n - 1, b, a, c);//然后再将b上的盘子通过a移动到c上
  }
}
int main()
{
int n = 0;
scanf("%d", &n);
hannuo(n,'a','b','c');//这些都是实参
return 0;
}

函数2

留言：

欢迎留言交流，喜欢就点赞支持一下吧







标签：

相关文章