递归算法实例C源码
c语言写斐波那契数列使用递归和递推
英文回答：As amon mathematical problem， the Fibonacci series is defined as follows： F（0） = 0， F（1） = 1， F（n） = F（n—1） + F（n—2）。
This means that the n element of the array is equal to the sum of its first two elements。
In the process of calculating the Fibonacci series， we should consider the way in which the regression and the extrapolation are carried out separately。
For government policymakers， understanding and using the formula of the Fibonacci series can help us to better understand and analyse the patterns of socio—economic development and provide an important reference for the development of science's paths， approaches and policies。
斐波那契数列作为一种常见的数学问题，其定义如下：F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2)。
这意味着数列的第n个元素等于其前两个元素之和。
在实现斐波那契数列的计算过程中，我们应当分别考虑递归和递推的方式。
对于政府决策者而言，理解并运用斐波那契数列的计算方法，能够帮助我们更好地理解和分析社会经济发展的规律，并为制定科学的发展路线、方针和政策提供重要参考。
c语言递归算法简单例子
c语言递归算法简单例子嘿，聊聊C 语言的递归算法简单例子，老有意思啦！嘿，朋友们！今天咱来唠唠C 语言里那个神奇又有点让人摸不着头脑的递归算法，顺便看几个简单例子，保证让你大开眼界！递归算法就像是一只调皮的小猴子，在代码的树林里上蹿下跳，一会儿钻进这个函数，一会儿又从里面冒出来，还带回一些东西，可有意思啦！比如说计算一个整数的阶乘，这可是递归算法的经典例子呢。
我们来看看代码怎么写：```cinclude <>int factorial(int n) {if (n == 0 n == 1) {return 1;} else {return n factorial(n - 1);}}int main() {int num = 5;int result = factorial(num);printf("%d 的阶乘是：%d\n", num, result);return 0;}```你看哈，在这个factorial 函数里，它自己会不断地叫自己，就好像一直在问：“嘿，我下一个数的阶乘是多少啊？”然后就一层一层地往里钻。
直到遇到n 等于0 或者1 这个底部，才开心地说：“哦，我知道啦，是1 呀！”然后又一层一层地跑回来，把每层得到的结果相乘，最后得出最终答案。
感觉就像是小猴子在树洞里找到了宝贝，然后欢天喜地地跑出来。
还有一个有趣的例子，就是计算斐波那契数列。
这斐波那契数列啊，前面两个数是0 和1，后面的每个数都是前两个数的和。
我们也可以用递归算法来算算。
```cinclude <>int fibonacci(int n) {if (n == 0) {return 0;} else if (n == 1) {return 1;} else {return fibonacci(n - 1) + fibonacci(n - 2);}}int main() {int n = 10;for (int i = 0; i < n; i++) {printf("斐波那契数列第。
汉诺塔递归c语言
汉诺塔递归c语言
汉诺塔是一个经典的递归问题。
在汉诺塔问题中，有3个柱子，一个可以移动的盘子，开始时所有盘子按大小顺序叠放在第一个柱子上，目标是将这些盘子移动到第三个柱子上，同时每次只能移动一个盘子，并且不能将一个较大的盘子放在较小的盘子上面。
以下是一个使用C语言实现的汉诺塔递归算法：
c复制代码
#include<stdio.h>
void hanoi(int n, char from, char to, char via) {
if (n == 1) {
printf("Move disk 1 from %c to %c\n", from, to);
return;
}
hanoi(n - 1, from, via, to);
printf("Move disk %d from %c to %c\n", n, from, to);
hanoi(n - 1, via, to, from);
}
int main() {
int n = 3; // 盘子的数量
hanoi(n, 'A', 'C', 'B'); // 从柱子A移动到柱子C，经过柱子B
return0;
}
这个程序使用递归函数hanoi来解决汉诺塔问题。
当只有一个盘子时，直接将其从起始柱子移动到目标柱子。
当有多于一个盘子时，先将上面的n-1个盘子从起始柱子通过目标柱子移动到辅助柱子，然后将最大的盘子从起始柱子移动到目标柱子，最后将n-1个盘子从辅助柱子通过起始柱子移动到目标柱子。
递归算法(C版)
【例4】用递归旳措施求斐波那契数列中旳第N个数
【参照程序】 #include<iostream> using namespace std; int a[11]; int fib(int); int main() { int m; cin>>m; cout<<"fib("<<m<<")="<<fib(m); }
//调用下一层递归
}
int main()
{
int n,k;
cin >> n >> k;
cout << s(n,k);
return 0;
}
【例6】数旳计数(Noip2023)
【问题描述】
我们要求找出具有下列性质数旳个数（涉及输入旳自然数n）。先输入一 种自然数n（n≤1000），然后对此自然数按照如下措施进行处理：
return(fac(n-1)+n);
//调用下一层递归
}
运营程序，当T=5时，输出成果：S=15，其递归调用执行过程是： （设T=3）
递归调用过程，实质上是不断调用过程或函数旳过程，因为递归调 用一次，全部子程序旳变量（局部变量、变参等）、地址在计算机内部 都有用特殊旳管理措施——栈（先进后出）来管理，一旦递归调用结束， 计算机便开始根据栈中存储旳地址返回各子程序变量旳值，并进行相应 操作。
int fib(int n) { if (n==0) return 0; if (n==1) return 1; return (fib(n-1)+fib(n-2)); }
输入 15 输出 fib(15)=610
//满足边界条件，递归返回 //满足边界条件，递归返回 //递归公式，进一步递归
c语言猴子吃桃问题递归法
c语言猴子吃桃问题递归法
"猴子吃桃"问题是一个经典的递归问题。
故事是这样的：猴子摘下了n个桃子，
第一天吃掉了桃子数的一半又多吃了一个，接下来的每一天也是吃前一天剩下的
一半再多吃一个，到了第m天就剩下一个桃子了。
下面是用C语言和递归方法
来解决这个问题。
```c
#include
<stdio.h>
int total_peaches(int n, int day) {
if (day == 1) {
return1; // 最后一天剩下一个桃子
} else {
return (total_peaches(n, day - 1) + 1) * 2; // 第二天桃子数是前一天加1后的两倍
}
}
int main() {
int n = 100; // 初始的桃子数
int day = 9; // 经过的天数，可以根据需要更改
printf("总共摘了 %d 个桃子\n", total_peaches(n, day));
return0;
}
这个程序会计算出猴子在经过指定的天数后总共摘了多少个桃子。
注意，递归的
终止条件是当只剩下一个桃子的时候，此时的天数（我们这里设定为1）。
在每
一天，桃子的数量是前一天加1后的两倍。
c语言递归求数列
c语言递归求数列C语言递归求解数列是一种常见的编程问题，它可以通过递归函数来实现。
在数学中，数列是按照一定规律排列的一组数。
我们可以通过递归的方式来求解数列中的某一项或者整个数列。
首先，我们需要确定数列的规律，也就是递推关系。
递推关系是指数列中的每一项与前面的项之间的关系。
例如，斐波那契数列的递推关系是每一项等于前两项之和。
在C语言中，我们可以通过编写递归函数来实现数列的求解。
递归函数是指在函数体内调用自身的函数。
我们可以将递归函数看作是一个问题的解决方案，每次调用函数都是在解决一个更小规模的子问题。
下面是一个示例，演示了如何使用递归函数来求解斐波那契数列的第n项：```c#include<stdio.h>int fibonacci(int n) {// 递归终止条件if (n <= 1) {return n;}// 递归调用return fibonacci(n-1) + fibonacci(n-2);}int main() {int n;printf("请输入要求解的斐波那契数列的项数：");scanf("%d", &n);printf("斐波那契数列的第%d项为：%d\n", n,fibonacci(n));return 0;}```在上述代码中，我们定义了一个名为`fibonacci`的递归函数，它接受一个整数参数n，表示要求解的斐波那契数列的项数。
在递归函数内部，我们首先检查递归终止条件，即当n小于等于1时，直接返回n。
然后，我们通过递归调用函数本身来计算前两项的和，并返回结果。
在`main`函数中，我们首先获取用户输入的斐波那契数列的项数n，然后调用`fibonacci`函数来求解第n项，并将结果打印出来。
需要注意的是，递归函数在处理大规模问题时可能会导致性能问题，因为每次调用函数都需要保存现场和恢复现场。
C语言程序设计 递归应用举例
return 0; }
void invertLongInt(long x) {
if(x >=0 && x <= 9) printf("%d\n" , x);
else { printf("%d" , x % 10);
invertLongInt(x / 10); } }
return 0; }
int gcd(int x , int y) {
if( x % y = = 0) return y;
else
return gcd(y , x % y); }
程序运行结果：
请输入两个整数：341，132 341 , 132 的最大公约数是 11
【例 7-8】反向输出一个长整数 程序设计思路： (1) 如果要输出的数据只有一位，则“反向输出”问题可简化为输出一位整数。 (2) 如果要输出的数据超过一位，则可将该整数分为两部分：个位上的数字和个位以前 的数字。个位上的数字可以直接输出，而个位以前的数字又可以看成一个新的整数，重复执 行“反向输出”的操作。这时，反向输出在规模上缩小了一位，但求解的方法还是一致的。 (3) 用表达式 x % 10 可以分离出一个整数个位上的数字，用表达式 x / 10 可以表示出 个位以前的数。定义一个反向输出函数 invertLongInt，每次先用 x % 10 计算并输出个位 上的数，然后用 x / 10（即个位以前的数）做参数调用自己，不断进行下去，直到只剩一 位数字。 参考程序如下：
/*程序名：7_8.c*/ /*功能：反向输出一个长整数 */ #include <stdio.h> void invertLongInt(long);
c语言递归调用例子
c语言递归调用例子【篇一：c语言递归调用例子】* 小编已将正确代码放在左侧任务的“不知道怎么办”里* 小编希望各位童鞋独立完成哦~*///定义一个函数，传送人员序号进去，返回该序号员工的年龄。
int getage(numpeople) //定义返回的年龄 int age; //如果是第1个人的时候，年龄为10岁 if(numpeople==1) age=10; //这是回推墙，也就是结束递归的条件。
else //还没接触到回推墙，就自我调用，谓之递归。
age = getage(numpeople-1) //年龄等于上一个人的年龄加2 return age;int main() printf( 第5个人的年龄是%d岁 , getage(5));return 0;}【篇二：c语言递归调用例子】一、基本内容：c语言中的函数可以递归调用，即：可以直接（简单递归）或间接（间接递归）地自己调自己。
要点：1、c语言函数可以递归调用。
2、可以通过直接或间接两种方式调用。
目前只讨论直接递归调用。
二、递归条件采用递归方法来解决问题，必须符合以下三个条件：1、可以把要解决的问题转化为一个新问题，而这个新的问题的解决方法仍与原来的解决方法相同，只是所处理的对象有规律地递增或递减。
说明：解决问题的方法相同，调用函数的参数每次不同（有规律的递增或递减），如果没有规律也就不能适用递归调用。
2、可以应用这个转化过程使问题得到解决。
说明：使用其他的办法比较麻烦或很难解决，而使用递归的方法可以很好地解决问题。
3、必定要有一个明确的结束递归的条件。
说明：一定要能够在适当的地方结束递归调用。
不然可能导致系统崩溃。
三、递归实例例：使用递归的方法求n!当n 1时，求n!的问题可以转化为n*(n-1)!的新问题。
比如n=5：第一部分：5*4*3*2*1 n*(n-1)!第二部分：4*3*2*1 (n-1)*(n-2)!第三部分：3*2*1 (n-2)(n-3)!第四部分：2*1 (n-3)(n-4)!第五部分：1 （n-5）! 5-5=0，得到值1，结束递归。
c++汉诺塔问题递归算法
c++汉诺塔问题递归算法以下是C++中使用递归算法解决汉诺塔问题的示例代码：```cpp#include <iostream>using namespace std;// 定义递归函数解决汉诺塔问题void hanoi(int n, char source, char target, char auxiliary) {if (n == 1) {// 只有一个盘子时直接移动到目标柱子上cout << "Move disk 1 from " << source << " to " << target << endl;return;}// 将n-1 个盘子从源柱子移动到辅助柱子上hanoi(n - 1, source, auxiliary, target);// 将最底下的盘子从源柱子移动到目标柱子上cout << "Move disk " << n << " from " << source << " to " << target << endl;// 将n-1 个盘子从辅助柱子移动到目标柱子上hanoi(n - 1, auxiliary, target, source);}int main() {int numDisks;cout << "Enter the number of disks: ";cin >> numDisks;// 调用递归函数解决汉诺塔问题hanoi(numDisks, 'A', 'C', 'B');return 0;}```以上代码使用递归算法解决汉诺塔问题。
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++中，递归可以用于解决各种问题，例如排序、搜索、树遍历等等。
下面是一个经典的递归算法实例：斐波那契数列。
问题描述：给定两个整数n和m，求第n个斐波那契数列的值fn，其中fn=mfn-1+fn-2 (n>1)，fn=m (n=1)，fn=0 (n=0)。
以下是用C++实现的递归算法：c#include <iostream>using namespace std;int fibonacci(int n, int m) {if (n == 0) {return 0;} else if (n == 1) {return m;} else {return fibonacci(n-1, fibonacci(n-2, m));}}int main() {int n = 10, m = 2;cout << "The " << n << "th Fibonacci number is: " << fibonacci(n, m) << endl;return 0;}解释：在上面的代码中，我们定义了一个名为fibonacci的函数，该函数采用递归方法来计算第n个斐波那契数列的值。
如果n等于0，则返回0；如果n等于1，则返回m；否则，我们可以通过递归调用fibonacci函数来计算fn-1和fn-2的值，并将它们相加得到fn的值。
在main 函数中，我们定义了n和m的值，并调用fibonacci函数来计算第n个斐波那契数列的值，并输出结果。
需要注意的是，递归算法虽然简单易懂，但是可能会导致栈溢出等问题。
因此，在使用递归算法时需要谨慎考虑递归深度等因素。
c语言递归算法及经典递归例子代码实现
c语⾔递归算法及经典递归例⼦代码实现⼀、什么叫做递归？⼀个过程或 函数 在其定义或说明中有直接或间接调⽤⾃⾝的⼀种⽅法；递归函数就是直接或间接调⽤⾃⾝的函数，也就是⾃⾝调⽤⾃⼰；刚接触递归的同学，可能难以理解递归，难以理解的点可能很多，例如：1.函数为什么可以在⾃⼰的内部⼜调⽤⾃⼰呢?2.既然可以⾃⼰调⽤⾃⼰，那么递归运⾏过程中⼀定回有很多层相互嵌套，到底什么时候不再嵌套呢？3.递归运⾏过程中，相互嵌套的多层之间会有参数传递，多层之间是否会相互影响？递归两个要素1.递归边界2.递归的逻辑——递归"公式"递归的过程⼀定有参数的变化，并且参数的变化，和递归边界有关系.在难度较⼤的题⽬中，这两者均不容易直接得到.递归的种种问题，也许理解的同学可能可以⽤⼀句话解释清楚，但是不理解的同学再怎么说也没办法理解.下⾯通过⼏个简单的例⼦【体会】⼀下递归，先从【感性】的⾓度理解递归.1.Fibonacci数我们直到Fibonacci数的递推公式为：F(0)=F(1)=1,F(n)=F(n-1)+F(n-2) n>=2;这个明显地给出了递归边界n=0或1的时候F(n)的值，和递归逻辑F(n)=F(n-1)+F(n-2)，即递推公式.所以这个递归函数不难书写#includeusing namespace std;int F(int n)//函数返回⼀个数对应的Fibonacci数{ if(n0 || n1)//递归边界return 1; return F(n-1) + F(n-2);//递归公式}int main(){ //测试int n; while(cin >> n) cout << F(n) << endl;return 0;}2.阶乘阶乘的递归公式为：代码如下：#includeusing namespace std;int F(int n){ if(n==0)//递归边界return 1;return n*F(n-1);//递归公式}int main(){ int n; cin >> n; cout << F(n) << endl;return 0;}3.数组求和给⼀个数组a[]:a[0],a[1],…,a[n-1]如何⽤递归的⽅式求和？仍然是两个问题：递归边界和递归公式.递归边界是什么？⼀时不容易想到，但是我们想到了求和，多个数的求和过程是什么，x,y,z,w⼿动求和的过程是什么？步骤如下：x+y=a,任务变为a,z,w求和a+z=b,任务变为b,w求和b+w=c得出答案思考⼀下，【得出答案】这⼀步为什么就可以得出答案呢？(废话？)是因为，⼀个数不⽤相加就能得出答案.所以，递归的边界就是只有⼀个数.所以，递归边界有了，那么递归公式呢？其实⼿动计算过程中，隐含了递归公式：其中+为求两个数的和，F为求多个数的和的递归函数.代码如下：#includeusing namespace std;int F(int a[],int start,int end){ if(start==end)//递归边界return a[start];return a[start] + F(a,start+1,end);//递归公式}int main(){ int a[] = {1,2,3,4,5}; int s=0,e=4; cout << F(a,s,e) << endl;return 0;}4.求数组元素最⼤值⼿动求最⼤值的过程是什么，遍历+⽐较，过程如下：例如，求3,2,6,7,2,4的最⼤值：先设置最⼤值max=-999999，然后将max和数组元素逐个(遍历)⽐较如果a[i]>max，则更新max的值为a[i]，否则max不变，继续向后遍历，直到遍历结束.max<3，则max=3max>2，max=3不变max<6，则max=6max<7，则max=7max>2，max=7不变max>4，max=7不变遍历结束，max=7为最⼤值.和求和类似，递归的公式如下：其中max为求两个数的较⼤值函数，F为求多个数的最⼤值的递归函数.代码如下：#includeusing namespace std;#define max(a,b) (a>b?a:b)int F(int a[],int s,int e){ if(s==e) return a[s]; else if(s+1 == e)//递归边界return max(a[s],a[e]);return max(a[s],F(a,s+1,e));//递归公式}int main(){ int a[] = {5,1,4,6,2}; int s = 0,e = 4; cout << F(a,s,e) << endl;return 0;}之所以，说上⾯的⼏个例⼦是【简单例⼦】，是因为上述所有的递归都属于【单向递归】.单向递归，递归的路径就是⼀个⽅向，所以思路相对⽐较容易想到.较难的递归问题，⼀般都不是单向递归，⽽是需要使⽤【回溯】的⽅法，递归的⽅法不太容易想到.写在最后每天晚上20:00我都会开直播给⼤家免费分享C/C++学习知识和路线⽅法，C/C++交流学习群:814974917，邀请码：洋洋。
倒序数c语言递归
倒序数c语言递归
倒序数是一种数学概念，指的是从大到小依次排列的自然数序列。
如果要用C语言递归实现倒序数，可以先从一个数开始，每次减一并
打印出来，然后再调用自己来继续打印下一个数，直到打印到1为止。
具体的代码实现如下：
```
#include <stdio.h>
void reverse(int n)
{
printf("%d ", n); // 先打印当前数
if(n > 1) // 如果当前数大于1，就继续递归
reverse(n-1);
}
int main()
{
int num;
printf("请输入一个正整数：");
scanf("%d", &num);
reverse(num); // 调用递归函数
return 0;
}
```
这段代码实现了对输入的正整数进行倒序数排列并输出。
其中，reverse()函数是递归函数，用来打印当前数并调用自己来打印下一个数，直到打印到1为止。
主函数通过调用reverse()函数来实现倒序数排列。
c++欧几里得递归算法
c++欧几里得递归算法以下是使用C++实现欧几里得递归算法（辗转相除法）的示例代码：```cpp#include <iostream>// 欧几里得递归算法，计算最大公约数int euclideanAlgorithm(int a, int b) {if (b == 0) {return a;}return euclideanAlgorithm(b, a % b);}int main() {int num1, num2;std::cout << "请输入两个整数：" << std::endl;std::cin >> num1 >> num2;int gcd = euclideanAlgorithm(num1, num2);std::cout << "最大公约数为：" << gcd << std::endl;return 0;}```在上述代码中，我们定义了一个名为`euclideanAlgorithm`的函数，该函数使用欧几里得递归算法来计算两个整数的最大公约数。
函数接受两个整数参数`a`和`b`，并基于以下原理进行递归计算：1. 如果`b`等于0，则`a`即为最大公约数。
2. 否则，递归调用`euclideanAlgorithm`函数，传入`b`和`a`除以`b`的余数`a % b`作为参数。
在`main`函数中，我们首先获取用户输入的两个整数，然后调用`euclideanAlgorithm`函数来计算最大公约数，并将结果输出到控制台。
通过运行以上代码，您可以输入任意两个整数，程序将使用欧几里得递归算法来计算它们的最大公约数并输出结果。
c#递归精典实例代码
c#递归精典实例代码在程序中使用递归，可以帮助我们解决很多繁琐的问题。
同时，还能帮助我们解决很多不能预知的事。
下面，以C#代码为实例，给大家讲解如何在C#中构造并使用递归。
一、阶层的递归代码//定义一个静态的递归函数MySumstatic long MySum(long n){if (n <= 1){return 1;}else{return n * MySum(n - 1);}}//递归函数的调用，只需要传递一个参数MessageBox.Show(MySum(9));。
二、使用递归获取某文件夹中的所有子文件夹名称相关基础知识：DirectoryInfo di=new DirectoryInfo(strBaseDir);//strBaseDir是起始目录，绝对地址DirectoryInfo[] diA=di.GetDirectories();//获得了所有一级子目录FileInfo[] fiA=di.GetFiles();//获得了所有起始目录下的文件//递归函数如下public ArrayList al=new ArrayList(); //把ArrayList当成动态数组用，用于保存子目录名称public void GetAllDirList(string strBaseDir){DirectoryInfo di=new DirectoryInfo(strBaseDir);//欲查找的目录DirectoryInfo[] diA=di.GetDirectories(); //该目录下的所有一级目录for(int i=0;i<diA.Length;i++){al.Add(diA[i].FullName); //diA[i].FullName是某个子目录的绝对地址，把它记录在ArrayList中GetAllDirList(diA[i].FullName); //这里使用C#递归方法}}知识扩展：最后，把所有目录信息从ArrayList中取出来，代码如下：for(int i=0;i<al.Count;i++){textBox1.AppendText(al[i].ToString()+" "); //把目录信息输到文本框 textBox1中}。
C++递归算法实例代码
C++递归算法实例代码递归算法，总结起来具有以下⼏个特点：特点1 它有⼀个基本部分，即直接满⾜条件，输出特点2 它有⼀个递归部分，即通过改变基数（即n），来逐步使得n满⾜基本部分的条件，从⽽输出特点3 在实现的过程中，它采⽤了分治法的思想：即将整体分割成部分，并总是从最⼩的部分（基本部分）开始⼊⼿（输出），其背后的原理在于当整体递归到部分时，会保留整体的信息，部分满⾜条件输出的结果会被回溯给整体使⽤，从⽽使得整体输出结果。
特点4 每⼀步操作，整体都会将部分当作其必要的⼀个步骤，从⽽实现整体步骤的完成1.Question:本题是⽤枚举的思路来判断⼀个规定的逻辑表达式是不是永真式⾸先题⽬意思是最多不会有超过5个逻辑变量，有五种运算Definitions of K, A, N, C, and Ew x Kwx Awx Nw Cwx Ewx1 1 1 1 0 1 11 0 0 1 0 0 00 1 0 1 1 1 00 0 0 0 1 1 1其中K &A |N !C ->E 同或其中的C我们可以利⽤ !A | B 实现E利⽤==实现本题的主要难点并不在于实现我们的语句计算的⽅式难点1：递归求解表达式，在这⾥真的是有深刻的理解了递归的强⼤之处，我们本题的做法真的离不开递归，我们的做法是⼀个⼀个字符的开始枚举的递归，每个字符分出10种情况，五种变量，五种运算符，这⾥我们添加⼀个指⽰器变量表⽰我们当前的递归的位置和深度，我们不⽤设置我们的递归的终⽌条件，因为我们的表达式保证了⼀定是正确的，我们的计算结果⼀定是会有返回值的，我们的计算结果是⼀层⼀层的返回的难点2：位运算，我们本题如果不利⽤位运算的话，⾄少需要写5层循环来模拟我们的变量的所有的情况，这样太低效了，我们将我们的所有的变量封装到⼀个⼀个字节的存储器中，每次利⽤位运算提取相关的位置的数字就好了（虽然我们的表达式并不会运算所有的情况，但是⾄少不会错）Code:#include"iostream"#include"cstdio"#include"cstdlib"#include"cstring"using namespace std;int pos=0;string data;bool cal(int i){int t=pos++;switch(data[t]){case 'p':return (i >> 4)&1;case 'q':return (i >> 3)&1;case 'r':return (i >> 2)&1;case 's':return (i >> 1)&1;case 't':return i&1;case 'K':return cal(i) & cal(i);case 'A':return cal(i) | cal(i);case 'N':return !cal(i);case 'C':return !cal(i) | cal(i);case 'E':return cal(i) == cal(i);}}bool isTautology(){for(int i=0;i<=31;i++){pos=0;if(cal(i)) continue;else return false;}return true;}int main(){while(cin>>data&&data[0]!='0'){if(isTautology()) cout<<"tautology"<<endl;else cout<<"not"<<endl;}return 0;}总结以上就是本⽂关于C++递归算法实例代码的全部内容，希望对⼤家有所帮助。
c语言递归函数示例
return n+1;
else if(n==0)
return Acm(m-1,1);
else
return Acm(m-1,Acm(m,n-1));
}
int main()
{
printf("Acm(2,1)=%d\n",Acm(2,1));
printf("Acm(3,2)=%d\n",Acm(3,2));
printf("结果是：%ld\n",answer);
}
结果说明：输入61再输入5求得61的5次幂为844596301.
2编写计算学生年龄的递归函数。
#include<stdio.h>
int age(int n)
{
int c;
if(n==1)
c=10;
else
c=age(n-1)+2;
return c;
return 0;
}
结果说明：利用递归函数求得Acm（2,1）=5，Acm（3,2）=29.
实验小结：
1.编写计算X的Y次幂的递归函数getpower(int x,int )，并在主程序中实现输入输出。
#include"stdio.h"
long getpower(int x,int y)
{
if(y==1)
return x;
else
return x*getpower(x,y-1);
}
void main()
}
void main()
{
int n=5;
printf("the five student'sage is:%d years old\n",age(n));
c++递归二分法
c++递归二分法递归二分法是一种常用的算法思想，用于在有序集合中查找特定的元素。
下面是一个使用C++实现递归二分法的示例代码：```cpp#include <iostream>using namespace std;int binarySearch(int arr[], int low, int high, int x) {if (high >= low) {int mid = (low + high) / 2;if (arr[mid] == x)return mid;else if (arr[mid] < x)return binarySearch(arr, mid + 1, high, x);elsereturn binarySearch(arr, low, mid - 1, x);}elsereturn -1;}int main() {int arr[] = {1, 3, 5, 7, 9};int size = sizeof(arr) / sizeof(arr[0]);int x = 5;int result = binarySearch(arr, 0, size - 1, x);if (result != -1)cout << "元素" << x << " 在索引为" << result << " 的位置找到。
" << endl;elsecout << "元素" << x << " 未找到。
" << endl;return 0;}```在上述代码中，`binarySearch` 函数接受一个有序数组`arr`、数组的起始索引`low`、结束索引`high` 和要查找的元素`x` 作为参数。
c语言实现树先序遍历递归写法
c语言实现树先序遍历递归写法在C语言中，实现二叉树的先序遍历（根-左-右）递归写法的基本框架如下：// 假设我们有一个名为TreeNode的结构体来表示二叉树的节点
typedef struct TreeNode {
int val; // 节点值
struct TreeNode *left; // 左子节点指针
struct TreeNode *right; // 右子节点指针
} TreeNode;
// 先序遍历的递归函数
void preorderTraversal(TreeNode *root) {
// 递归终止条件：如果当前节点为空，则直接返回
if (root == NULL) {
return;
}
// 访问根节点（打印或处理节点值）
printf("%d ", root->val);
// 递归遍历左子树
preorderTraversal(root->left);
// 递归遍历右子树
preorderTraversal(root->right);
}
// 使用示例：
int main() {
// 创建并初始化二叉树（这里省略了创建过程）
// 对根节点进行先序遍历
preorderTraversal(root);
return 0;
}
上述代码中，`preorderTraversal` 函数会按照先序遍历的顺序依次访问每个节点，当遇到空节点时停止递归调用。
对于任意给定的二叉树根节点`root`，调用该函数即可完成整棵树的先序遍历。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
玩转算法与数据结构之递归算法—HIT2000鲁天伟递归算法在数据结构的树，图程序中都有应用。
那么什么是递归算法呢。
其实就是函数的自我调用。
循环的在作一件事，把一个问题分成了可以重复的子问题去处理。
递归这个词有两层含义，即递去和归来。
递去，就是函数一层一层的在调用自己，我们在这里定义调用自己的函数为父函数，被调用的是子函数。
父与子是个相对概念（参照二叉树中父结点与子结点来理解）。
递去，何时结束呢，是要设定一个结束条件。
那么这种结束条件的设置，第一种是设全局变量，全局变量随着每次自我调用在变化，当全局变量达到指定值或是全局变量参与的计算达到某个指定的值时结束。
第二种是形参变量在被调用时达到指定值或形参参与的计算达到某个值时结束。
第三种是当不满足自我调用条件时结束。
这三种结束条件结合程序的需要可以组合使用。
归来是指调用到某一次时，子程序执行结束了，子函数一层一层的把程序的执行权返还给自己的父函数，父函数执行所调用子函数的下一条命令。
简单的递归，是一个函数体中调用自己一次，复杂的是在函数体中调用自己多次。
举一个字符串逆序输出的简单递归调用的例子如下图。
图表 1 递归函数调用1、字符串逆序输出问题：将一个长为4的字符串逆序输出。
代码如下：#include<stdio.h>#define MAXSIZE 4char data[MAXSIZE];Rverse(int n){if(n<MAXSIZE){Rverse(n+1);printf("%c",data[n]);}}void main(){printf("Input %d letters”,MAXSIZE);gets(data);Rverse(0);getch();}上面这段代码完成了，长度为4的任意字符串的逆序输出。
由于打印的语句在递归函数自我调用之后，所以打印是在归来时开始的，从后向前打印。
那如果把上面代码中标红的两句代码上下换个位置，那么就是正序打印了，也就是在递归函数自我调用之前打印，在递去的过程中打印。
递去过程中正序打印，归来过程中是逆序打印。
正序打印递归调用如下：Rverse(int n){if(n<MAXSIZE){printf("%c",data[n]);Rverse(n+1);}}修改成如下while循环代码Rverse(int n){while(n<MAXSIZE){printf("%c",data[n]);n=n+1;}}上述两段代码执行效果相同。
2、斐波那契级数问题求解F(n)=F(n-1)+F(n-2); n>=3,F(1)=1,F(2)=1 代码如下：#include<stdio.h>int Fib(int N){if(N<=1)return N;elsereturn Fib(N-1)+Fib(N-2);}int n;int result;do{printf("Input n ,if you want to quit please input -1\n"); scanf("%d",&n);if(n==-1)break;result=Fib(n);printf("Fib(%d) is %d\n",n,result);}while(1);getch();}3、阶乘问题：N！=N*(N-1)! 1!=1 代码如下：#include<stdio.h>int NJ(int n){if(n==1)return1;else{return n*NJ(n-1);}}void main(){int n;int result;do{printf("Input n you want to caculate n!,Input -1 to quit\n"); scanf("%d",&n);if(n==-1)break;result=NJ(n);printf("%d! is %d\n",n,result);}while(1);getch();}4、乘法运算：M*N=M*（N-1）N=1时返回M 代码如下：#include<stdio.h>int Multiply(int M,int N){if(N==1)return M;elsereturn M+Multiply(M,N-1);}int M,N;int a;int result;do{printf("Pleaese input the data you want to Multiply format:M N.Ifquit input -1 -1\n");scanf("%d %d",&M,&N);result=Multiply(M,N);if(M==-1)break;printf("%d * %d is %d\n",M,N,result);}while(1);getch();}5、组合的计算，从m个物品中选出n个物品有几种选法C n m=C n m-1+C n-1 m-1m>=n n>=0 #include<stdio.h>int zuhe(int m,int n){if(m==n || n==0)return1;elsereturn zuhe(m-1,n)+zuhe(m-1,n-1);}void main(){int m,n;int result;do{printf("Please input format:m n ;（m>=n) if you want to quit input -1 -1 \n");scanf("%d %d",&m,&n);if(m==-1)break;else if(m<n){continue;}else{result=zuhe(m,n);printf("C %d %d is %d\n",m,n,result);}}while(1);getch();}6、求两个数的最大公因数。
#include<stdio.h>int GCD(int M,int N){if(N==0)return M;elsereturn GCD(N,M%N);}void main(){int m,n;int result;do{printf("Please input M N format:M N,(M>=N)if you want to quit input -1 -1\n");scanf("%d %d",&m,&n);if(m==-1)break;if(m<n)continue;else{result=GCD(m,n);printf("Zui da gong yin zi is %d\n",result);}}while(1);getch();}7、汉诺塔问题，把n个圆盘，从A柱通过B柱全部移到C柱，圆盘在A柱上从上到下越来越大。
在移动的过程中，大圆盘不能放在小圆盘上。
图表 2 汉诺塔示意图#include<stdio.h>int count=0;void hanoi(int n,char a,char b,char c){if(n!=0){hanoi(n-1,a,c,b);count++;printf("step %d:Move %d %c->%c\n",count,n,a,c);hanoi(n-1,b,a,c);}}void main(){int n;do{count=0;printf("Please input n,if you want to quit,please input -1\n"); scanf("%d",&n);if(n==-1)break;elsehanoi(n,'A','B','C');}while(1);getch();}上述代码运行一下，对于n个圆盘的搬运，搬运的总次数是2n-1次。
8、迷宫问题，从指定的入口进，从指定的出口出。
代码实现如下：#include<stdio.h>int chess[7][7]={0,1,1,1,1,1,1,1,0,1,1,0,1,1,1,0,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,0,0,0,0,1,};int migong(int x,int y){if(x==6&& y==5){chess[x][y]=2;return1;}if(x<0|| x>6|| y<0|| y>6)else{if(chess[x][y]==0)/*0表示可以走*/chess[x][y]=2;/*用2标记已走过，避免走回头路*/elsereturn0;if(migong(x-1,y))return1;if(migong(x-1,y+1))return1;if(migong(x,y+1))return1;if(migong(x+1,y+1))return1;if(migong(x+1,y))return1;if(migong(x+1,y-1))return1;if(migong(x,y-1))return1;if(migong(x-1,y-1))return1;chess[x][y]=3;/*标3以后不再考虑这个位置，这个位置8面都不通*/return0;}}void main(){int i,j;migong(0,0);for(i=0;i<7;i++){for(j=0;j<7;j++){printf("%d ",chess[i][j]);}printf("\n");}getch();}9、N皇后问题，在一个N*N的棋盘上，放置N个皇后，使以每个皇后的为中心的八个方向上都没有其它皇后存在。
程序实现如下：#include<stdio.h>#define MAX 10char chess[MAX][MAX];/*===判断x行，y列这个位置是否能放皇后===*/int Place(int x,int y){int i,j;if(chess[x][y]=='Q') return0;j=y-1;while(j>=0){if(chess[x][j--]=='Q') return0;}j=y+1;while(j<MAX){if(chess[x][j++]=='Q') return0;}i=x-1;while(i>=0){if(chess[i--][y]=='Q') return0;}i=x+1;while(i<MAX){if(chess[i++][y]=='Q') return0;}i=x-1;j=y-1;while(i>=0&& j>=0){if(chess[i--][j--]=='Q') return0;}i=x+1;j=y-1;while(i<MAX && j>=0){if(chess[i++][j--]=='Q') return0;}i=x+1;j=y+1;while(i<MAX && j<MAX){if(chess[i++][j++]=='Q') return0;}i=x-1;j=y+1;while(i>=0&& j<MAX){if(chess[i--][j++]=='Q')return0;}return1;}int Queen(int x,int y,int N){int i,j;int result=0;chess[x][y]='Q';if(N==MAX)return1;else{for(i=0;i<MAX;i++){for(j=0;j<MAX;j++){if(Place(i,j)){result=Queen(i,j,N+1);if(result==1)return1;}}}chess[x][y]='X'; /*尝试了所有点，都无法再放一个皇后，这个位置不能放Q*/ return0;}}void main(){int i,j,x,y;do{for(i=0;i<MAX;i++){for(j=0;j<MAX;j++){chess[i][j]='X';}}printf("Input x,y you put Queen first.If you want to quit,please input -1 -1\n");scanf("%d %d",&x,&y);if(x==-1)break;else{Queen(x,y,1);for(i=0;i<MAX;i++){for(j=0;j<MAX;j++){printf("%c ",chess[i][j]);}printf("\n");}}}while(1);getch();}我自己使用的环境是运用notepad++编辑，在notepad++里调用Dev-CPP里的编译和运行。