数据结构实验：递归程序设计-精简

python递归实验报告Python递归实验报告引言：递归是计算机科学中一种重要的编程技术，它在解决问题时能够简化代码逻辑，并提高代码的可读性和可维护性。

Python作为一种高级编程语言，提供了强大的递归支持，本文将通过实验来探讨Python递归的特性和应用。

一、递归的概念与原理递归是一种通过调用自身的方式解决问题的方法。

在递归过程中，问题被分解为更小的子问题，直到子问题足够简单可以直接求解。

递归的基本原理是将一个大问题转化为一个或多个与原问题相似但规模更小的子问题，通过递归调用解决子问题，最终得到原问题的解。

二、递归的实现方式在Python中，递归可以通过函数调用自身来实现。

递归函数通常包含两个部分：基准情况和递归情况。

基准情况是递归函数的结束条件，当满足基准情况时，递归函数将不再调用自身，而是返回一个特定的值。

递归情况是指递归函数在未满足基准情况时，调用自身来处理更小规模的子问题。

三、递归的应用场景1. 阶乘计算阶乘是指从1到给定数之间所有整数的乘积。

递归可以很方便地实现阶乘计算，如下所示：```pythondef factorial(n):if n == 0:return 1else:return n * factorial(n-1)```2. 斐波那契数列斐波那契数列是指从第三项开始，每一项都等于前两项之和。

递归可以很容易地实现斐波那契数列的计算，如下所示：```pythondef fibonacci(n):if n <= 1:return nelse:return fibonacci(n-1) + fibonacci(n-2)```3. 文件夹遍历递归还可以用于文件夹的遍历，通过递归调用实现对文件夹内所有文件的查找和处理。

例如，可以编写一个函数来计算指定文件夹下所有文件的总大小：```pythonimport osdef get_folder_size(folder):size = 0for item in os.listdir(folder):item_path = os.path.join(folder, item)if os.path.isfile(item_path):size += os.path.getsize(item_path)elif os.path.isdir(item_path):size += get_folder_size(item_path)return size```四、递归的优缺点递归的优点在于能够简化问题的解决过程，提高代码的可读性和可维护性。

c语⾔递归算法实验报告,递归算法的设计与实现实验报告-read.doc递归算法的设计与实现实验报告-read递归算法的设计与实现实验报告⼀、实验⽬的：a)掌握递归算法的基本思想及其与数学归纳法的关系;b)掌握递归算法设计与实现。

⼆、实验内容a)⽤递归算法计算n!；b)⽤递归⽅法求⾮负整数a和b(a,b不全为0)的最⼤公约数。

三、实验要求a)⽤伪代码计算n!和求⾮负整数a,b(a,b不全为零)的最⼤公约数的递归算法；b)⽤C＋＋语⾔实现算法并测试通过；c)⽐较采⽤欧⽒算法和递归算法求⾮负a,b(a,b不全为零)的最⼤公约数的执⾏效率。

四、(⼀)使⽤递归算法求n!的伪代码表⽰：1.Procedurefactorial (n)2. if n= = 0 then3. return (1)4. return (n * factorial (n-1))5. end(⼆)使⽤递归算法求⾮负整数a和b(a,b不全为0)的最⼤公约数的伪代码表⽰：输⼊：a和b(不全为0的⾮负整数)输出：a和b的最⼤公约数1. Procedure gcd_recurs (a, b)2. if a3. swap (a, b)4. if b = 0 then5. return (a)6. a 除以 b 得到 a = bq + r ，0 ￡ r < b7. redurn (gcd_recurs (b, r))8. end gcd_recurs五、(⼀)使⽤递归算法求n!的C语⾔实现：#include"stdio.h"long fac(int n){long result;if(n==0||n==1)result=1;elseresult=n*fac(n-1);return result;}main(){int x;long f;printf("please input one numbers: ");scanf("%d",&x);if(x<=0)printf("ERROR!\n");else{f=fac(x);printf("%d!=%ld\n",x,f);}}结果截图：(⼆)使⽤递归算法求⾮负整数a和b(a,b不全为0)的最⼤公约数的C语⾔实现：#include"stdio.h"int gcd(int a,int b){int temp,c;if(a{temp=a;a=b;b=temp;}if(b==0)return a;else{c=a%b;return(gcd(b,c));}}main(){int a,b;printf("please input two numbers:\n");scanf("%d%d",&a,&b);printf("gcd(%d,%d)=%d\n",a,b,gcd(a,b));}结果截图：六、⽐较采⽤欧⽒算法和递归算法求⾮负a,b(a,b不全为零)的最⼤公约数的执⾏效率。

