C语言函数的递归调用

于 2024-09-26 09:01:30 发布
阅读量689 收藏 10
点赞数 9
分类专栏： 把C语言捡起来 文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwsong52/article/details/142546061
版权

C语言函数的递归调用

简单的求和函数

  1. 定义一个函数求1到n的和，马上就想到用循环累加，这里用for循环，名称为sumf。
  2. 参数和返回值都采用无符号整型，防止累加的和超出范围，出现意外情况！！！
  3. 将无符号整型自定义为uint，其实就是一种重命名，加强代码的可读性。
    代码如下：
/* filename: sum.c */
#include <stdio.h>

/* compile : gcc sum.c -o sum
       run : ./sum            */

/**/
typedef unsigned int uint;

/**/
uint
sumf (uint n)
{
  uint tmp = 0;
  for (uint i = 1; i <= n; i++)
    tmp = tmp + i;
  return tmp;
}

/**/
void
test_sum (void)
{
  printf ("Sum 1 -   100: %u\n", sumf(100));
  printf ("Sum 1 - 10000: %u\n", sumf(10000));
}

/**/
int
main (int argc, char *argv[])
{
  test_sum ();
  return 0;
}
/* --(:-O-:)-- */

编译运行，结果在意料之中：

songvm@ubuntu:~/works/xdn$ gcc sum.c -o sum
songvm@ubuntu:~/works/xdn$ ./sum
Sum 1 -   100: 5050
Sum 1 - 10000: 50005000

将参数10000改为100000，编译运行，结果如下：

songvm@ubuntu:~/works/xdn$ gcc sum.c -o sum
songvm@ubuntu:~/works/xdn$ ./sum
Sum 1 -    100: 5050
Sum 1 - 100000: 705082704

明显是结果超出表示范围了，解决办不将无符号整型改为无符号长整型！

  1. 自定义无符号长整型ulong
  2. 将printf输出中的转意符改为%lu
    代码如下：
/* filename: sum.c */
#include <stdio.h>

/* compile : gcc sum.c -o sum
       run : ./sum            */

/**/
typedef unsigned long ulong;

/**/
ulong
sumf (ulong n)
{
  ulong tmp = 0;
  for (ulong i = 1; i <= n; i++)
    tmp = tmp + i;
  return tmp;
}

/**/
void
test_sum (void)
{
  printf ("Sum 1 -    100: %lu\n", sumf(100));
  printf ("Sum 1 - 100000: %lu\n", sumf(100000));
}

/**/
int
main (int argc, char *argv[])
{
  test_sum ();
  return 0;
}
/* --(:-O-:)-- */

编译运行，结果如预期：

songvm@ubuntu:~/works/xdn$ gcc sum.c -o sum
songvm@ubuntu:~/works/xdn$ ./sum
Sum 1 -    100: 5050
Sum 1 - 100000: 5000050000

用递归的方法写一个求和函数

  1. 参数还可以更大，这里就不做极限测试了，但要考虑到超出取值范围这种情况的出现！！！
  2. 不用循环也可以实现求和，就是用递归的方法！！！
  3. 说白了，递归就是函数调用自己本身，sum中再次调用sum，执行下去就会无限循环，所以一定要设置一个条件让函数跳出执行，返回一个值，就是当n等于1时返回1；
  4. 当再次调用sum时，参数n都减1，直到n等于1返回，这样就达到了循环的效果。
    代码如下：
/* filename: sum.c */
#include <stdio.h>

/* compile : gcc sum.c -o sum
       run : ./sum            */

/**/
typedef unsigned long ulong;

/**/
ulong
sumf (ulong n)
{
  ulong tmp = 0;
  for (ulong i = 1; i <= n; i++)
    tmp = tmp + i;
  return tmp;
}

/**/
ulong
sum (ulong n)
{
  if (n == 1) return 1;
  return n + sum (n - 1);
}

