C语言中递归的分析及应用
c语言递归实现1到n的和
C语言递归实现1到n的和简介递归是一种常用的编程技巧，它通过函数自身的调用来解决问题。
在C语言中，递归可以用于实现各种算法和数据结构。
本文将介绍如何使用递归来计算1到n的和，通过详细的代码解释和示例演示，帮助读者理解递归的原理和使用方法。
递归的基本原理递归是一种通过函数自身的调用来解决问题的方法。
在递归中，函数会不断地调用自身，直到满足某个终止条件才停止调用。
递归可以分为两个阶段：递归调用和递归返回。
递归调用是指函数在执行过程中，自己调用自己。
在每次递归调用时，函数会使用不同的参数值，以便在每次调用中解决不同的子问题。
递归调用将问题分解为更小的子问题，直到达到终止条件。
递归返回是指函数在满足终止条件后，通过返回值将结果传递给上一层调用。
通过不断返回结果，最终得到整个问题的解。
递归实现1到n的和下面是使用递归实现1到n的和的C语言代码：#include <stdio.h>int sum(int n) {if (n == 1) {return 1;} else {return n + sum(n - 1);}}int main() {int n;printf("请输入一个正整数n：");scanf("%d", &n);printf("1到%d的和为：%d\n", n, sum(n));return 0;}在上面的代码中，我们定义了一个名为sum的递归函数，它接受一个整数参数n，并返回1到n的和。
在函数内部，我们使用了一个if-else语句来判断是否满足终止条件。
当n等于1时，递归终止，直接返回1。
否则，递归调用sum函数，并将n减1作为参数传入，然后将递归调用的结果与n相加返回。
在main函数中，我们首先从用户输入获取一个正整数n，然后调用sum函数计算1到n的和，并将结果打印出来。
递归的执行过程为了更好地理解递归的执行过程，我们以计算1到5的和为例，来逐步分析递归的调用和返回过程。
《c语言递归算法》课件
C语言递归算法是一种强大的编程技巧，通过函数自身调用实现问题的解决。 本课件将介绍递归算法的概念、实现方式、应用场景、优缺点以及与循环的 区别，同时还会通过案例演示帮助理解。
什么是递归算法？
基本概念
递归是指函数直接或间接地调用自身的过程。
递归特点
递归算法需要有基准条件和递推关系，用于结 束递归和推进递归过程。
递归算法的实现方式
递归函数
通过函数自身调用实现递归，需要定义递归函数和 递归终止条件。
递归流程图
通过流程图展示递归算法的执行过程，帮助理解递 归逻辑。
递归算法的应用场景
1 数学计算
递归算法可以用于解决数学问题，如斐波那契数列、阶乘等。
2 数据结构
递归算法在树、图等数据结构的遍历和搜索中有广泛应用。
递归算法的优点和缺点
优点
• 简化问题复杂度 • 代码结构清晰
缺点
• 执行效率较低 • 内存占用较高
递归算法与循环的区别
1
循环
2
迭代操作
3
递归
函数自身调用
区别
递归更直观，但消耗资源较多；循环更 高效，但代码可读性差。
递归算法的注意事项
1 递归终止条件
保证递归过程能够结束，否则可能导致死循 环。
2 堆栈溢出
过深的递归调用可能导致堆栈溢出，需要注 意递归深度。
递归算法的案例演示
斐波那契数列
通过递归实现斐波那契数列的计算。
二叉树遍历
通过递归遍历二叉树的各种方式。
C语言中递归函数的教学方法
C语言中递归函数的教学方法在教授C语言中的递归函数时，我们可以采用以下教学方法：一、引入递归概念和原理首先，我们需要向学生们解释什么是递归以及递归函数的原理。
递归是指一个函数直接或间接地调用自己的过程。
通过一个简单的例子，如计算阶乘，来引导学生理解递归的概念。
然后，解释递归函数的工作原理，即每一次递归调用都会将问题分解为规模更小的子问题，直到达到基本情况（递归停止条件），然后依次返回结果。
二、示范递归调用过程接着，我们可以使用一个实际的例子来示范递归调用的过程，如计算斐波那契数列。
我们可以用具体的数值来展示函数调用栈，以及每次递归调用会如何返回结果。
这样可以帮助学生更直观地理解递归的工作过程。
三、教授递归函数的编写与调用经过前两步的引导，学生们应该可以理解递归函数的原理。
然后，我们可以教授学生如何编写和调用递归函数。
这包括函数的定义、终止条件的判断和处理、递归调用的方法等。
我们可以使用一些简单的示例，如计算阶乘、斐波那契数列、二叉树的遍历等，来让学生们亲自编写递归函数并运行。
同时，我们需要向学生们强调递归函数的设计的重要性，以避免无限递归导致的程序崩溃。
四、递归函数中的陷阱与优化递归函数在编写过程中可能会遇到一些陷阱，例如无限递归、堆栈溢出等问题。
我们需要向学生们提示这些陷阱，并讲解如何避免或解决这些问题。
此外，我们还可以介绍一些递归函数的优化技巧，例如尾递归优化、缓存中间结果、剪枝等，以提高递归函数的效率和性能。
五、扩展应用与实际案例最后，我们可以引导学生们探索更多的递归应用和实际案例。
例如，图的深度优先、回溯法、分治算法等都是基于递归的常见算法。
我们可以通过这些实际案例来巩固学生们对递归函数的理解和运用能力。
同时，我们也可以鼓励学生们尝试自己设计和实现基于递归的算法，以提升他们的创造力和解决问题的能力。
六、练习和总结在教学结束时，我们可以给学生们一些练习题来巩固他们对递归函数的理解和编写能力。
正整数分解成几个正整数相加 c语言递归实现
正整数分解成几个正整数相加 c语言递归实现1. 引言在数学中，将一个正整数分解成几个正整数相加的问题一直备受关注。
这个问题不仅在数论中有着重要的意义，也在计算机科学中有着广泛的应用。
本文将通过 c 语言递归实现，探讨如何将一个正整数分解成几个正整数相加的具体方法和实现过程。
2. 问题分析给定一个正整数 n，我们希望将它分解成几个正整数相加，即 n = a1 + a2 + ... + ak，其中 a1, a2, ..., ak 均为正整数，并且 k 至少为 2。
我们的目标是找到所有满足条件的 a1, a2, ..., ak 的组合。
这个问题涉及到组合数学和算法设计，我们将通过 c 语言递归实现来解决这个问题。
3. c 语言递归实现我们需要设计一个递归函数来实现正整数分解的过程。
我们定义一个函数 dpose，它接收三个参数：n 表示待分解的正整数，start 表示当前递归的起始数值，path 表示当前已经找到的分解路径。
具体的 c 语言实现如下所示：```c#include <stdio.h>void dpose(int n, int start, int path[], int idx) { if (n == 0) {printf("%d = ", n);for (int i = 0; i < idx; i++) {if (i > 0) {printf(" + ");}printf("%d", path[i]);}printf("\n");} else {for (int i = start; i <= n; i++) {path[idx] = i;dpose(n - i, i, path, idx + 1);}}}int main() {int n;printf("请输入一个正整数：");scanf("%d", &n);int path[n];dpose(n, 1, path, 0);return 0;}```在这段 c 语言代码中，我们首先定义了 dpose 函数来实现正整数分解的递归过程。
c语言递归求素数
c语言递归求素数在计算机编程中，递归是一种重要的编程技巧，它可以在函数体内调用自身来解决问题。
本文将为大家介绍如何使用C语言中的递归算法来判断一个数是否为素数。
什么是素数呢？素数又称质数，是指除了1和它本身之外没有其他约数的自然数。
比如2、3、5、7等都是素数。
判断一个数是否为素数通常有多种方法，其中一个比较简单和常用的方法就是试除法。
我们可以使用递归算法来实现试除法判断一个数是否为素数。
首先，我们需要一个辅助函数来判断一个数n是否能被另一个数i整除，如果能整除，则说明n不是素数；如果不能整除，则说明n可能是素数。
下面是一个示例代码：```cinclude <stdio.h>int isPrime(int n, int i) {if (i == 1) {return 1;}if (n % i == 0) {return 0;}return isPrime(n, i - 1);}int main() {int n;printf("请输入一个自然数："); scanf("%d", &n);if (isPrime(n, n - 1)) {printf("%d是素数\n", n); } else {printf("%d不是素数\n", n); }return 0;}```以上代码中，`isPrime`函数接收两个参数，分别是要判断的数n和当前的除数i。
函数首先判断是否已经试除到1，如果是则返回1，表示n是素数。
如果n能被i整除，则返回0，表示n不是素数。
否则，递归地调用`isPrime`函数，将i减1，继续试除。
在主函数中，我们首先接收一个自然数n，并调用`isPrime`函数进行判断。
如果返回值为1，则说明n是素数，否则不是素数。
通过这个简单的递归算法，我们可以判断一个数是否为素数。
当然，递归算法也有一些缺点，在处理大数时可能会导致栈溢出，所以在实际应用中，我们可能需要使用其他更高效的算法来判断素数。
基于递归法在C语言项目实践中的探索和应用
Ｔｈ ｅ Ｅｘ ｐ ｌ ｏ ｒ ａ ｔ ｉ ｏ ｎ ａ ｎ ｄ Ａｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｏ ｆ Ｒｅ ｃ ｕ ｒ ｓ ｉ ｖ ｅ
Ｍｅ ｔ ｈ ｏ ｄ ｉ ｎ Ｃ Ｌ ａ ｎ ｇ ｕ ａ ｇ ｅ Ｐ ｒ ｏ ｊ ｅ ｃ ｔ Ｐ ｒ ａ ｃ ｔ ｉ ｃ ｅ
ｇ ｏ ｒ ｉ ｔ ｈ ｍ ｓ ａ ｎ ｄ ｄ ｉ ｆ ｉ ｆ ｃ ｕ ｌ ｔ ｔ ｏ ｕ ｎ ｄ ｅ ｍ ｔ ａ ｎ ｄ ， ｂ ｕ ｔ ｂ ｅ ｃ ａ ｕ ｓ ｅ ｏ ｆ ｉ ｔ ｓ ｐ ｏ ｗ ｅ ｆ ｒ ｕ ｌ ｆ ｅ ａ ｔ ｕ ｒ ｅ ｓ ， ｗ ｈ ｅ ｎ ｍ ａ ｋ ｉ ｎ ｇ ｔ ｈ ｅ ｐ ｒ ｏ ｊ ｅ ｃ ｔ ｐ ｒ ａ ｃ ｔ ｉ ｃ ｅ ａ ｎ ｄ ａ ｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｓ
递 归 是 一 种 算 法 ．而 算 法 是 解 决 问 题 的 方 法 。 应 用 递 归 法 解 决 问 题 的 时 候 ．对 问 题 按 照 一 定 的要 求 进 行 分 解 ，形 成
Ｓ Ｔ Ｕ Ｄ Ｙ ０ Ｆ Ｃ Ｏ Ｍ Ｐ Ｕ Ｔ Ｅ Ｒ Ａ Ｐ Ｐ Ｌ Ｉ Ｃ Ａ Ｔ １ ０ Ｎ Ｉ Ｎ Ｅ Ｄ Ｕ Ｃ Ａ ｎ ０ Ｎ
计算机应 用教 学研 究
基于递归法在 Ｃ语言项 目实践 中的探 索和应 用
黄春 艳
（ 广东省韶关市 中等职业技术学校 ，广东 韶关 ５ １ ２ ０ ２ ３ ） 摘 要 ：在 用 ｃ语言进行项 目实践的时候 经常会遇到算法的设计 问题 ，算法设计的好坏 以及效率的 高低 直接影响和
ｏ ｔ ｆ ｅ ｎ ｕ ｓ ｅ ａ ｒ ｅ ｃ ｕ ｒ ｓ ｉ ｖ ｅ ａ ｌ ｇ ｏ ｉ ｒ ｔ ｈ ｍ ｔ ｏ ｓ ｏ ｌ ｖ ｅ ｔ ｈ ｅ ｐ ｒ ｏ ｂ ｌ ｅ ｍ． Ｔ ｈ ｉ ｓ ｐ ａ ｐ ｅ ｒ ａ ｔ ｔ ｅ ｍｐ ｔ ｓ ｔ ｏ ｓ ｏ ｌ ｖ ｉ ｎ ｇ ｐ ｒ ｏ ｃ ｅ ｓ ｓ ｂ ｙ ｄ ｅ ｔ ａ ｉ ｌ ｉ ｎ ｇ ｓ ｅ ｖ ｅ ｒ ａ ｌ ｔ ｙ ｐ ｉ ｃ ｌ ａ ｐ ｒ ｏ —
c语言递归判断回文数
c语言递归判断回文数C语言是一种广泛应用于计算机编程的高级编程语言，其灵活性和强大的功能使其成为开发人员的首选。
在C语言中，递归是一种常见的编程技巧，可以用来解决各种问题。
本文将以C语言递归判断回文数为主题，介绍如何使用递归算法来判断一个数是否是回文数。
我们需要明确回文数的定义。
回文数是指正着读和倒着读都一样的数，例如121、12321等。
判断一个数是否是回文数的方法有很多种，其中一种简单而有效的方法是使用递归算法。
在C语言中，递归是一种函数调用自身的方法。
通过将问题分解为更小的子问题，递归能够简化复杂的计算过程。
对于判断回文数来说，我们可以将问题分解为判断首尾两个数字是否相等，并将剩余的数字作为子问题进行递归判断。
下面是使用递归算法来判断一个数是否是回文数的C语言代码：```c#include <stdio.h>int isPalindrome(int num, int temp) {// 递归的终止条件if (num == 0) {return temp;}// 提取最后一位数字temp = temp * 10 + num % 10;// 递归调用，判断剩余的数字是否是回文数return isPalindrome(num / 10, temp);}int main() {int num;printf("请输入一个整数：");scanf("%d", &num);int result = isPalindrome(num, 0);if (result == num) {printf("%d是回文数\n", num);} else {printf("%d不是回文数\n", num);}return 0;}```在上面的代码中，我们定义了一个名为`isPalindrome`的递归函数，该函数接受两个参数：`num`和`temp`。
c语言递归求子树各奇数结点之和
C语言是一种广泛应用的编程语言，其强大的功能和灵活性使得它成为许多程序员和软件工程师的首选。
在C语言中，递归是一个重要的概念，它允许程序通过调用自身来解决问题。
本文将探讨如何使用C 语言的递归功能来求解树结构中子树内的各奇数节点之和。
1. 树的定义和结构在计算机科学中，树是一种非线性数据结构，它由节点（node）和边（edge）组成。
每个节点都有零个或多个子节点，并且从根节点（root）到任意节点都有唯一的路径。
树的一个重要特性是它的递归性质，即树本身可以递归地定义为节点和子树的集合。
在C语言中，通常使用结构体（struct）来表示树的节点，例如：```cstruct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};```这个结构体表示了一个树节点，其中val表示节点的值，left和right 分别表示左子节点和右子节点。
2. 递归函数的设计为了求解子树内的各奇数节点之和，我们可以设计一个递归函数来遍历整棵树，并在遍历过程中对节点的值进行判断和累加。
下面是一个简单的C语言函数，用来实现这一功能：```cint sumOddNodes(struct TreeNode* root) {if (root == NULL) {return 0;}int sum = 0;if (root->val 2 != 0) {sum += root->val;}sum += sumOddNodes(root->left);sum += sumOddNodes(root->right);return sum;}```这个函数使用了递归的思想，首先判断当前节点是否为空，如果为空则返回0；然后判断当前节点的值是否为奇数，如果是奇数则将其累加到sum中；最后分别递归遍历左子树和右子树，并将它们的结果累加到sum中。
3. 算法的正确性证明为了证明上述算法的正确性，我们可以通过数学归纳法来进行推导。
c语言函数的嵌套和递归调用方法的实验小结
C语言函数的嵌套和递归调用方法的实验小结一、引言在C语言程序设计中，函数的嵌套和递归调用是两种常用的方法，它们在解决问题和实现特定功能时具有重要作用。
本文将结合实验结果，对C语言函数的嵌套和递归调用方法进行总结和分析，旨在加深对这两种方法的理解和应用。
二、函数的嵌套1. 概念与特点函数的嵌套是指在一个函数内部调用另一个函数。
当函数A中调用了函数B，函数B又调用了函数C，函数C又调用了函数D时，就形成了函数的嵌套调用。
函数的嵌套具有以下特点：（1）提高了程序的模块化和可读性，减少了代码的复杂度。
（2）可以在不同的函数之间传递参数，实现更灵活的功能组合。
（3）需要注意函数的声明顺序和作用域，避免出现未声明的函数引用错误。
2. 实验验证为了验证函数的嵌套调用，在实验中我们设计了一个简单的例子：编写两个函数，分别实现计算阶乘和计算组合数的功能，然后在主函数中进行嵌套调用，计算组合数的值。
实验结果表明，函数的嵌套调用可以实现相互依赖的功能模块，在程序设计中具有一定的灵活性和适用性。
三、递归调用1. 概念与特点递归调用是指一个函数在执行过程中调用了自身，从而形成了一种函数调用的循环结构。
通过递归调用，可以使函数不断重复执行，直到满足特定的条件才停止。
递归调用具有以下特点：（1）简化了程序的结构，使代码更加清晰和易于理解。
（2）能够处理一些需要多级嵌套的问题，极大地提高了代码的复用性和灵活性。
（3）需要设置递归调用的终止条件，避免形成无限循环，导致程序崩溃。
2. 实验验证为了验证递归调用的功能和特点，我们设计了一个典型的递归程序：计算斐波那契数列的前n项值。
实验结果表明，递归调用在实现该问题时具有简洁、高效的特点，使得代码易于阅读和理解，优雅地解决了该问题。
四、两种方法的比较1. 灵活性与适用性函数的嵌套调用主要适用于需要实现不同功能模块之间的交互和依赖关系的情况，具有较强的灵活性和可扩展性。
递归调用主要适用于解决问题具有明显的递归结构或需要多级嵌套的情况，具有较好的适用性和简洁性。
递归法求两个数的最大公约数c语言
递归法求两个数的最大公约数在C语言中是一种常见的算法。
下面我们将详细介绍如何使用递归法来求两个数的最大公约数，并给出相应的C语言代码示例。
1. 什么是最大公约数？最大公约数，又称最大公因数，指两个或多个整数共有约数中最大的一个。
最大公约数通常用gcd(m, n)或者（m,n）表示。
2. 辗转相除法求最大公约数辗转相除法是一种求最大公约数的常用方法，其原理是利用两个正整数的除法及求余运算来求得最大公约数。
其公式为：gcd(m, n) = gcd(n, mn)其中，m和n是两个正整数，为求余运算符。
3. 递归法求最大公约数递归法是一种常用的算法思想，它将一个问题拆分为更小的子问题，通过解决子问题来解决原问题。
在求最大公约数时，我们可以使用递归法将辗转相除法进行递归调用。
具体的递归算法如下：```cint gcd(int m, int n) {if (n == 0) {return m;} else {return gcd(n, m n);}}```在上面的代码中，我们定义了一个名为gcd的函数，该函数接受两个整数m和n，并返回它们的最大公约数。
在函数内部，我们首先判断n是否为0，如果为0则返回m，否则递归调用gcd函数，参数为n 和mn。
4. 递归法求最大公约数的示例下面我们给出一个具体的示例来演示递归法求最大公约数的过程。
假设我们要求解gcd(48, 18)，根据递归法的算法，首先会调用gcd(18, 4818)，然后继续调用gcd(4818, 184818)，直至其中一个数为0，此时最大公约数就是另一个非0数。
通过以上示例可以看出，递归算法求最大公约数的过程比辗转相除法更为简洁和直观。
5. 递归法求最大公约数的优缺点递归法求最大公约数的优点是代码简洁、易于理解，而且能够直接体现递归思想，对于解决类似问题具有一定的指导作用。
但是递归调用会占用额外的系统资源，可能会导致栈溢出，因此在处理大规模数据时需要谨慎使用递归法。
C语言与程序设计ppt-第12章递归
第12章 递 归
华中科技大学计算机学院 卢萍
华中科技大学计算机学院C语言课
2021/4/25
程组
1
本章讲授内容
递归（recursion）是一项非常重要的编 程技巧，可以使程序变得简洁和清晰，是 许多复杂算法的基础。本章介绍 递归、递归函数的概念； 递归的执行过程； 典型问题的递归函数设计； 分治法与快速排序； 回溯法； 递归在动态规划等算法中的应用。
12
【例12.3】 设计一个求解汉诺塔问题的算法。
这是一个典型的用递归方法求解的问题。要移动n个 盘子，可先考虑如何移动n 1个盘子。分解为以下3 个步骤：
（1）把A上的n-1个盘子借助C移到B。 （2）把A上剩下的盘子（即最大的那个）移到C。 （3）把B上的n-1个盘子借助A移到C。 其中，第（1）步和第（3）步又可用同样的3步继
2021/4/25
华中科技大学计算机学院C语言课程组
2
12.1 递归概述
递归是一种函数在其定义中直接或间接调用 自己的编程技巧。递归策略只需少量代码就 可描述出解题过程所需要的多次重复计算， 十分简单且易于理解。
递归调用：函数直接调用自己或通过另一函 数间接调用自己的函数调用方式
递归函数：在函数定义中含有递归调用的函 数
续分解，依次分解下去，盘子数目n每次减少1，直 至n为1结束。这显然是一个递归过程，递归结束条 件是n为1。
2021/4/25
华中科技大学计算机学院C语言课程组
13
函数move(n,a,b,c)
为了更清楚地描述算法，可以定义一个函数 move(n,a,b,c)。该函数的功能是：将n个盘 子从木桩a上借助木桩b移动到木桩c上。算法 的第（1）步和第（3）步的实现都是递归调 用，分别为move(n-1,a,c,b)和move(n1,b,a,c)。
数据结构-使用C语言 朱战立 第6章递归
6.7设计举例
6.7.1 一般递归算法设计举例
例6-5 设计一个输出如下形式数值的递归算法。 n n n ... n
...... 3 2 1 3 2 3
18
问题分析：该问题可以看成由两部分组成：一部分是输出一 行值为n的数值；另一部分是原问题的子问题，其参数为n-1。 当参数减到0时不再输出任何数据值，因此递归的出口是当参 数n≤0时空语句返回。
（ 3 ）分析当调用语句为 Gcd(97, 5) 时算法的 执行过程和执行结果；
（4）编写求解该问题的循环结构算法。
23
解：
递归算法如下： int Gcd(int n, int m) { if(n < 0 || m < 0) exit(0); if(m == 0) return n; else if(m > n) return Gcd(m, n); else return Gcd(m, n % m); }
7
递归算法如下：
int BSearch(int a[], int x, int low, int high) { int mid; if(low > high) return -1; mid = (low + high) / 2; if(x == a[mid]) return mid; else if(x < a[mid]) return BSearch(a, x, low, mid-1); /*在下半区查找*/ else return BSearch(a, x, mid+1, high); } /*在上半区查找*/ /*查找成功*/ /*查找不成功*/
Move Disk 2 from Peg A to Peg C
Move Disk 1 from Peg B to Peg C
c语言爬楼梯递归算法
c语言爬楼梯递归算法C语言是一门强大的编程语言，拥有广泛的应用领域。
在编程过程中，递归算法是一种非常重要的技巧。
而爬楼梯问题是一个经典的递归应用场景。
在这篇文章中，我们将一步一步地探讨如何使用C语言编写一个递归算法来解决爬楼梯的问题。
首先，让我们来了解一下爬楼梯问题的背景。
假设有一座楼梯，每次只能向上爬1步或2步。
假设我们要爬到楼梯顶部，问有多少种不同的方法可以实现这个目标。
为了解决这个问题，我们可以通过递归的方式来分析。
首先，让我们来思考一下简单的情况。
当楼梯只有1级时，只有一种方法可以达到楼梯顶部，即爬一步；当楼梯有2级时，有两种方法可以达到楼梯顶部，即一步一步地爬上去，或者一次性跨两级。
这些简单的情况给了我们一些启示，即当楼梯有n级时，我们可以将问题拆分为两个子问题：爬到n-1级楼梯的方法数，以及爬到n-2级楼梯的方法数。
而当楼梯有3级时，我们可以将其看作先爬到2级楼梯，再爬上一级的方式。
现在，我们可以写出一个初步的递归函数来解决这个问题。
让我们定义一个名为`climbStairs`的函数，该函数接受一个整数参数`n`，表示楼梯的级数。
函数的返回值是一个整数，表示爬到楼梯顶部的方法数。
我们将函数的实现如下：cint climbStairs(int n) {if (n == 1) {return 1;}if (n == 2) {return 2;}return climbStairs(n-1) + climbStairs(n-2);}在这段代码中，我们首先处理了基本情况。
当楼梯只有1级或2级时，我们直接返回相应的方法数。
然后，我们使用递归调用来解决更复杂的情况。
我们将楼梯的级数减1和减2分别传递给函数本身，并将两者的结果相加。
这样，我们就能得到爬到n级楼梯的方法数。
让我们来用一个例子来测试我们的代码。
假设楼梯有5级，我们可以调用`climbStairs(5)`来计算。
根据我们的递归算法，我们可以得到以下计算过程：climbStairs(5)= climbStairs(4) + climbStairs(3)= (climbStairs(3) + climbStairs(2)) + climbStairs(3)= (climbStairs(2) + climbStairs(1)) + climbStairs(2) + climbStairs(3) = 2 + 1 + 2 + (climbStairs(1) + climbStairs(2))= 2 + 1 + 2 + 1 + 2= 8从这个例子中，我们可以看到`climbStairs(5)`的结果是8，即有8种不同的方式可以爬到楼梯顶部。
C语言递归函数原理应用和注意事项
C语言递归函数原理应用和注意事项一、什么是递归函数递归函数是指在函数的定义中调用函数本身的一种编程技术。
在C 语言中，递归函数是以一种自我调用的方式来解决问题的。
递归函数通常包含两个部分：基本情况和递归情况。
基本情况是指函数不再调用自身时的结束条件，而递归情况是指函数调用自身继续解决子问题的情况。
二、递归函数应用场景1. 数学问题：递归函数常用于解决数学上的问题，比如计算阶乘、斐波那契数列等。
递归函数可以简化数学问题的求解过程。
2. 数据结构操作：在处理树、图等数据结构时，递归函数也经常被使用。
通过递归函数，可以方便地遍历树或图的各个节点。
3. 文件操作：递归函数在处理文件时也有一些应用场景。
比如在文件夹中搜索指定文件、复制文件夹等操作中，递归函数可以递归地处理每个子文件夹或文件。
三、递归函数的注意事项1. 结束条件：递归函数必须有一个合适的结束条件，否则会导致无限递归，造成程序崩溃或死循环。
2. 参数传递：递归函数在每次调用自身时，参数要适当地传递给下一次调用。
参数传递要根据具体问题来确定，避免传递过多或不必要的参数。
3. 层次控制：递归函数的层次过多可能导致函数调用栈溢出，因此要注意控制递归的层次，避免出现过深的递归。
4. 代码复杂性：递归函数的代码比较复杂，理解和调试相对困难。
要保持良好的代码风格和逻辑清晰，增加注释有助于他人理解代码。
四、递归函数的示例代码下面是一个计算阶乘的递归函数例子：```c#include <stdio.h>int factorial(int n) {// 基本情况if (n == 0 || n == 1) {return 1;}// 递归情况return n * factorial(n - 1);}int main() {int num = 5;int result = factorial(num);printf("The factorial of %d is %d\n", num, result);return 0;}```在上面的示例代码中，factorial函数通过递归调用实现了计算阶乘的功能。
c语言递归算法
c语言递归算法C语言递归算法递归算法是一种基于函数调用的编程方法，即一个函数在执行过程中调用自身，以此实现循环的效果。
C语言中递归函数的应用范围很广，可以帮助我们简化代码结构，提高代码复用率和可读性。
在接下来的文章中，将会详细介绍C语言中递归算法的原理和应用。
1.递归算法的基本原理递归算法的原理非常简单，即一个函数在执行过程中，调用自身直到达到某个结束条件。
换句话说，递归算法就是把一个大问题不断地分成小问题，直到小问题可以轻松解决的时候，再逐层返回最终结果。
2.递归算法的应用2.1.阶乘问题递归算法最经典的应用场景之一就是求阶乘。
阶乘的定义是从1乘到给定的数字n，所以我们可以使用递归函数来求解阶乘问题。
即，如果n等于1，则阶乘就是1；否则阶乘为n乘以n-1的阶乘。
代码如下：```cint factorial(int n){if (n == 1)return 1;elsereturn n * factorial(n-1);}```2.2.斐波那契数列斐波那契数列是另一个非常经典的递归算法实现问题。
斐波那契数列的定义是，前两个数都是1，之后的每一个数都是前两个数的和。
以下是斐波那契数列的递归函数的实现：```cint fibonacci(int n){if (n <= 1)return n;elsereturn fibonacci(n-1) + fibonacci(n-2);}```2.3.越界问题递归函数存在一个重要的问题就是越界问题。
如果递归函数的调用层数过多，会容易就会导致栈内存溢出，从而导致程序崩溃。
为了防止这种情况的发生，我们可以使用迭代方法来提高程序的效率和稳定性。
```cint fibonacci(int n){int result[100];result[0] = 1;result[1] = 1;for(int i=2; i<=n; i++)result[i] = result[i-1] + result[i-2];return result[n-1];}```3.总结本文详细介绍了C语言中递归算法的实现原理和应用场景，从阶乘问题到斐波那契数列，每一个问题都展示了递归算法的优点和缺点，以及如何提高程序的效率和稳定性。
c语言输入n,求n!(递归算法)
【题目】C语言输入n，求n的阶乘（递归算法）【导言】在编程语言中，阶乘是一个非常基础且常见的数学问题。
在C语言中，可以通过递归算法来解决求n的阶乘的问题。
本文将介绍C语言中如何输入n，然后利用递归算法来求n的阶乘，希望能为大家深入理解递归算法提供一些帮助。
【正文】1. 了解递归算法递归算法是指在函数的定义中使用函数自身的方法。
在进行递归调用时，必须要有出口条件，否则就会陷入无限循环之中。
对于阶乘问题，可以采用递归算法来解决，即n的阶乘等于n乘以n-1的阶乘，而n-1的阶乘又可以继续拆分为(n-1)乘以(n-2)的阶乘，以此类推直到n=1时，其阶乘为1。
这就是递归调用的基本思想。
2. 编写C语言代码下面我们来编写一个C语言的函数，利用递归算法来求输入n的阶乘。
```c#include <stdio.h>int factorial(int n) {if (n == 1) {return 1;} else {return n * factorial(n - 1);}}int main() {int number;printf("请输入一个整数：");scanf("d", number);if (number < 0) {printf("输入的整数必须大于等于0\n");} else {printf("d的阶乘为：d\n", number, factorial(number));}return 0;}```3. 程序分析在上面的代码中，定义了一个名为factorial的函数，用于求n的阶乘。
在main函数中，首先要求用户输入一个整数，然后调用factorial函数来求该整数的阶乘，并在控制台输出结果。
4. 示例运行接下来，我们通过一个示例来演示如何输入n，然后利用递归算法来求n的阶乘。
假设我们要求5的阶乘，输入5后程序将输出5的阶乘结果120。
c语言写递归
c语言写递归C语言是一种广泛应用于计算机编程的高级编程语言，它具有强大的功能和灵活的语法结构。
其中，递归是C语言中一种重要的编程技巧，它可以简化代码的编写，并且在解决一些问题时非常有效。
递归是指在一个函数中调用自身的过程。
通过递归，我们可以将一个复杂的问题分解成一个或多个相同或类似的子问题，然后通过解决子问题来解决原始问题。
递归函数通常包含两个部分：基本情况和递归情况。
基本情况是指递归函数停止调用自身的条件，而递归情况则是指递归函数继续调用自身的条件。
下面我们以一个经典的例子来说明递归的使用。
假设我们要计算一个正整数的阶乘，可以使用递归函数来实现。
阶乘的定义是：n的阶乘等于n乘以(n-1)的阶乘，其中0的阶乘定义为1。
下面是一个使用递归函数计算阶乘的C语言代码：```c#include <stdio.h>int factorial(int n) {// 基本情况if (n == 0) {return 1;}// 递归情况else {return n * factorial(n - 1);}}int main() {int num;printf("请输入一个正整数：");scanf("%d", &num);printf("%d的阶乘是：%d\n", num, factorial(num));return 0;}```在上面的代码中，我们定义了一个名为`factorial`的递归函数，它接受一个整数参数`n`，并返回`n`的阶乘。
在函数内部，我们首先判断`n`是否等于0，如果是，则返回1，这是基本情况。
如果`n`不等于0，则调用`factorial`函数来计算`(n-1)`的阶乘，并将结果乘以`n`，这是递归情况。
最后，在`main`函数中，我们通过用户输入一个正整数来调用`factorial`函数，并将结果打印出来。
通过上述代码，我们可以看到递归函数的使用非常简洁和直观。
c语言中的递归
c语言中的递归递归是一种常见的编程技巧，也是C语言中的重要概念之一。
它是指一个函数在执行过程中调用自身的行为。
递归在解决一些问题时非常有效，能够简化代码的编写和理解。
在C语言中，递归函数的定义和普通函数类似，只是在函数体内部会调用自身。
递归函数通常包含两个部分：基本情况和递归情况。
基本情况是指函数不再调用自身，而是直接返回结果的情况。
递归情况是指函数调用自身的情况，通常会将问题规模缩小，然后再次调用函数来解决。
递归函数的一个经典例子是计算阶乘。
阶乘是指一个正整数n与小于等于n的所有正整数的乘积。
可以使用递归函数来计算阶乘，代码如下：```cint factorial(int n) {if (n == 0 || n == 1) {return 1;} else {return n * factorial(n - 1);}}```在这个例子中，当n等于0或1时，函数直接返回1，这是基本情况。
当n大于1时，函数调用自身来计算n-1的阶乘，并将结果与n相乘，这是递归情况。
通过不断缩小问题规模，最终可以得到n的阶乘。
递归函数的执行过程可以用一棵树来表示，这棵树被称为递归树。
每个节点表示函数的一次调用，树的根节点表示初始调用，叶子节点表示基本情况。
递归树的深度表示递归的层数，每一层的节点数表示函数的调用次数。
递归函数的优点是能够简化代码的编写和理解。
通过递归，可以将复杂的问题分解成更小的子问题，然后通过递归调用来解决。
递归函数的缺点是可能会导致性能问题。
由于递归函数的调用过程中需要保存函数的局部变量和返回地址，所以递归的层数过多时会消耗大量的内存和时间。
为了避免递归函数的性能问题，可以使用尾递归优化。
尾递归是指递归函数的最后一步是调用自身的情况。
在尾递归优化中，编译器会将递归调用转化为循环，从而减少内存和时间的消耗。
总之，递归是C语言中的重要概念之一，能够简化代码的编写和理解。
通过递归，可以将复杂的问题分解成更小的子问题，然后通过递归调用来解决。
C语言高级特性递归与回溯算法
C语言高级特性递归与回溯算法C语言高级特性：递归与回溯算法递归和回溯算法是C语言中一种非常重要的高级特性，它们在解决一些复杂问题和优化代码时发挥着关键的作用。
本文将会介绍递归和回溯算法的原理和应用，并通过具体的示例来说明它们的使用方法。
一、递归算法递归是指一个函数在执行过程中调用自身的过程。
递归算法通常包括两个部分：递归出口和递归调用。
递归出口是指当满足某个条件时结束递归的条件，而递归调用则是指在函数内部调用自身来解决规模更小的问题。
递归算法在解决一些具有重复性结构的问题时非常高效。
例如，计算一个数的阶乘，可以使用递归算法来实现：```c#include <stdio.h>int factorial(int n) {if (n == 0 || n == 1) { //递归出口return 1;} else {return n * factorial(n - 1); //递归调用}}int main() {int n = 5;printf("The factorial of %d is %d\n", n, factorial(n));return 0;}```上述代码定义了一个计算阶乘的递归函数factorial。
在函数内部，通过递归调用来计算规模更小的问题，直到n等于0或1时返回结果。
二、回溯算法回溯算法是一种通过尝试所有可能的解来找到问题解决方法的搜索算法。
在遇到有多个解可选的情况下，回溯算法会尝试每一种可能，并通过剪枝策略来避免不必要的计算。
回溯算法通常涉及到构建决策树和遍历树上的节点。
以八皇后问题为例，考虑如何在8x8的棋盘上放置8个皇后，使得每个皇后都不会互相攻击。
下面是用回溯算法解决八皇后问题的示例代码：```c#include <stdio.h>#define N 8int board[N][N];int isSafe(int row, int col) {int i, j;// 检查当前位置的列是否安全for (i = 0; i < row; i++) {if (board[i][col] == 1) {return 0;}}// 检查当前位置的左上方是否安全for (i = row, j = col; i >= 0 && j >= 0; i--, j--) { if (board[i][j] == 1) {return 0;}}// 检查当前位置的右上方是否安全for (i = row, j = col; i >= 0 && j < N; i--, j++) { if (board[i][j] == 1) {return 0;}}return 1;}int solve(int row) {int col;if (row >= N) { // 所有行都已经安全放置皇后，找到解 return 1;}for (col = 0; col < N; col++) {if (isSafe(row, col)) {board[row][col] = 1; // 放置皇后if (solve(row + 1)) { // 递归调用return 1;}board[row][col] = 0; // 回溯，撤销放置皇后}}return 0;void printBoard() {int i, j;for (i = 0; i < N; i++) {for (j = 0; j < N; j++) {printf("%d ", board[i][j]); }printf("\n");}}int main() {if (solve(0)) {printf("Solution:\n");printBoard();} else {printf("No solution found.\n"); }return 0;}上述代码使用回溯算法来解决八皇后问题。
c语言中如何返回之前的步骤
c语言中如何返回之前的步骤在C语言中，要返回之前的步骤，可以使用函数的递归调用或者栈的数据结构来实现。
下面分别介绍这两种方法。
一、递归调用递归调用是一种函数调用自身的方式。
通过递归调用，可以实现函数返回之前的步骤。
1.递归调用的基本原理递归调用的基本原理是在函数内部调用自身，通过在每一次递归调用中传递不同的参数，让函数按照不同的路径执行，最终返回之前的步骤。
2.递归调用的步骤（1）定义递归函数：在函数内部定义一个递归函数，用于实现递归调用。
（2）设置递归终止条件：在递归函数的开头设置一个递归终止条件，当满足此条件时，不再进行递归调用，直接返回。
（3）设置递归调用：在递归函数内部，根据条件判断是否进行递归调用，若进行递归调用，则传入不同的参数。
（4）返回值：在递归函数中，根据需要返回相应的值。
3.递归调用的示例下面以计算阶乘的函数为例，介绍递归调用的实现过程。
```c#include <stdio.h>int factorial(int n)if(n == 0)return 1; // 终止条件elsereturn n * factorial(n-1); // 递归调用int mainint num;printf("请输入一个非负整数：");scanf("%d", &num);printf("%d的阶乘为%d\n", num, factorial(num));return 0;```以上代码中，factorial函数是一个递归函数，根据n的不同值，通过递归调用来实现计算阶乘的功能。
当n为0时，满足递归终止条件，函数直接返回1；否则，函数通过递归调用返回n * factorial(n-1)的结果。
二、栈的数据结构栈是一种后进先出（LIFO）的数据结构，可以通过栈来实现返回之前的步骤。
1.栈的基本操作（1）入栈（push）：将元素压入栈顶。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言中递归的分析及应用作者：杨新宇兰全祥来源：《电脑知识与技术》2020年第22期摘要：函数以及函数的递归调用是学习C语言必须要掌握的内容，且递归作为经典的算法思想被广泛应用于程序设计中。
从应用场景的角度出发，对C语言中递归的定义、特征以及适用场景进行了探讨，并对这些适用场景进行分析和举例。
最后，分析并探讨了递归的优缺点，并给出了递归的优化方法和将递归转换为非递归的方法。
关键词：C语言;递归;应用;非递归化中图分类号：TP311 文献标识码：A文章编号：1009-3044（2020）22-0237-02开放科学（资源服务）标识码（0SID）：1 背景随着时代的进步以及计算机编程语言的不断发展，从20世纪80年代传承至今的C语言始终是各大高校首选的计算机编程语言。
世界编程语言排行榜（ TIOBE）中C语言的热门程度自2002年至今始终稳居前三[1]。
由此可见，C语言的重要程度以及热门度。
另外，模块化设计是所有程序设计必须遵循的设计原则，而函数就是C语言模块化的重要组成部分[2]。
C语言函数以及函数的使用是学习C语言必须要掌握的内容。
递归作为经典的函数使用方法，应用范围广泛，是函数中不可或缺的重要内容，也是作为一个开发者应该掌握的重要算法之一。
2 遞归的概述2.1 定义张长海等人认为在定义一个函数时，若在定义函数的内部又出现对函数本身的调用，则称该函数是递归的或递归定义的[3];谭浩强等人认为递归就是函数自己直接或间接地调用自身的过程[4];丁雪晶认为递归就是把要解决的问题分解成与原问题有相同解法，且规模较小的问题，直到遇见终止条件[5]。
综上，笔者认为函数的递归就是直接或间接地调用自身进行人栈操作，遇到边界之后再进行出栈的过程，且在人栈过程中，由原始问题分解为的子问题始终向边界靠拢。
2.2 特征从上述定义可得出递归的以下特征：1）函数总是直接或者间接的调用自身;2）函数的递归必须有结束条件（即问题的边界），且在调用的过程中始终向某一个边界靠近;3）递归过程是一个不断人栈和出栈的过程。
2.3 应用场景递归的本质是将关于n的问题转化为同类解法的关于m的问题，其中n和m是问题的规模，且m比n更靠近问题的边界（递归结束条件）。
通过对常见递归应用的分析，笔者将递归应用场景分为三类：1）数据的初始化是递归的。
2）数据的结构是递归的。
3）问题的求解是递归的。
3 递归的案例根据上述对函数递归的定义、特征以及应用场景的总结，本文对上述递归的应用场景进行分析和举例。
3.1 数据的初始化是递归的示例：Fibonacci数列（兔子数列）描述：形如1，1，2，3，5，8，13，21I.….的数列被称为Fibonac-Cl数列，即第n个数等于第n-l个数和第n-2个数之和。
分析：根据上述定义，对数列进行数学归纳可得出数学递推公式。
根据分析可知，Fibonacci数列是典型的数据的初始化是递归的例子，即要对n进行初始化，必须知道n-l和n-2的值。
初始化Fibonacci数列的关键代码如下：int Fib（int n）{if（n ==1¨n==2）{return 1;）elsefreturn Fib（n-I）+Fib（n-2）;））3.2 数据的结构是递归的示例：二叉树描述：二叉树是结点的有限集合，该集合或者为空集，或者是由一个根和两棵互不相交的称为该根的左子树和右子树的二叉树组成[6]。
分析：由定义可知，一个根结点可能存在左子树和右子树，且左子树和右子树又是一颗更小的二叉树。
因此，二叉树从数据结构上来看是递归的，如图1所示，A的左子树、A的右子树以及C 的左子树都是一颗二叉树，且无论是二叉树的初始化还是遍历都能用递归来解决。
构造二叉树的关键代码如下：typedef struct BiTNode{char data; struct BiTNode，*rchild，*rchild;}BiTNode，a：BiTree;void CreateBiTree（BiTiree *T）{char c;scanf（”%c”，&c）;i“c==7#7）{*T=NULL;】elsef*T= （BiTNode*）new BiTNode;（*T）->data=c;CreateBiTree（&（*T）->lchild）;CreateBiTree（&（*T）->rchild）;）】由代码可以看出，在二叉树的构造中，输入根节点数据之后还需要递归调用CreateBiTree 函数对其左右子树进行构造，即要成功构造一颗二叉树，需要先构造出其左、右子树。
另外，二叉树的遍历也可采用递归的方法实现先序遍历、中序遍历与后序遍历。
3.3 问题的求解是递归的示例：汉诺塔描述：现有A，B，C三根柱子，在A柱有n个从上到下面积依次增大的盘子，现在想把A柱这n个盘子移动到C柱，但规定每一次只能移动一个盘子，且三根柱子的盘子始终都保持着面积大的盘子在下，面积小的盘子在上，问盘子移动的步骤。
分析：如果我们能先将A柱上层的n-1个盘子移动到B柱，然后将A柱的第n个盘子移动到C柱，再将B柱的n-1盘子移送到C柱，那么就完成了将A柱的n个盘子移动到C柱的操作。
也就意味着，我们将n的问题Q（n）分解为了Q（n-1）+l+Q（n-1）的问题。
从上述分析可以看出，汉诺塔是典型的问题的解是递归的。
即如果能解决Q（n-1）的问题，那么就能解决Q（n）的问题。
汉诺塔的关键代码如下：void hanoi（int n， char A，char B， char C）（if（n==1 1printf（”%c→%c＼n”，A，C）;elsefhanoi（ n-l，A，C，B）;printf（”%c→%c＼n”，A，C）;hanoi（ n-1，B，A，C）;在解决问题的过程中，原问题在不断地减小规模，且总是向边界不断的靠近。
4 递归的分析4.1 优点通过对递归的特征以及应用场景的分析，可以总结出以下优点：1）函数的递归调用可以使问题的解更直观、思路更清晰。
比如红黑树的插入、删除等。
2）使用遞归函数可以大幅度减少函数的代码量，使代码更简洁。
3）可以更便于使用数学方法证明算法的正确性、计算算法的时间与空间复杂度，也能更方便地将问题所对应的递归形式函数转化为相应的递归算法程序，如斐波拉契数列。
4.2 缺点函数的递归调用虽然在程序设计上更便捷，但是也存在着许多无法避免的缺点，如：时间复杂度高。
如Fibonacci数列的时间复杂度为0（211），是呈指数级增长的。
假设计算机Is可以计算出Fib（40），那么，当n=100时，计算机计算出Fib（100）所需要的时间大约需要16，000，000，000年，这个计算所需要的时间时不可等待的。
1）空间复杂度高。
递归是一个不断压栈和出栈的过程，在输入的数据量比较大的时候，很可能发生栈溢出。
如在二叉树的遍历中，若二叉树的深度较大时，递归调用时将进行大量压栈操作，致使空间效率大大降低，造成栈溢出。
4.3 递归的优化与非递归化为了解决函数递归调用可能会发生的空间爆炸和时间爆炸问题，可以考虑对递归进行优化和非递归化。
1）将递归与分治法相结合。
分治法的基本思想是将一个规模为n的问题费解为k个规模较小的子问题，这些子问题相互独立且与原问题相同，然后再将各个子问题的解合并，进而得到原问题的解。
如Fibonacci数列使用数学归纳法可以得证：因此采用矩阵与分治和递归相结合的方法计算Fibonacci数列，其时间复杂度为O （logn），大大提高了算法的效率。
2）将递归与动态规划相结合。
动态规划也是对原问题进行分解，但是所得到的子问题往往不是相互独立的[9]。
如Fibo-naccl数列使用数组逐个保存Fibonacci数列值，将问题转化为：x[n]=x[n- 1]+x[n -2]先记录x[n一1]和x[n一2]的值，然后通过已解决的子问题来求解原问题的解，其时间复杂度为O（n）。
关键代码如下：static int rec[100]{-1）;long long f'ib（int n）（iffn==01return 1：iffn==11return 1：if（rec[n]_=-1）rec[n]= fib（n-l）+ fib（n-2）;return rec[n];】3）将递归算法非递归化。
将递归算法转化为非递归算法还可以利用栈模拟、循环、递推等来进行转化[7-8]。
这样算法的执行效率与空间利用率将会大大提高。
5 结束语函数的递归在程序设计中是很常见的，所有使用递归算法来解决的问题都必然要具有收敛性（即问题的求解存在结束条件或者是边界），若满足这一个要求的源问题，就可以考虑用递归的方法来解决。
但是在实际开发过程中，需要考虑递归所带来的时间复杂度以及空间复杂度等问题，当时间复杂度过高时，则应考虑将递归算法进行非递归化。
在解决问题的过程中，是否采用递归算法，使用什么样的非递归转化方法，可以根据实际的情况进行选择。
参考文献：[1]兰全祥.地方应用型本科院校C语言课程改革探讨[J].西昌学院学报（自然科学版），2017，31（4）： 100-102，123.[2]袁凤玲.软件工程思想在程序设计公共课教学中的应用[J].辽宁科技学院学报，2015，17（1）： 44-45.[3]张长海，陈娟.C程序设计[M].北京：高等教育出版社，2004.[4]谭浩强.C程序设计[Ml.4版.北京：清华大学出版社，2010.[5]丁雪晶.C语言递归函数教学的设计与探讨[Jl.电脑知识与技术，2018，14（16）： 150-152.[6]陈慧南.数据结构与算法：C++语言描述[M].北京：高等教育出版社，2005.[7]孟林，李忠.递归算法的非递归化研究[J].计算机科学，2001，28（8）： 96-98.[8]汤亚玲.递归算法设计及其非递归化研究[J].计算机技术与发展，2009，19（11）： 85-88，93.【通联编辑：谢媛媛】基金项目：攀枝花学院大学生创新创业项目（项目编号：2019cxcy072）作者简介：杨新宇（2001-），男，四川巴中人，主要研究方向为算法设计与分析;兰全祥（1990-），通讯作者，男，四川攀枝花人，讲师，硕士，主要研究方向为软件开发。