递归算法实验报告篇一：递归算法的设计和实现的实验报告班级学号姓名实验组别试验日期室温报告日期成绩报告内容：（目的和要求、原理、步骤、数据、计算、小结等）实验名称：递归算法的设计和应用实验目的：1. 掌握递归算法的实现。

2. 实现递归算法的应用。

实验环境（硬/软件要求）：Windows XX, Visual C++ 6.0实验内容：用递归算法实现前n个自然数的累加和与平均数【C语言源程序】#includeint Digui(int n)//设计递归算法功能为求前n个整数的和//{if(n==0)return 0;if(n==1)return 1;else return Digui(n-1)+n;}int main(){int n;printf("请输入n的值：\n");scanf("%d",&n);printf("计算结果为：\n%d\n",Digui(n));printf("这n个数的平均数是：\n%f\n",(float)Digui(n)/n);}篇二：数据结构- 递归算法实验报告实验报告实验五递归算法实验目的：1.熟悉递归算法的实现过程及实现机理；2.熟练并掌握递归算法的设计方法；3.了解递归算法到非递归算法的转换。

实验原理：高级程序语言函数调用原理；递归算法的设计方法。

实验内容：6-14 折半查找问题。

折半查找问题的描述见6.1节，折半查找问题的递归算法见例6-2。

要求：（1）设计折半查找问题的循环结构算法；（2）设计一个查找成功的例子和一个查找不成功的例子，并设计测试主程序；（3）设计一个包含10000个数据元素的查找成功的例子，然后分别调用循环结构的查找算法和递归结构的查找算法，并测试出两种算法在计算机上的实际运行时间。