/**/
void
test_sum (void)
{
  printf ("Use for method \n");
  printf ("Sum 1 -    100: %lu\n", sumf(100));
  printf ("Sum 1 - 100000: %lu\n", sumf(100000));
  printf ("--------------------\n");
  printf ("Use recursion method \n");
  printf ("Sum 1 -    100: %lu\n", sum(100));
  printf ("Sum 1 - 100000: %lu\n", sum(100000));
  printf ("--------------------\n");
}

/**/
int
main (int argc, char *argv[])
{
  test_sum ();
  return 0;
}
/* --(:-O-:)-- */

编译运行，结果如下：

songvm@ubuntu:~/works/xdn$ gcc sum.c -o sum
songvm@ubuntu:~/works/xdn$ ./sum
Use for method 
Sum 1 -    100: 5050
Sum 1 - 100000: 5000050000
--------------------
Use recursion method 
Sum 1 -    100: 5050
Sum 1 - 100000: 5000050000
--------------------

结果一样，方法不同

  1. 理解递归对编写函数代码来说非常重要，尤其是在数据结构和算法方面！！！
  2. 上面的sum函数使用了简单的递归调用，可以看出参数n越大，返回的表达式就越长，占用的程序运行资源就越多，对于递归次数较少的的应用来说是可行的。
  3. 如何改变表达式越来越长的这种情况呢，就是采用尾递归调用，使表达式的长度不变！！！
  4. 定义函数sumt，除原有参数n外，再加一个参数s，来保存累加结果，这个累加结果初始值定为1，当n等于1时直接返回s，否则每次调用s都要加n来继续累加，n则减1继续调用。
    代码如下：
/* filename: sum.c */
#include <stdio.h>

/* compile : gcc sum.c -o sum
       run : ./sum            */

/**/
typedef unsigned long ulong;

/**/
ulong
sumf (ulong n)
{
  ulong tmp = 0;
  for (ulong i = 1; i <= n; i++)
    tmp = tmp + i;
  return tmp;
}

/**/
ulong
sum (ulong n)
{
  if (n == 1) return 1;
  return n + sum (n - 1);
}

/**/
ulong
sumt (ulong n, ulong s)
{
  if (n == 1) return s;
  return sumt (n - 1, s + n);
}

/**/
void
test_sum (void)
{
  printf ("Use for method \n");
  printf ("Sum 1 -    100: %lu\n", sumf(100));
  printf ("Sum 1 - 100000: %lu\n", sumf(100000));
  printf ("--------------------\n");
  printf ("Use recursion method \n");
  printf ("Sum 1 -    100: %lu\n", sum(100));
  printf ("Sum 1 - 100000: %lu\n", sum(100000));
  printf ("--------------------\n");
  printf ("Use tail recursion method \n");
  printf ("Sum 1 -    100: %lu\n", sumt(100, 1));
  printf ("Sum 1 - 100000: %lu\n", sumt(100000, 1));
  printf ("--------------------\n");
}

/**/
int
main (int argc, char *argv[])
{
  test_sum ();
  return 0;
}
/* --(:-O-:)-- */

编译运行，结果如预期:

songvm@ubuntu:~/works/xdn$ gcc sum.c -o sum
songvm@ubuntu:~/works/xdn$ ./sum
Use for method 
Sum 1 -    100: 5050
Sum 1 - 100000: 5000050000
--------------------
Use recursion method 
Sum 1 -    100: 5050
Sum 1 - 100000: 5000050000
--------------------
Use tail recursion method 
Sum 1 -    100: 5050
Sum 1 - 100000: 5000050000
--------------------

菲波那契数列

  1. 数列中从第三项开始，每一项都是前两项之和。
  2. 即F(n) = F(n-1) + F(n-2)，其中n >= 2
  3. 此处以1和1作为初始值： 1 1 2 3 5 8 13 21 …
  4. 定义递归函数fib和上面的sum雷同，一个参数n，直接返回fib(n-1)与fib(n-2)的和。
  5. 定义尾递归函数fibt，在fib的基础上加三个参数，rsa对应n-1的值，rsb对应n-2的值，n不变，idx每次加1，rsb赋值给rsa，rsb赋值rsa与rsb的和（即fib(n-1)+fib(n-2)），当idx等于n时，返回rsb的值。