实验结果：（1）折半查找问题的循环结构算法程序为：int Csearch(int test[],int x,int low,int high) {int i;for( i=0;i {if(x==test[i]) return i;else if(x>test[i])low=i+1;else high=i-1;}if(i>=high) return -1;}（2）①查找成功的例子：#includeint Csearch(int test[],int x,int low,int high) {int i;for( i=0;i {if(x==test[i]) return i;else if(x>test[i])low=i+1;else high=i-1;}if(i>=high) return -1;}int main(){int a[10]={1,2,3,4,5,6,7,8,9,10};int x=6,flag ;int low=0,high=10;flag=Csearch(a,x,0,10);if(flag==-1) printf("searching is failed!\n"); else printf("searching is success!\n") ;printf("This program is made by 10273206\n"); }运行结果为：②查找失败的例子为：#includeint Csearch(int test[],int x,int low,int high) {int i;for( i=0;i {if(x==test[i]) return i;else if(x>test[i])low=i+1;else high=i-1;}if(i>=high) return -1;}int main(){int a[10]={1,2,3,4,5,6,7,8,9,10};int x=11,flag ;int low=0,high=10;flag=Csearch(a,x,0,10);if(flag==-1) printf("searching is failed!\n"); else printf("searching is success!\n") ;printf("This program is made by 10273206\n"); }运行结果为：（3）程序为：#include#includeint 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 Bsearch(a,x,low,mid-1);elseBsearch(a,x,mid+1,high);}int Csearch(int test[],int x,int low,int high) {int i;for( i=0;i {if(x==test[i]) return i;else if(x>test[i])low=i+1;else high=i-1;}if(i>=high) return -1;}int main(){time_t start,end;double dif;int Bsearch(int a[],int x,int low,int high);int Csearch(int test[],int x,int low,int high);int a[10000],x,y,i,bn,flag;int low=0,high=10000,mid=0;printf("please enter number:\n");scanf("%ld",&x);for( i=0;i a[i]=i+1;time(&start);bn=Bsearch(a,x,0,10000);if(bn==-1) printf("%d is not in a !\n",x);else printf("%d is in a,suffix is %d\n",x,bn);time(&end);dif=difftime(end,start);printf("di gui method use time is:%f seconds\n",dif);time(&start);flag=Csearch(a,x,0,10000);if(flag==-1) printf("%ld is not in a !\n",x);else printf("%d is in a,suffix is %d\n",x,flag);time(&end);dif=difftime(end,start);printf("xun huan method use time is :%f seconds\n",dif);printf("This program is made by 10273206\n");}运行结果为：总结与思考通过实验我初步了解了递归算法到非递归算法的转换，递归算法在数据结构存储中用处很大。

实验一循环与递归一、实验目的进一步理解循环与递归程序设计的基本思想，充分利用基本的机械化操作设计高质量的算法。

二、实验要求1、上机前的准备工作根据实验内容中所给题目，利用所学循环与递归的基本设计思想设计算法并编写好上机程序，以提高上机效率；2、独立上机，输入、调试所编程序；3、上机结束后，写出实验报告。

4、上机时间：2学时三、实验内容1、核反应堆中有α和β两种粒子，每秒钟内一个α粒子可以反应产生3个β粒子，而一个β粒子可以反应产生1个α粒子和2个β粒子。

若在t=0时刻的反应堆中只有一个α粒子，求在t时刻的反应堆中α粒子和β粒子数。

#include <iostream>using namespace std;int X(int n);int Y(int n){if(n==1) return 3;return 3*X(n-1)+2*Y(n-1);}int X(int n){if(n==1) return 0;return Y(n-1);}void main(){int t;cout<<"请输入t的值：";cin>>t;cout<<"粒子的个数依次为："<<X(t)<<","<<Y(t)<<endl;}运行结果：2、求这样的两位数据：五位数=3*四位数，9个数字各不相同#include <iostream>using namespace std;int main(){long x, y1, y2;int p[10],i,t,k;for (x=3334;x<=9999; x++){for(i=0; i<=9; i=i+1)p[i]=0;y1=3*x ;k=0;y2=10000*y1+x;while(y2>=0){t=y2 % 10;if(p[t]==1)break;y2=y2/10;p[t]++;k++;}if(k==9)cout<<"四位数："<<x<<","<<"五位数："<< y1<<endl;}}运行结果：3、A、B、C、D、E五人为某次竞赛的前五名，他们在比赛前猜名次：A说：B得第三名，C得第五名B说：D得第二名，E得第四名C说：B得第一名，E得第四名D说：C得第一名，B得第二名E说：D得第二名，A得第三名结果每个人都猜对了一半，实际名次是什么？#include <iostream>using namespace std;void main( ){int a,b,c,d,e;for( a=1;a<=5;a++)for( b=1;b<=5;b++)if (a!=b)for( c=1;c<=5;c++)if (c!=a&&c!=b)for( d=1;d<=5;d++)if (d!=a && d!=b && d!=c ){e=15-a-b-c-d;if (e!=a&&e!=b&& e!=c&&e!=d)if(((c==5)+(b==3))==1&&((d==2)+(e==4))==1&& ((b==1)+(e==4))==1&& ((c==1)+(b==2))==1&& ((d==2)+(a==3))==1)cout<< "a,b,c,d,e="<<a<<b<<c<<d<<e<<endl;}}运行结果：4、从下列题中任选其一：1）国王分财产。

算法设计与分析：递归与分治法-实验报告(总8页)实验目的：掌握递归与分治法的基本思想和应用，学会设计和实现递归算法和分治算法，能够分析和评价算法的时间复杂度和空间复杂度。

实验内容：1.递归算法的设计与实现3.算法的时间复杂度和空间复杂度分析实验步骤：1）递归定义：一个函数或过程，在其定义或实现中，直接或间接地调用自身的方法，被成为递归。

递归算法是一种控制结构，它包含了解决问题的基础情境，也包含了递归处理的情境。

2）递归特点：递归算法具有以下特点：①依赖于递归问题的部分解被划分为若干较小的部分。

②问题的规模可以通过递推式递减，最终递归终止。

③当问题的规模足够小时，可以直接求解。

3）递归实现步骤：①确定函数的定义②确定递归终止条件③确定递归调用的过程4）经典实例：斐波那契数列递推式：f(n) = f(n-1) + f(n-2)int fib(int n) {if (n <= 0)return 0;else}5）优化递归算法：避免重复计算例如，上述斐波那契数列的递归算法会重复计算一些中间结果，影响效率。

可以使用动态规划技术，将算法改为非递归形式。

int f1 = 0, f2 = 1;for (int i = 2; i <= n; i++) {f1 = f2;使用循环避免递归，重复计算可以大大减少，提高效率。

1）分治算法的定义：将原问题分解成若干个规模较小且类似的子问题，递归求解子问题，然后合并各子问题得到原问题的解。

2）分治算法流程：②将问题分解成若干个规模较小的子问题。

③递归地解决各子问题。

④将各子问题的解合并成原问题的解。

3）分治算法实例：归并排序归并排序是一种基于分治思想的经典排序算法。

排序流程：②分别对各子数组递归进行归并排序。

③将已经排序好的各子数组合并成最终的排序结果。

实现源代码：void mergeSort(int* arr, int left, int right) {if (left >= right)while (i <= mid && j <= right)temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];temp[k++] = arr[i++];1) 时间复杂度的概念：指完成算法所需的计算次数或操作次数。

递归实验报告递归实验报告引言递归是计算机科学中一种重要的概念，它在问题解决和算法设计中起到了关键的作用。

本文将对递归进行实验探究，通过编写一些递归函数来解决不同类型的问题，并对其性能和应用进行评估。

一、递归的基本原理递归是一种通过调用自身来解决问题的方法。

它包含两个重要的要素：基本情况和递归情况。

基本情况是指问题可以直接解决的情况，而递归情况则是指问题需要通过调用自身来解决的情况。

在递归函数中，我们需要确保递归情况能够最终达到基本情况，否则会出现无限递归的情况。

二、递归的应用1. 阶乘计算阶乘是一个常见的递归应用。

我们可以定义一个递归函数来计算一个正整数的阶乘。

例如，计算5的阶乘可以通过调用函数fact(5)来实现。

在函数内部，我们将问题转化为计算4的阶乘，并不断递归下去，直到问题达到基本情况，即计算1的阶乘为止。

2. 斐波那契数列斐波那契数列也是递归的一个经典应用。

该数列的定义是：第一个和第二个数为1，从第三个数开始，每个数都是前两个数之和。

我们可以编写一个递归函数来计算斐波那契数列中的第n个数。

在函数内部，我们将问题转化为计算第n-1个数和第n-2个数的和，并不断递归下去，直到问题达到基本情况，即计算第一个或第二个数为止。

三、递归的性能评估递归在解决某些问题时可以提供简洁的解决方案，但也可能带来性能上的问题。

递归函数的调用涉及到函数的压栈和弹栈操作，这会增加程序的开销。

在处理大规模问题时，递归可能导致栈溢出的问题。

因此，在使用递归时，我们需要仔细评估其性能，确保其适用于当前的问题规模。

四、递归的优化技巧为了提高递归函数的性能，我们可以采用一些优化技巧。

其中一种常见的优化方法是尾递归优化。

尾递归是指递归函数在递归调用时，只返回递归函数本身的结果，而不进行其他的计算。

这样可以减少函数调用的开销，提高程序的执行效率。

五、结论递归是一种强大的问题解决方法，它在计算机科学中有着广泛的应用。

通过实验我们可以发现，递归函数可以提供简洁的解决方案，但在处理大规模问题时需要注意其性能问题。

递归实验报告分析总结递归是一种非常重要的编程思想和技巧，对于理解和解决问题具有非常大的帮助。

通过递归，我们可以将一个问题分解成为更小的子问题，从而简化问题的复杂度和难度。

在本次实验中，我深入学习了递归的原理和应用，并实践了一些递归算法。

通过这些实验，我对递归有了更深入和全面的理解，掌握了递归的使用方法和注意事项。

在实验中，我首先学习了递归的概念和原理。

递归是一种将大问题分解成小问题的算法思想，通过不断调用自己来解决问题。

递归算法通常包含两个部分：基本情况和递归情况。

基本情况是递归终止的条件，递归情况是递归调用自身的条件。

通过合理设置这两个条件，我们可以确保递归算法能够得到正确的结果并正常终止。

然后，我练习了递归的应用。

在实验中，我实现了一些常见的递归算法，如计算阶乘、斐波那契数列等。

通过这些实践，我更加熟悉了递归的写法和思维模式。

递归算法的核心思想是将大问题分解成小问题，然后通过递归调用解决这些小问题，最终得到整个问题的解。

这种思维模式非常灵活和高效，对于解决一些复杂和抽象的问题非常有帮助。

在实验过程中，我也遇到了一些递归算法的常见问题和注意事项。

例如，递归算法容易出现堆栈溢出的问题，因为每次递归调用都会占用一定的内存空间，如果递归层数过多，就容易导致栈溢出。

为了解决这个问题，我们可以在递归算法中加入递归深度的限制条件，或者考虑使用迭代算法等其他算法思想。

此外，递归算法的时间复杂度一般比较高，因为递归算法需要不断的调用自身，导致函数的调用次数非常多。

为了提高递归算法的效率，我们可以尝试使用尾递归优化、记忆化搜索等技巧。

尾递归优化是指在递归函数的最后一步调用中，直接返回递归函数的结果，而不再进行其他操作。

这样可以有效避免函数调用的堆栈积累，提高程序的性能。

总的来说，通过本次递归实验，我对递归算法有了更深入的理解和掌握。

递归是一种非常强大和灵活的算法思想，可以用来解决各种复杂的问题。

通过合理设置递归的基本情况和递归情况，我们可以通过递归算法简化问题的复杂度和难度，高效地解决问题。

递归算法的实验报告引言递归算法是计算机科学中一种重要的算法思想，通过将问题分解为更小的子问题并逐步解决，从而实现问题的求解。

本实验旨在探讨递归算法的原理，并通过具体例子来说明递归算法的应用。

算法原理1.递归定义：递归算法通过将问题分解为规模更小的子问题来解决。

通常，递归算法会有一个或多个基准情况，当问题的规模达到基准情况时，递归调用将停止。

2.递归调用：在递归算法中，函数会调用自身来解决规模更小的子问题。

通过递归调用，问题的规模逐步缩小，直到达到基准情况。

3.递归终止条件：递归算法必须定义一个或多个递归终止条件，当满足这些条件时，递归调用将停止。

实验步骤为了更好地理解递归算法的应用，我们选取了斐波那契数列作为示例，并通过递归算法计算斐波那契数列的第n项。

1.确定递归终止条件：斐波那契数列的第0项和第1项为预定义的基准情况，所以递归终止条件为n=0或n=1。

2.实现递归算法：创建一个递归函数fibonacci(n)，用于计算斐波那契数列的第n项。

3.处理递归调用：在递归函数中，当n大于1时，调用fibonacci(n-1)和fibonacci(n-2)来计算第n-1项和第n-2项，并将它们相加得到第n项的值。

4.返回计算结果：将计算得到的结果返回给调用者。

实验结果通过上述步骤，我们成功实现了递归算法来计算斐波那契数列的第n项。

以下是一些示例结果：•当n=0时，第0项为0。

•当n=1时，第1项为1。

•当n=2时，第2项为1。

•当n=3时，第3项为2。

•当n=4时，第4项为3。

我们还可以通过增大n的值来计算更多项的斐波那契数列。

实验总结通过本次实验，我们深入了解了递归算法的原理和应用。

递归算法通过将问题分解为更小的子问题，从而解决复杂的计算任务。

然而，递归算法也存在一些缺点，如效率较低和可能出现栈溢出的风险。

因此，在实际应用中需要谨慎使用递归算法，并针对具体问题选择合适的算法思想。

希望通过本次实验，读者对递归算法有了更深入的理解，并能够灵活运用递归算法解决实际问题。

《数据结构》课程设计迷宫求解班级：学号：姓名：指导老师：迷宫求解1、问题描述输入一个任意大小的迷宫数据，用递归和非递归两种方法求出一条走出迷宫的路径，并将路径输出。

2、设计思路从入口出发，按某一方向向前探索，若能走通并且未走过，即某处可以到达，则到达新点，否则试探下一个方向；若所有的方向均没有通路，则沿原路返回前一点，换下一个方向再继续试探，直到找到一条通路，或无路可走又返回入口点。

在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一点以便继续从下一个方向向前试探，则需要用一个栈（递归不需要）保存所能够到达的每一点的下标及从该点前进的方向。

设迷宫为m行n列，利用maze[m][n]来表示一个迷宫，maze[i][j]=0或1；其中：0表示通路，1表示不通，当从某点向下试探时，中间点有四个方向可以试探，而四个角点有两个方向，其他边缘点有三个方向，为使问题简单化，用maze[m+2][n+2]来表示迷宫，而迷宫的四周的值全部为1，这样做使问题简单了，每个点的试探方向全部为4，不用再判断当前点的试探方向有几个。

3、数据结构设计在上述表示迷宫的情况下，每个点有4个方向去试探，如当前点的坐标（x，y），与其相邻的4个点的坐标都可根据与该点的相邻方位而得到。

因为出口在（m，n），因此试探顺序规定为：从当前位置向前试探的方向为从正东沿顺时针方向进行。

为了简化问题，方便求出新点的坐标，将从正东开始沿顺时针进行的4个方向的坐标增量放在一个结构数组move[4]中，在move数组中，每个元素有两个域组成，x为横坐标增量，y为纵坐标增量。

这样对move设计会很方便地求出从某点（x，y）按某一方向v(0<=v<=3)到达的新点（i，j）的坐标：i=x+move[v].x;j=y+move[v].y;当到达了某点而无路可走时需返回前一点，再从前一点开始向下一个方向继续试探。

因此，压入栈中的不仅是顺序到达的各点的坐标，而且还要有从前一点到达本点的方向。

一、实验背景递归是一种编程技巧，通过函数自身调用自身的方式实现算法的求解。

递归算法在解决一些具有递归特性的问题上具有独特的优势，如斐波那契数列、汉诺塔等。

本实验旨在通过递归算法解决实际问题，加深对递归的理解和应用。

二、实验目的1. 掌握递归算法的基本思想和方法；2. 熟悉递归算法的编写和调试；3. 分析递归算法的时间复杂度和空间复杂度；4. 学会运用递归算法解决实际问题。

三、实验内容1. 斐波那契数列求解2. 汉诺塔问题3. 递归求解组合问题四、实验过程1. 斐波那契数列求解（1）问题描述：给定一个正整数n，求斐波那契数列的第n项。

（2）递归算法实现：```pythondef fibonacci(n):if n <= 1:return nelse:return fibonacci(n-1) + fibonacci(n-2)```（3）分析：斐波那契数列递归算法的时间复杂度为O(2^n)，空间复杂度为O(n)。

2. 汉诺塔问题（1）问题描述：有n个大小不同的盘子，初始放置在A柱子上，按照从小到大的顺序排列。

现要求将所有盘子移动到C柱子上，在移动过程中，每次只能移动一个盘子，且在移动过程中，大盘子不能放在小盘子上面。

（2）递归算法实现：```pythondef hanoi(n, source, target, auxiliary):if n == 1:print("Move disk 1 from", source, "to", target)returnhanoi(n-1, source, auxiliary, target)print("Move disk", n, "from", source, "to", target)hanoi(n-1, auxiliary, target, source)```（3）分析：汉诺塔递归算法的时间复杂度为O(2^n)，空间复杂度为O(n)。

python递归实验报告《Python递归实验报告》引言Python是一种功能强大的编程语言，它具有许多强大的特性，其中之一就是递归。

递归是一种解决问题的方法，通过将问题分解成更小的子问题来解决。

在本实验报告中，我们将探讨Python中递归的使用，并进行一些实验来展示其强大的功能。

递归的基本概念在计算机科学中，递归是一种解决问题的方法，其中函数调用自身来解决更小的子问题。

递归函数通常包含两部分：基本情况和递归情况。

基本情况是指最小的问题实例，它们可以直接解决而不需要再次调用函数。

递归情况是指问题的一般情况，它需要调用函数本身来解决更小的子问题。

Python中的递归Python是一种非常适合使用递归的语言，因为它具有简洁的语法和灵活的函数调用机制。

在Python中，函数可以直接调用自身，这使得编写递归函数变得非常简单。

此外，Python还提供了一些内置的递归函数，如`factorial`和`fibonacci`等，这些函数可以帮助我们更好地理解递归的工作原理。

实验设计与结果为了展示Python中递归的使用，我们设计了一些实验来演示其功能。

首先，我们编写了一个递归函数来计算阶乘。

通过不断调用函数本身，并将问题分解成更小的子问题，我们成功地计算出了给定数字的阶乘。

接下来，我们编写了一个递归函数来生成斐波那契数列。

通过递归调用函数来计算前两个数的和，并将结果作为下一个数的输入，我们成功地生成了斐波那契数列。

结论通过本次实验，我们深入了解了Python中递归的使用。

我们发现递归是一种非常强大的解决问题的方法，它可以帮助我们简洁地解决复杂的问题。

然而，递归也需要谨慎使用，因为它可能会导致性能问题和栈溢出。

因此，在实际应用中，我们需要仔细考虑是否使用递归来解决问题。

总而言之，Python中的递归是一种非常有用的功能，它可以帮助我们解决各种复杂的问题。

通过深入研究和实验，我们可以更好地理解递归的工作原理，并充分发挥其潜力。

递归实验报告篇一：字符串,递归实验报告宁波工程学院电信学院计算机教研室实验报告一、实验目的1）熟悉串的定义和串的基本操作。

2）加深对串数据结构的理解，逐步培养解决实际问题的编程能力。

3）熟悉递归的定义和递归的算法设计。

4）加深对递归算法的理解，逐步培养解决实际问题的编程能力。

二、实验环境装有Visual C＋＋6.0的计算机。

三、实验内容1、凯撒加密算法凯撒密码（caeser）是罗马扩张时期朱利斯?凯撒（Julius Caesar）创造的，用于加密通过信使传递的作战命令。

它将字母表中的字母移动一定位置而实现加密。

他的原理很简单，说到底就是字母与字母之间的替换。

每一个字母按字母表顺序向后移3位，如a加密后变成d，b加密后变成e，······x加密后变成a，y加密后变成b，z加密后变成c。

例如：“baidu”用凯撒密码法加密后字符串变为“edlgx”。

试写一个算法，将键盘输入的文本字符串（只包含a～z 的字符）进行加密后输出。

另写一个算法，将已加密后的字符串解密后输出。

提示：? 如果有字符变量c加密后则＝’a’＋（c-‘a’＋3）％26? 采用顺序结构存储串，键盘输入字符串后保存到顺序串中；输出用顺序串的输出函数。

程序：#include#define MaxSize 100typedef struct //串的类型定义char ch[MaxSize];//存放串字符int len; //串长}SqString;void SetString(SqString &s) //设置源码{int i;printf("请输入原字符串：");scanf("%s",s.ch);for(i=0;s.ch[i]!='\0';i++); //计算串的长度s.len=i;}void TranString(SqString s,SqString &t)//开始加密{int i;for(i=0;i {if(s.ch[i]>='a'&&s.ch[i] t.ch[i]='a'+(s.ch[i]-'a'+3)%26; //将每一个字母按字母表顺序向后移3位elset.ch[i]=s.ch[i];//如果字符不是字母a~z，则原样保留}t.len=s.len;}void RecoverString(SqString s,SqString &t) //开始解密{int i;for(i=0;i {if(s.ch[i]>='d'&&s.ch[i] t.ch[i]=s.ch[i]-3;else if(s.ch[i]>='a'&&s.ch[i] t.ch[i]=s.ch[i]+23;elset.ch[i]=s.ch[i]; //如果字符不是字母a~z，则原样保留 }t.len=s.len;}void DispString(SqString s) //输出字符串int i=0;while(i {printf("%c",s.ch[i]); //字母的逐个输出i++;}printf("\n");}int main(){SqString s1,s2,s3; //s1是源码，s2是加密后密码，s3是解密后密码SetString(s1); //输入字符串DispString(s1); //输出字符串TranString(s1,s2);//加密DispString(s2); //加密后输出字符串RecoverString(s2,s3);//解密DispString(s3); //解密后输出字符串return 0;}按实验要求首先定义顺序串，实验的难点在于密码的加密和解密的实现，特别是再解密时，字母的溢出问题，在参考网上程序后很好地解决了这个问题。

一、实验目的1. 理解递归算法的基本概念和原理。

2. 掌握递归算法的设计方法和实现技巧。

3. 通过具体实例，加深对递归算法在实际问题中的应用。

二、实验内容本次实验主要针对递归算法在排序、查找和数学问题中的应用进行探讨。

1. 排序问题（1）实验目的：使用递归算法实现快速排序。

（2）实验原理：快速排序是一种分而治之的排序算法。

其基本思想是：选取一个基准元素，将数组分为两个子数组，一个子数组的所有元素都比基准元素小，另一个子数组的所有元素都比基准元素大，然后递归地对两个子数组进行快速排序。

（3）实验步骤：① 定义一个递归函数，用于实现快速排序；② 在递归函数中，选择基准元素，并根据基准元素将数组分为两个子数组；③ 递归地对两个子数组进行快速排序；④ 输出排序后的数组。

（4）实验结果：通过实际编程，验证快速排序算法的正确性。

2. 查找问题（1）实验目的：使用递归算法实现折半查找。

（2）实验原理：折半查找是一种基于二分查找思想的递归查找算法。

其基本思想是：将待查找的序列分为两个子序列，然后确定目标值所在子序列，递归地对子序列进行查找。

（3）实验步骤：① 定义一个递归函数，用于实现折半查找；② 在递归函数中，根据目标值与中间元素的比较结果，确定目标值所在子序列；③ 递归地对子序列进行查找；④ 输出查找结果。

（4）实验结果：通过实际编程，验证折半查找算法的正确性。

3. 数学问题（1）实验目的：使用递归算法求解斐波那契数列。

（2）实验原理：斐波那契数列是一个著名的数列，其递推公式为：F(n) = F(n-1) + F(n-2)，其中F(1) = 1，F(2) = 1。

（3）实验步骤：① 定义一个递归函数，用于计算斐波那契数列的第n项；② 在递归函数中，根据n的值，计算斐波那契数列的第n项；③ 输出斐波那契数列的第n项。

（4）实验结果：通过实际编程，验证斐波那契数列递归算法的正确性。

三、实验总结1. 通过本次实验，我们对递归算法的基本概念和原理有了更深入的理解。

递归算法的实验报告递归算法的实验报告引言：递归算法作为一种重要的问题解决方法，在计算机科学领域发挥着重要的作用。

本次实验旨在通过实际编程实现递归算法，并对其性能进行评估和分析，以探讨递归算法的优势和局限性。

一、递归算法的基本原理递归算法是一种将问题分解为更小规模的子问题来解决的方法。

其基本原理是在解决一个问题的过程中，调用自身来解决更小规模的相同问题，直到达到基本情况，然后将结果合并得到最终解。

递归算法的核心是找到递归的边界条件和递推关系。

二、实验设计与实现本次实验选择了经典的递归问题——计算斐波那契数列。

斐波那契数列是一个典型的递归问题，其定义如下：F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2) (n >= 2)。