代码如下：

/* filename: fib.c */
#include <stdio.h>

/* compile : gcc fib.c -o fib
       run : ./fib           */

/**/
typedef unsigned int  uint;
typedef unsigned long ulong;

/* recursion call */
ulong
fib (ulong n)
{
  if (n == 1 || n == 2) return 1;
  return fib (n - 1) + fib (n - 2);
}

/* tail recursion call */
ulong
fibt (ulong n, ulong rsa, ulong rsb, ulong idx)
{
  if (n == 1 || n == 2) return 1;
  if (n == idx) return rsb;
  return fibt (n, rsb, rsa + rsb, idx + 1);
}

/**/
void
test_fib (void)
{
  for (int i = 1; i < 20; i++)
    printf ("%lu ", fib (i));
  printf ("\n--------------------\n");

  for (int i = 1; i < 20; i++)
    printf ("%lu ", fibt (i, 1, 1, 2));
  printf ("\n--------------------\n");
}

/**/
int
main (int argc, char *argv[])
{
  test_fib ();
  return 0;
}
/* --(:-O-:)-- */

编译运行，菲波那契数列前20项结果如下：

songvm@ubuntu:~/works/xdn$ gcc fib.c -o fib
songvm@ubuntu:~/works/xdn$ ./fib
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 
--------------------
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 
--------------------

能看出尾递归还是有效率的

  1. 因为fib函数当n大于2时每次递归调用时都调用2次，而fibt函数每次递归调用只调用一次！！！
  2. 可以加个计数变量看一下都调用了多少次！！！
  3. 在函数外加一个静态变量count，初始值赋为0，在函数的第一行令count自增，这样在函数调用结束后输出count，查看函数调用次数。
  4. 再次计数时别忘了重置count为0！！！
    代码如下：
/* filename: fib.c */
#include <stdio.h>

/* compile : gcc fib.c -o fib
       run : ./fib           */

/**/
typedef unsigned int  uint;
typedef unsigned long ulong;

/* define counter */
static int count = 0;

/* recursion call */
ulong
fib (ulong n)
{
  count++;
  if (n == 1 || n == 2) return 1;
  return fib (n - 1) + fib (n - 2);
}

/* tail recursion call */
ulong
fibt (ulong n, ulong rsa, ulong rsb, ulong idx)
{
  count++;
  if (n == 1 || n == 2) return 1;
  if (n == idx) return rsb;
  return fibt (n, rsb, rsa + rsb, idx + 1);
}

/**/
void
test_fib (void)
{
  for (int i = 1; i < 20; i++)
    printf ("%lu ", fib (i));
  printf ("\nCount: %d\n--------------------\n", count);

  count = 0;
  for (int i = 1; i < 20; i++)
    printf ("%lu ", fibt (i, 1, 1, 2));
  printf ("\nCount: %d\n--------------------\n", count);
}

/**/
int
main (int argc, char *argv[])
{
  test_fib ();
  return 0;
}
/* --(:-O-:)-- */

编译运行，结果如下：

songvm@ubuntu:~/works/xdn$ gcc fib.c -o fib
songvm@ubuntu:~/works/xdn$ ./fib
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 
Count: 21871
--------------------
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 
Count: 172
--------------------

仅求前20项，fib函数就调用了21871次，而fibt只调用了172次，尾递归效率之高，出乎意料之外！！！

字符串输出函数

常用printf来输出字符串，putchar只能输出单个字符，可以考虑设计函数来递归调用通过putchar输出字符串（当然循环也可以）。

  1. 字符串以’\0’结尾，设计一个函数out_charactor递归调用，参数为字符指针，当遇到’\0’时输出换行符并退出，否则输出当前字符。
  2. 做为参数的字符指针每次自增，指向下一个字符，继续调用out_charactor。
  3. 写一个测试函数，定义两个字符串，一个是简单的hello world!，另一个是全部为0的字符数组。
  4. 向数组循环填入26个大写字母，填充10次。
  5. 最后分别输出这两个字符串！！！
    代码如下：
/* filename: outchar.c */
#include <stdio.h>