为了实现递归算法，我们设计了一个名为fibonacci的函数。

该函数接受一个整数n作为输入，返回斐波那契数列的第n个元素。

函数的实现如下：```pythondef fibonacci(n):if n == 0:return 0elif n == 1:return 1else:return fibonacci(n-1) + fibonacci(n-2)```三、实验结果与分析我们首先对fibonacci函数进行了功能测试，通过计算前几个斐波那契数列的元素来验证函数的正确性。

实验结果表明，函数能够正确计算出斐波那契数列的元素。

接下来，我们对递归算法的性能进行了评估。

我们分别计算了斐波那契数列的前30个元素，并记录了每次计算所花费的时间。

实验结果显示，随着n的增大，递归算法的计算时间呈指数级增长。

这是因为递归算法在计算过程中会重复计算相同的子问题，导致计算量呈指数级增加。

因此，在处理大规模问题时，递归算法的效率较低。

为了进一步验证递归算法的性能，我们将fibonacci函数与迭代算法进行了比较。

迭代算法是一种通过循环来解决问题的方法，相比递归算法，迭代算法不会出现重复计算的情况。

陕西科技大学实验报告班级电信091 学号200906020127 姓名张成实验组别实验日期2012/3/29 室温15 报告日期2012/3/28 成绩报告内容：(目的和要求，原理，步骤，数据，计算，小结等)实验名称：《递归程序设计》一、实验目的：1、掌握递归程序设计的原理；2、熟悉递归程序的设计与应用。

二、实验内容：◆理解递归程序设计基本方法◆理解递归的三大要素◆根据整数乘法运算的特点，给出整数乘法运算的递归实现编写一个递归实现整数之间乘法运算的函数，并进行测试，验证设计的正确性三、实验方法：1)递归算法和课程前面讲的内容不同，递归算法不是一种数据结构，而是一种有效的算法设计方法。

递归算法是解决很多复杂问题的有效方法！2)在定义一个过程或函数时出现调用本过程或本函数的成分,称之为递归。

若调用自身,称之为直接递归。

若过程或函数p调用过程或函数q,而q又调用p,称之为间接递归。

3)如果一个递归过程或递归函数中递归调用语句是最后一条执行语句,则称这种递归调用为尾递归。

四、实验源码#include "stdio.h"#include "conio.h"long chengfa(int x,int y,int a){int z;a=x*y;if (y=1) printf("%d",a);if (y>1){a=x+chengfa(x,y-1,a);printf("%d",a);}return (a);}void main(){int x,y,z,a;printf("qing yi ci shu ru bei cheng he cheng wu:\n");scanf("%d %d",&x,&y);printf("cheng ji wei:\n");chengfa(x,y,a);}五、实验结果：应用算法insert，实现优先级的入队;应用算法pop,实现队的出队;六、实验心得a)递归算法应注意其执行逻辑；b)本实验编程算法设计思想无难度，但实现起来不是很简单，在队列的结构体中，成员有数据和数据的优先级，而且在每个元素入队时，均要与原来的每个元素进行优先级比较，并进行存放位置的相应修改。