/* recursion call */
void
out_charactor (char *pc)
{
  if (*pc == '\0')
    {
      putchar ('\n');
      return;
    }
  else
    {
      putchar (*pc);
      pc++;
      out_charactor (pc);
    }
}

/**/
void
test_out_charactor (void)
{
  char *str = "Hello world!";
  char buf[261] = { 0 };

  for (int i = 0; i < 10; i++)
    for (int j = 0; j < 26; j++)
      buf[i*26 + j] = 'A' + j;

  out_charactor (str);
  out_charactor (buf);
}

/**/
int
main (int argc, char *argv[])
{
  test_out_charactor ();
  return 0;
}
/* --(:-)-- */

编译运行，结果如下：

songvm@ubuntu:~/works/xdn$ gcc -g outchar.c -o outchar
songvm@ubuntu:~/works/xdn$ ./outchar
Hello world!
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ

怎么样，会玩递归了吧？下一步研究一下求质数的方法！

麻瓜老宋
关注
专栏目录
c语言递归函数作用,C语言函数的递归和调用实例分析
weixin_34712106的博客
05-16 3152
一、基本内容：C语言中的函数可以递归调用，即：可以直接(简单递归)或间接(间接递归)地自己调自己。要点：1、C语言函数可以递归调用。2、可以通过直接或间接两种方式调用。目前只讨论直接递归调用。二、递归条件采用递归方法来解决问题，必须符合以下三个条件：1、可以把要解决的问题转化为一个新问题，而这个新的问题的解决方法仍与原来的解决方法相同，只是所处理的对象有规律地递增或递减。说明：解决问题的方法相同，...
C语言函数的递归和调用实例分析
09-05
在C语言中，函数的递归调用是一种强大的编程技巧，它允许一个函数在其定义内部调用自身。递归调用的主要特点是每次调用都会创建一个新的函数执行上下文，使得每次调用都有独立的变量空间。这种技术在解决某些特定...
C语言函数递归调用
qq_48516121的博客
09-17 4031
C语言函数递归调用
C语言函数递归调用实验报告,C语言函数的递归和调用实例分析
weixin_33309048的博客
05-18 1079
一、基本内容：C语言中的函数可以递归调用，即：可以直接(简单递归)或间接(间接递归)地自己调自己。要点：1、C语言函数可以递归调用。2、可以通过直接或间接两种方式调用。目前只讨论直接递归调用。二、递归条件采用递归方法来解决问题，必须符合以下三个条件：1、可以把要解决的问题转化为一个新问题，而这个新的问题的解决方法仍与原来的解决方法相同，只是所处理的对象有规律地递增或递减。说明：解决问题的方法相同，...
C语言函数递归调用实验报告,c语言实验报告9函数的嵌套调用及递归调用、数组作为函数参数.doc...
weixin_29660305的博客
05-18 727
c语言实验报告9函数的嵌套调用及递归调用、数组作为函数参数C语言实验报告(一)一、实验目的掌握C语言中，基本的输入输出函数的使用方法。掌握printf中转义字符’\t’，’\n’的用法。掌握赋值语句的用法。掌握算术表达式、赋值表达式的计算。掌握数学函数的使用。二、实验内容从键盘输入一个6位整数，输出该整数的后三位数。例如，输入：342471 输出则为：471·程序代码：# include "s...
C语言 函数的递归调用
NuYoaH502329的博客
11-17 3754
C语言 函数的递归调用 有5个学生坐在一起，问第5个学生多少岁，他说比第4个学生大2岁。问第4个学生多少岁，他说比第3个学生大2岁。问第3个学生多少岁，他说比第2个学生大2岁。问第2个学生多少岁，他说比第1个学生大2岁。最后问第1个学生，他说他是10岁。求第5个学生多少岁。 用递归方法求n!。
C语言函数之递归调用
qq_56870066的博客
07-31 5678
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言函数的调用函数的递归调用中间递归函数多层递归函数递归函数的最大缺陷二、使用步骤1.引入库2.读入数据总结 前言 函数是学习C语言的最重要知识点之一，要学好这门编程语言，那么函数当然是至关重要的 提示：以下是本篇文章正文内容，下面案例可供参考 函数的调用 函数的递归调用 中间递归函数 多层递归函数 递归函数的最大缺陷 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引
【c语言】函数递归调用
努力让自己的能力配得上梦想.
05-04 1291
​ c语言系列专栏：c语言之路重点知识整合 目录 一、递归基本概念的理解 二、递归算法的基本模式 一些习题实例： 一、递归基本概念的理解 函数递归就是函数在其内部再次调用自己的过程。 二、递归算法的基本模式 递归算法的基本模式：终止条件，递推公式 例如：计算阶乘5*4*3*2*1= 阶乘计算到1，终止条件为n==1 阶乘计算为前一个数累乘到后一个数，递推公式为n*fun01(n-1) 一定要有终止条件！！因为没有终止条件会一直循环，过度递归可能会导致栈 ​
函数的递归调用，C语言函数递归调用完全攻略
GJINW的博客
05-07 988
** 文章地址 ** 下面给大家编写几个程序，列举几个例子，主要通过例子让大家对递归有一个了解。 1) 用递归求 n 的阶乘。 n！也可以写成 n×(n–1)！，这就是递归公式。 # include <stdio.h> long Factorial(int n); //函数声明 int main(void) { int n; printf("请输入n的值:"); ...
C语言函数递归经典题目适合小白
weixin_73376720的博客
01-02 1199
通过以上的例子，大家对函数的递归有了一个较为模糊的印象，ChatGPT这样定义它——递归（Recursion）是指在解决问题的过程中，通过调用自己来解决问题的一种编程或数学技术。在计算机科学中，递归是通过将问题分解为更小、相似的子问题，并通过对这些子问题的解决来解决原始问题的方法。我的理解是在子函数中调用它本身，然后通过将复杂问题分解为相似的简单问题来解决。
C语言函数递归简单例举
qq_73616760的博客
10-15 1942
第一题，题目是输入1234，打印出来1 2 3 4，未学习函数递归时，简单的做法是给每一位定义一个变量，然后用取整取余求出这四个数字并将其付给四个已定义的变量。但若题目要求不可使用strlen，并且也不可以引入新的变量，该如何做呢？第二题，题目是求出数组中的元素个数。这道题，用库函数strlen可以一步求出，今天，用函数递归简单一步就可搞定。废话不多说，上干货。后续有其他递归题及相关游戏会继续分享。
C语言函数递归调用学习教案.pptx
09-30
C语言函数递归调用学习教案 C语言函数递归调用是指在调用一个函数的过程中，出现直接或间接地调用该函数本身的现象。递归调用可以用来解决一些复杂的问题，但也需要注意递归调用的深度和性能问题。 函数的递归...
C语言函数递归调用PPT课件.pptx
10-10
C语言函数递归调用PPT课件 函数的递归调用是指在调用一个函数的过程中，出现直接或间接地调用该函数本身的现象。例如，函数f调用函数f1，函数f1调用函数f2，函数f2调用函数f1，这样就形成了一个递归调用链。 递归...
C语言函数递归调用PPT学习教案.pptx
10-01
以下是关于C语言函数递归调用的详细讲解： 1. **递归的基本概念**： 函数递归调用是指在一个函数内部调用自身，形成一个调用链。这种调用方式的关键在于必须有一个明确的停止条件，否则会导致无限递归，最终导致...
C语言读取一行字符_只需要看第四条
kuilaurence的博客
09-21 585
推荐使用fgets()来读取一行字符，因为它可以避免缓冲区溢出问题，并且能够控制最大读取字符数。尽量避免使用gets()，因为它不安全，容易导致程序崩溃。通过scanf()和手动循环的方式也可以实现读取一行字符，但需要小心处理输入长度。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 477
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
【优选算法】（第一篇）
最新发布
weixin_73861555的博客
09-25 796
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 353
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
C语言题目之单身狗2
something for nothing的博客
09-22 492
c语言题目之找单身狗2：在一堆数中找到两个只出现过一次数的数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值