实验1++递归与分治算法

递归与分治算法心得
递归与分治算法都是常用的算法思想，可以很好地解决复杂问题。

递归算法是通过将问题分解为相同或相似的子问题来解决整个问题，然后再逐步合并回原问题的过程。

递归算法通常需要明确边界条件，以确保递归能够正确地停止。

分治算法是将问题分解成若干个相同或相似的子问题，递归地解决这些子问题，然后合并这些子问题的解来解决原始问题。

通常，分治算法可以高效地解决问题，但需要注意分解问题的方式和合并子问题的解的过程。

在实际应用中，递归和分治算法可以相互结合，以解决更加复杂的问题。

例如，可以使用分治算法来将问题分解成多个子问题，然后使用递归算法来解决这些子问题。

此外，还可以在递归算法中使用分治算法来对子问题进行分解和合并。

总而言之，递归与分治算法都是非常有用的算法思想，可以在许多领域中得到应用。

但是，在实际使用时，需要仔细考虑问题的性质和算法的复杂度，以确保算法的正确性和效率。

- 1 -。

递归与分治算法心得
递归与分治算法是算法设计中常见的两种方法，它们在解决问题时都采用了“分而治之”的思想，将问题分解成更小的子问题，然后通过递归调用或者合并子问题的解来得到原问题的解。

通过我的学习和实践，我深刻认识到了递归与分治算法的重要性和优势。

首先，递归算法可以使问题的描述更加简单明了。

通过将问题转化为自身的子问题，我们可以建立起更为简洁优美的数学模型。

其次，递归算法可以使问题的解决过程更加自然。

在递归过程中，我们可以利用已知的子问题解决同类问题，实现代码的复用和模块化。

此外，递归算法还可以解决一些重要的数学问题，如斐波那契数列和二分查找等。

分治算法则更加注重问题的分解和合并。

它将问题划分成若干个规模相同或相近的子问题，然后将子问题的解合并起来得到原问题的解。

这种方法在解决某些复杂问题时具有很大的优势。

例如，在排序算法中，归并排序采用了分治算法的思想，将待排序的序列分成两个长度相等的子序列，然后递归地对子序列排序，最后将子序列合并成有序序列。

这种算法具有较高的稳定性和灵活性，常常被应用于海量数据的排序任务中。

总之，递归与分治算法是算法设计中不可或缺的两种方法。

在解决问题时，我们应该根据具体情况选择合适的算法，并在实践中不断探索、总结和优化。

只有这样，我们才能更好地应对日益复杂多变的计算机科学挑战。

分治算法实验（用分治法查找数组元素的最大值和最小值）算法分析与设计实验报告第一次实验实验步骤关键代码}else//当数组中元素个数少于2时，直接赋值处理1. 先解决小规模的问题，如数组中只有1个元素或者只有两个元素时候的情况。

2. 将问题分解，如果数组的元素大于等于3个，将数组分为两个小的数组。

3. 递归的解各子问题，将中分解的两个小的数组再进行以上两个步骤最后都化为小规模问题。

4. 将各子问题的解进行比较最终得到原问题的解。

//分治法处理整个数组，求出最大值与最小值void merge( int a[], int left, int right, int &Max, int &Min){int max1=0,min 1=0,max2=0,min2=0;if (right-left>2) //当数组中元素个数大于3时，才实行分治法{int mid=(right+left)/2;merge(a,left,mid,max1,mi n1);//左半边递归调用自身，求岀最大值与最小值，分别保存在max1,min1中merge(a,mid+1,right,max2,mi n2);//右半边递归调用自身，求岀最大值与最小值，分别保存在max2,min2中if (max1>=max2)Max=max1; //子序列两两合并，求岀最大值与最小值elseMax=max2; //分别保存在Max与Minif (min1<=min2)Min=mi n1;elseMin=mi n2;测试结果实验心得Max=compmax(a,left,right);Min=compmi n( a,left,right);}}利用分治法（递归实现）：非递归实现:请输入数据克1000093 32767The tine is1990003276? 9The tine is1000032767 0TJ IE tine is1000 32767 9The time is3276? RThe tine is內.0060-004TO通解，明白了分治法到底是怎样的一个过程，在代码实现分治法的时候，也使我加深了对于自己构造函数的理解，明白了分治法利用代码是怎样实现的，以及构造函数的传参与返回值等等地方需要注意的F;\鮒实验沁［p || B附录：完整代码（分治法）#include <iostream>#inelude <time.h>#include <iomanip> using namespacestd;//当数组中的元素个数小于3时，处理最大值int compmax(int A[], int start, int end) {int max;if (start<end) //有两个元素{if (A[start]<=A[end]) max=A[e nd];elsemax=A[start];}else //有一个元素max=A[start];return max;}//当数组中元素的个数小于2时，处理最小值int compmin(int A[], int start, int end){int min;if (start<end) //有两个元素{if (A[start]<=A[end]) mi n= A[start];elsemin= A[e nd];}else //有一个元素mi n=A[start];return mi n;}//分治法处理整个数组，求最大值与最小值void merge( int a[], int left, int right, int &Max,int &Min) 〃Max,Min 用来保存最大值与最小值//之所以使用&引用，是由于如果只是简单的使用变量，并不会改变Ma>与Min的值，使用指针也可以{int max1=0,min 1=0,max2=0,min2=0;if (right-left>2) //当数组中元素个数大于等于3时，进行分治{int mid=(right+left)/2;merge(a,left,mid,max1,min1); //左半边递归调用自身，求出最大值最小值，分别保存在max1,min1中merge(a,mid+1,right,max2,min2); //右半边递归调用自身，求出最大值最小值，分别保存在max2,min2中if (max1>=max2) //子序列两两合并，求出最大值与最小值，保存在Max与Mi n 中Max=max1;elseMax=max2;if (min 1<=min2)Min=min1;elseMin=min 2;}else //数组中元素个数小于3时的情况，直接赋值{Max=compmax(a,left,right);Mi n=compmi n( a,left,right);}}void ran( int *input, int n) //随机生成数组元素函数{int i;sran d(time(0)); for(i=0;i<n;i++) input[i]=ra nd();input[i]= '\0';}int a[1000000]; //定义全局变量用来存放要查找的数组int main(){int n;int i;int max;int min;coutvv "请输入要查找的序列个数:"<<e ndl;for (i=0;i<5;i++){cin>>n;ran (a,n);start=clock();en d=clock();over=end-start;start=clock();//调用分治法算法merge(a,0, n-1,max,min);coutvvmax<<‘ " vvminvvendl;en d=clock();printf( "The time is %6.3f" ,( double )(end-start-over)/CLK_TCK); //显示运行时间}system( "pause"); // 停止运行窗口return 0;}完整代码(非递归方法)#include <iostream>#include <time.h>#include <iomanip> usingnamespacestd;void ran( int *input, int n) {//随机生成数组元素函数int i;sran d(time(0));for (i=0;i<n;i++)in put[i]=ra nd();input[i]= '\0';}int a[1000000];int main(){int max=a[0],min=a[0];int i,j,n;cout<<"请输入数据规模: "<<e ndl;for (j=0;j<5;j++){cin»n;ran( a, n);clock_t start,e nd,over;//计算程序运行时间的算法start=clock();en d=clock();start=clock(); for(i=1;i<n;i++) {if (a[i]>max)max=a[i];if (a[i]<min) min=a[i];}coutvvmax<<‘ " vvminvvendl;en d=clock();printf( "The time is %6.3f" ,( double )(end-start-over)/CLK_TCK); // 显示运行时间}system( "pause");return 0;}。

递归和分治法摘要：1.递归和分治法的定义2.递归和分治法的区别3.递归和分治法的应用实例4.递归和分治法的优缺点正文：递归和分治法是计算机科学中常用的两种算法设计技巧。

它们在解决问题时都采用了将问题分解成更小子问题的思路，但在具体实现上却有所不同。

下面，我们来详细了解一下递归和分治法。

1.递归和分治法的定义递归法是指在算法中调用自身来解决问题的方法。

递归函数在执行过程中，会将原问题分解成规模更小的相似子问题，然后通过调用自身的方式，解决这些子问题，最后将子问题的解合并，得到原问题的解。

分治法是指将一个大问题分解成若干个规模较小的相似子问题，然后分别解决这些子问题，最后将子问题的解合并，得到原问题的解。

分治法在解决问题时，通常需要设计一个主函数（master function）和一个子函数（subfunction）。

主函数负责将问题分解，子函数负责解决子问题。

2.递归和分治法的区别递归法和分治法在解决问题时都采用了将问题分解成更小子问题的思路，但它们在实现上存在以下区别：（1）函数调用方式不同：递归法是通过调用自身来解决问题，而分治法是通过调用不同的子函数来解决问题。

（2）递归法必须有递归出口，即必须有一个基线条件，而分治法不一定需要。

3.递归和分治法的应用实例递归法应用广泛，例如斐波那契数列、汉诺塔问题、八皇后问题等。

分治法也有很多实际应用，例如快速排序、归并排序、大整数乘法等。

4.递归和分治法的优缺点递归法的优点是代码简单易懂，但缺点是容易产生大量的重复计算，导致时间复杂度较高。

分治法的优点是时间复杂度较低，但缺点是代码实现相对复杂，需要设计主函数和子函数。

总之，递归和分治法都是解决问题的有效方法，具体应用需要根据问题的特点来选择。

实验一分治与递归算法的应用一、实验目的1．掌握分治算法的基本思想（分-治-合）、技巧和效率分析方法。

2．熟练掌握用递归设计分治算法的基本步骤（基准与递归方程）。

3．学会利用分治算法解决实际问题。

二 . 实验内容金块问题老板有一袋金块（共n块，n是2的幂（n≥2））,最优秀的雇员得到其中最重的一块，最差的雇员得到其中最轻的一块。

假设有一台比较重量的仪器，希望用最少的比较次数找出最重和最轻的金块。

并对自己的程序进行复杂性分析。

三.问题分析:一般思路：假设袋中有n 个金块。

可以用函数M a x（程序1 - 3 1）通过n-1次比较找到最重的金块。

找到最重的金块后，可以从余下的n-1个金块中用类似法通过n-2次比较找出最轻的金块。

这样，比较的总次数为2n-3。

分治法：当n很小时，比如说，n≤2，识别出最重和最轻的金块，一次比较就足够了。

当n 较大时（n＞2），第一步，把这袋金块平分成两个小袋A和B。

第二步，分别找出在A和B中最重和最轻的金块。

设A中最重和最轻的金块分别为HA 与LA，以此类推，B中最重和最轻的金块分别为HB 和LB。

第三步，通过比较HA 和HB，可以找到所有金块中最重的；通过比较LA 和LB，可以找到所有金块中最轻的。

在第二步中，若n＞2，则递归地应用分而治之方法程序设计据上述步骤，可以得出程序1 4 - 1的非递归代码。

该程序用于寻找到数组w [ 0 : n - 1 ]中的最小数和最大数，若n < 1，则程序返回f a l s e，否则返回t r u e。

当n≥1时，程序1 4 - 1给M i n和M a x置初值以使w [ M i n ]是最小的重量，w [ M a x ]为最大的重量。

首先处理n≤1的情况。

若n>1且为奇数，第一个重量w [ 0 ]将成为最小值和最大值的候选值，因此将有偶,数个重量值w [ 1 : n - 1 ]参与f o r循环。

当n 是偶数时，首先将两个重量值放在for 循环外进行比较，较小和较大的重量值分别置为Min和Max，因此也有偶数个重量值w[2:n-1]参与for循环。

算法设计与分析课程教学大纲【适用专业】计算机科学与技术【课时】理论课时：32【学分】 2【课程性质、目标和要求】《算法设计与分析》是计算机科学与技术专业的专业课。

无论是计算科学还是计算实践，算法都在其中扮演着重要角色。

本课程的教学目的是讲授在计算机应用中常常遇到的实际问题的解法，讲授设计和分析各种算法的基本原理、方法和技术，培养学生对算法复杂性进行正确分析的能力。

课程基本要求是⑴掌握算法分析的基本概念和理论。

⑵掌握算法设计技术和分析算法以及算法复杂性。

【教学时间安排】本课程计 2 学分，理论课时32, 学时分配如下：【教学内容要点】第一章算法引论一、学习目的要求1．了解算法的计算复杂性分析方法2．理解算法分析的基本理论3．掌握算法分析的基本概念二、主要教学内容1. 算法的基本概念2. 表达算法的抽象机制3. 采用Java语言与自然语言相结合的方式描述算法的方法4. 算法的计算复杂性分析方法第二章递归与分治策略一、学习目的要求1．理解典型范例中递归与分治策略应用技巧2．掌握递归与分治策略3．掌握数学归纳法证明算法正确性方法二、主要教学内容1. 递归的概念2. 分治法的基本思想3. 二分搜索技术4. 大整数的乘法5. Strassen阵乘法6. 棋盘覆盖7. 合并排序8. 快速排序9. 线性时间选择10. 最接近点对问题11. 循环赛日程表第三章动态规划一、学习目的要求1．理解典型范例中动态规划算法的设计思想2．掌握动态规划算法的基本要求以及算法的设计要点二、主要教学内容1. 矩阵连乘问题2. 动态规划算法的基本要素3. 最长公共子序列4. 最大子段和5. 凸多边形最优三角剖分6. 多边形游戏7. 图像压缩8. 电路布线9. 流水作业调度10. 0—l背包问题11. 最优二叉搜索树12. 动态规划加速原理三、课堂讨论选题1. 最长公共子序列2. 0—l背包问题第四章贪心算法一、学习目的要求1．了解贪心算法的理论基础及基本要素2. 理解典型范例中贪心算法的设计思想3. 掌握贪心算法的设计要点二、主要教学内容1. 活动安排问题2. 贪心算法的基本要素3. 最优装载4. 哈夫曼编码5. 单源最短路径6. 最小生成树7. 多机调度问题8. 贪心算法的理论基础三、课堂讨论选题1. 最优装载2. 单源最短路径第五章回溯法一、学习目的要求1．理解回溯法的效率分析方法2．掌握回溯法的算法框架和应用技巧二、主要教学内容1. 回溯法的算法框架2. 装载问题3. 批处理作业调度4. 符号三角形问题5. n后问题6. 0—l背包问题7. 最大团问题8. 图的m着色问题9. 旅行售货员问题10. 圆排列问题11. 电路板排列问题12. 连续邮资问题13. 回溯法的效率分三、课堂讨论选题1. 0—l背包问题2. 图的m着色问题第六章分支限界法一、学习目的要求1．理解分支限界法的基本思想2．掌握典型范例中分支限界法的应用技巧二、主要教学内容1. 分支限界法的基本思想2. 单源最短路径问题3. 装载问题4. 布线问题5. 0-1背包问题6. 最大团问题7. 旅行售货员问题8. 电路板排列问题9. 批处理作业调度三、课堂讨论选题1. 0-1背包问题2. 批处理作业调度第七章概率算法一、学习目的要求1．理解概率算法的基本思想2．掌握典型范例中概率算法的应用技巧二、主要教学内容1. 随机数2. 数值概率算法3. 舍伍德算法4. 拉斯维加斯算法5. 蒙特卡罗算法第八章 NP完全性理论一、学习目的要求1．了解P类与NP类问题2．了解典型的NP完全问题二、主要教学内容1. 计算模型2. P类与NP类问题3. NP完全问题4. 一些典型的NP完全问题第九章近似算法一、学习目的要求1．掌握近似算法的基本思想2．掌握常用近似算法的应用二、主要教学内容1. 近似算法的性能2. 顶点覆盖问题的近似算法3. 旅行售货员问题近似算法4. 集合覆盖问题的近似算法5. 子集和问题的近似算法第十章算法优化策略一、学习目的要求1．掌握算法优化策略2．掌握算法优化的基本方法二、主要教学内容1. 算法优化策略的比较与选择2. 动态规划加速原理3. 问题的算法特征4. 优化数据结构5. 优化搜索策略【教学（实验）内容要点】算法设计与分析实验是算法设计与分析课的一个实践性教学环节。

一、实验背景分治算法是一种常用的算法设计方法，其基本思想是将一个复杂问题分解成若干个相互独立的小问题，然后将小问题递归求解，最终将子问题的解合并为原问题的解。

分治算法具有高效性、可扩展性和易于实现等优点，被广泛应用于各个领域。

本实验旨在通过实现分治算法解决实际问题，掌握分治算法的设计思想，并分析其时间复杂度。

二、实验目的1. 理解分治算法的基本思想；2. 掌握分治算法的递归实现方法；3. 分析分治算法的时间复杂度；4. 应用分治算法解决实际问题。

三、实验内容本实验选择两个分治算法：快速排序和合并排序。

1. 快速排序快速排序是一种高效的排序算法，其基本思想是将待排序序列分为两个子序列，其中一个子序列的所有元素均小于另一个子序列的所有元素，然后递归地对两个子序列进行快速排序。

（1）算法描述：① 选择一个基准值（pivot），通常取序列的第一个元素；② 将序列分为两个子序列，一个子序列包含所有小于基准值的元素，另一个子序列包含所有大于基准值的元素；③ 递归地对两个子序列进行快速排序。

（2）代码实现：```cvoid quickSort(int arr[], int left, int right) {if (left < right) {int pivot = arr[left];int i = left;int j = right;while (i < j) {while (i < j && arr[j] >= pivot) {j--;}arr[i] = arr[j];while (i < j && arr[i] <= pivot) {i++;}arr[j] = arr[i];}arr[i] = pivot;quickSort(arr, left, i - 1);quickSort(arr, i + 1, right);}}```2. 合并排序合并排序是一种稳定的排序算法，其基本思想是将待排序序列分为两个子序列，分别对两个子序列进行排序，然后将排序后的子序列合并为一个有序序列。

算法分析与设计实验报告第 1 次实验if（maxi>maxj)max=maxi；elsemax=maxj；if（mini<minj)min=mini;elsemin=minj;return；｝}srand(（unsigned int)time(NULL)）；cout <〈”随机产生的数据（0—100）：”;for（int i=0； i〈m; i++）a[i] = rand(）%100；测试结果附录：完整代码SelectMaxMin.cpp:＃include <iostream>＃include <ctime>＃include 〈cstdio>#include <iomanip>＃include 〈cstdlib〉using namespace std;void SelectMaxMin（int ＊a，int i，int j,int &max,int ＆min) ｛if（i==j)｛max= a[i];min =a［i]；return;}else｛int mid=（i+j)/2;int maxi，maxj，mini，minj;SelectMaxMin（a,i，（i+j）/2,maxi,mini）;SelectMaxMin(a，((i+j）/2）+1,j，maxj，minj);if（maxi〉maxj)max=maxi;elsemax=maxj;if(mini<minj)min=mini；elsemin=minj;return;}}int main（）{clock_t start,end，over；start=clock();end=clock();over=end—start;start=clock(）；//freopen（"in。

txt",”r"，stdin）；//freopen(”out。

txt”，”w"，stdout);int m；cout 〈<"Please input the number : ”;cin>〉 m；int a［m]；srand((unsigned int）time(NULL））;cout 〈〈 "随机产生的数据（0-100)："；for（int i=0; i〈m; i++）a［i] = rand（)％100；for(int i=0； i〈m; i++)cout <〈 a[i] 〈< " ";cout 〈< endl；int max，min;SelectMaxMin(a,0,m-1,max,min）;cout 〈< "max = " 〈〈 max 〈〈 endl;cout <〈”min = " <〈 min 〈〈 endl；end=clock（)；printf（”The time is %6.3f”,（double）(end-start—over）/CLK_TCK）; ｝。

《算法设计与分析》实验报告实验一递归与分治策略应用基础学号：**************姓名：*************班级：*************日期：2014-2015学年第1学期第九周一、实验目的1、理解递归的概念和分治法的基本思想2、了解适用递归与分治策略的问题类型，并能设计相应的分治策略算法3、掌握递归与分治算法时间空间复杂度分析，以及问题复杂性分析方法二、实验内容任务：以下题目要求应用递归与分治策略设计解决方案，本次实验成绩按百分制计，完成各小题的得分如下，每小题要求算法描述准确且程序运行正确。

1、求n个元素的全排。

（30分）2、解决一个2k*2k的特殊棋牌上的L型骨牌覆盖问题。

（30分）3、设有n=2k个运动员要进行网球循环赛。

设计一个满足要求的比赛日程表。

（40分）提交结果：算法设计分析思路、源代码及其分析说明和测试运行报告。

三、设计分析四、算法描述及程序五、测试与分析六、实验总结与体会#include "iostream"using namespace std;#define N 100void Perm(int* list, int k, int m){if (k == m){for (int i=0; i<m; i++)cout << list[i] << " ";cout << endl;return;}else{for (int i=m; i<k; i++){swap(list[m], list[i]);Perm(list, k, m+1);swap(list[m], list[i]);}}}void swap(int a,int b){int temp;temp=a;a=b;b=temp;}int main(){int i,n;int a[N];cout<<"请输入排列数据总个数：";cin>>n;cout<<"请输入数据：";for(i=0;i<n;i++){cin>>a[i];}cout<<"该数据的全排列："<<endl;Perm(a,n,0);return 0;}《算法设计与分析》实验报告实验二递归与分治策略应用提高学号：**************姓名：*************班级：*************日期：2014-2015学年第1学期一、实验目的1、深入理解递归的概念和分治法的基本思想2、正确使用递归与分治策略设计相应的问题的算法3、掌握递归与分治算法时间空间复杂度分析，以及问题复杂性分析方法二、实验内容任务：从以下题目中任选一题完成，要求应用递归与分治策略设计解决方案。

竭诚为您提供优质文档/双击可除递归与分治实验报告篇一：实验一递归与分治算法编程-实验报告纸南京信息工程大学实验（实习）报告实验（实习）名称递归与分治算法编程实验（实习）日期得分指导教师院专业年级班次姓名学号1．实验目的：1）掌握递归与分治策略的基本思想2）掌握递归算法在阶乘函数、Ackerman函数、整数划分等问题上的应用3）掌握二分查找、合并排序、快速排序等问题的分治算法实现4）熟悉myeclipse或eclipse等Java开发工具的使用。

2．实验内容：1）采用myeclipse或eclipse编程实现基于分治策略的二分查找算法。

2）采用myeclipse或eclipse编程实现基于分治策略的合并排序算法。

3）采用myeclipse或eclipse编程实现基于分治策略的合并排序算法。

3．实验步骤二分查找publicclasssorting{publicstaticintbinarysearch(int[]a,intx,intn){intle ft=0;intright=n-1;while(left intmiddle=(left+right)/2;if(x==a[middle])returnmiddle;if(x>a[middle])left=middle+1;elseright=middle-1;}return-1;}publicstaticvoidmain(stringargs[]){intx,n;inta[]={1,3,4,5,6,13,25};x=6;n=7;ints;s=binarysearch(a,x,n);system.out.println(s);合并排序publicclassmergesort{publicstaticvoidmergesort(int[]a){}publicstaticvoid mergepass(int[]x,int[]y,ints){}publicstaticvoidmerg e(int[]c,int[]d,intl,intm,intr){inti=1,j=m+1,k=1;in ti=0;while(i }}if(c[i]-(c[j])m)for(intq=j;q快速排序publicclassQsort{privatestaticvoidqsort(inta[],intp,intr){}privatest aticintpartition(inta[],intp,intr){inti=p;intj=r+1; intx=a[p];inttemp;while(true){while((a[++i]-x)0);if (i>=j)break;temp=a[i];if(p }}}a[j]=temp;mymath.s wap(a,i,j);//a[p]=a[j];a[j]=x;returnj;publicstaticv oidmain(string[]args){}inta[]={4,2,7,9,1};qsort(a,0,4);for(inti=0;;i++){}s ystem.out.println(a[i]);4．实验分析和总结掌握了递归与分治策略的基本思想掌握了递归算法在阶乘函数、Ackerman函数、整数划分等问题上的应用掌握了二分查找、合并排序、快速排序等问题的分治算法实现熟悉了myeclipse或eclipse等Java开发工具的使用。

算法设计与分析：递归与分治法-实验报告(总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、定义：直接或间接地调用自身的算法称为递归算法。

用函数自身给出定义的函数称为递归函数。

2、与分治法的关系：由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。

在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。

这自然导致递归过程的产生。

分治与递归经常同时应用在算法设计之中，并由此产生许多高效算法。

3、递推方程：(1)定义：设序列01,....na a a简记为{na}，把n a与某些个()ia i n<联系起来的等式叫做关于该序列的递推方程。

(2)求解：给定关于序列{n a}的递推方程和若干初值，计算n a。

4、应用：阶乘函数、Fibonacci数列、Hanoi塔问题、插入排序5、优缺点：优点：结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法、调试程序带来很大方便。

缺点：递归算法的运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多。

二、递归算法改进：1、迭代法：(1)不断用递推方程的右部替代左部(2)每一次替换，随着n的降低在和式中多出一项(3)直到出现初值以后停止迭代(4)将初值代入并对和式求和(5)可用数学归纳法验证解的正确性2、举例：-----------Hanoi塔算法----------- ---------------插入排序算法----------- ()2(1)1(1)1T n T nT=−+=()(1)1W n W n nW=−+−（1）=021n-23()2(1)12[2(2)1]12(2)21...2++2 (121)n n n T n T n T n T n T −−=−+=−++=−++==++=−（1）2 ()(1)1((n-2)+11)1(2)(2)(1)...(1)12...(2)(1)(1)/2W n W n n W n n W n n n W n n n n =−+−=−−+−=−+−+−==++++−+−=−3、换元迭代：(1)将对n 的递推式换成对其他变元k 的递推式 (2)对k 进行迭代(3)将解（关于k 的函数）转换成关于n 的函数4、举例：---------------二分归并排序---------------()2(/2)1W n W n n W =+−（1）=0（1）换元：假设2kn =，递推方程如下()2(/2)1W n W n n W =+−（1）=0 → 1(2)2(2)21k k k W W W−=+−（0）=0（2）迭代求解：12122222321332133212()2(2)212(2(2)21)212(2)22212(2)2*2212(2(2)21)2212(2)222212(2)3*2221...2(0)*2(22...21)22k k k k k k k k k k k k k k k k k k k k k k k k W n W W W W W W W W k k −−−−−−−+−+−−−=+−=+−+−=+−+−=+−−=+−+−−=+−+−−=+−−−==+−++++=−1log 1n n n +=−+（3）解的正确性—归纳验证： 证明递推方程的解是()(1)/2W n n n =−()(1)1W n W n n W =−+−（1）=0,(n 1)=n +n=n(n-1)/2+n =n[(n-1)/2+1]=n(n+1)/2n W W +方法：数学归纳法证 n=1,W(1)=1*(1-1)/2=0假设对于解满足方程，则（）---------------快速排序--------------------->>>平均工作量：假设首元素排好序在每个位置是等概率的112()()()(1)0n i T n T i O n n T −==+=∑ >>>对于高阶方程应该先化简，然后迭代(1)差消化简：利用两个方程相减，将右边的项尽可能消去，以达到降阶的目的。

算法实验报告一分治法实验一、实验目的及要求利用分治方法设计大整数乘法的递归算法，掌握分治法的基本思想和算法设计的基本步骤。

要求：设计十进制的大整数乘法，必须利用分治的思想编写算法，利用c语言（或者c++语言）实现算法，给出程序的正确运行结果。

（必须完成）设计二进制的大整数乘法，要求利用分治的思想编写递归算法，并可以实现多位数的乘法（利用数组实现），给出程序的正确运行结果。

（任选）二、算法描述1、输入两个相同位数的大整数u，v 输出uv的值判断大整数的位数i；w=u/10^(i/2);y=v/10^(i/2);x=u-w*10^(i/2);z= v-y*10^(i/2);然后将w,x,y,z代入公式求得最后结果uv=wy10^i+((w+x)(y+z)-wy-xz)10^(i/2)+xz三、调试过程及运行结果在实验中我遇到的问题：原来以为这两个大整数的位数不同，结果题目要求是相同位数的大整数在写10的多少次方时，写的是10^(i/2),10^(i)，结果不对，我就将它改成了for循环语句四、实验总结在本次实验中，我知道了分治算法，以及分治算法的基本思想。

我还掌握了编写大整数乘法的算法与步骤，以及如何修改在编写程序时遇到的问题。

五、附录（源程序代码清单）1、#include&lt;iostream.h&gt; int weishu(int x){int i;while(x!=0){ x=x/10;i++;}return i;}void main(){int u,v;cout&lt;&lt;输入两个位数相同的大整数:&lt;&lt;endl; cin&gt;&gt;u;cin&gt;&gt;v;int i,j,m,n;int p,x,y,z,w;int a=1;int b=1;i=weishu(u);for(int k=1;k&lt;=i;k++){a=a*10;}for(int q=1;q&lt;=i/2;q++) {b=b*10;}w=u/b;y=v/b;x=u-w*b;z=v-y*b;p=w*y*a+((w+x)*(y+z)-w*y-x*z)*b+x*z; cout&lt;&lt;u&lt;&lt;*&lt;&lt;v&lt;&lt;=&lt;&lt;p; }教师评语：成绩：√优良中及格不及格算法实验报告二动态规划法实验一、实验目的及要求利用动态规划方法设计背包问题算法，掌握动态规划法的基本思想和算法设计的基本步骤。

递归和分治法摘要：一、递归与分治法的概念1.递归：函数调用自身的思想2.分治法：把一个大问题分解成若干个小问题二、递归与分治法的联系与区别1.递归通常作为分治法的实现方式2.分治法不一定要用递归实现三、递归与分治法的应用实例1.快速排序算法2.归并排序算法3.汉诺塔问题正文：递归和分治法是两种在计算机科学中经常使用的解决问题的方法。

递归是一种函数调用自身的思想，即函数在执行过程中，会调用自身来完成某些操作。

而分治法则是把一个大问题分解成若干个小问题，然后逐个解决这些小问题，最后再把它们的解合并，得到大问题的解。

这两种方法在某些情况下可以相互转化，递归通常作为分治法的实现方式，但分治法不一定要用递归实现。

递归与分治法之间的联系在于，递归通常是分治法的实现方式。

在分治法中，我们会把一个大问题分解成若干个小问题，然后通过递归的方式，逐个解决这些小问题。

最后，再把它们的解合并，得到大问题的解。

在这个过程中，递归函数的调用栈会随着问题规模的减小而减小，最终回到原点，从而完成问题的求解。

然而，分治法并不一定要用递归实现。

在一些情况下，我们可以通过迭代的方式，逐个解决小问题，然后把它们的解合并。

这种方式虽然不是通过递归函数调用自身来实现的，但它仍然符合分治法的思想，即把大问题分解成小问题，逐个解决。

递归和分治法在实际问题中有很多应用。

例如，快速排序算法和归并排序算法都是基于分治法的思想设计的。

在快速排序算法中，我们选择一个基准元素，然后把数组中小于基准的元素放在左边，大于基准的元素放在右边，再对左右两个子数组递归地执行相同的操作，直到数组有序。

而在归并排序算法中，我们同样把数组分成左右两个子数组，然后递归地对它们进行排序，最后再把排序好的子数组合并成一个有序的数组。

另一个例子是汉诺塔问题。

在这个问题中，有三个柱子和一个大小不同的圆盘。

要求把圆盘从第一个柱子移动到第三个柱子，每次只能移动一个圆盘，并且大盘不能放在小盘上。

实验一分治与递归（4学时）一、实验目的与要求1、熟悉C/C++语言的集成开发环境；2、通过本实验加深对递归过程的理解二、实验内容掌握递归算法的概念和基本思想，分析并掌握“整数划分”问题的递归算法。

三、实验题任意输入一个整数，输出结果能够用递归方法实现整数的划分。

四、程序代码五、实验结果首先按照提示输入数字：按回车键，得到此数划分的个数：此时您可以接着计算另一个数的划分个数：若要退出，请输入一个小于等于零的数：六、结果分析及程序功能经过和其它同学的实验数据对比，初步认定此程序基本正确，然而不足之处是只能得到划分的个数，而不能列出每个划分的详细情况。

一、实验目的与要求1、掌握棋盘覆盖问题的算法；2、初步掌握分治算法二、实验题盘覆盖问题：在一个2k×2k个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。

在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

三、程序代码四、实验结果按照提示输入特殊方格的行号和列号（起始行列号为0）：按回车键，得到一个矩阵，数字相同区域为一个L型骨牌覆盖：五、结果分析及程序功能得到的16*16棋盘覆盖结果正确，此程序的不足之处：只能设定特殊方格的行列号，而不能设定棋盘的大小。

实验二动态规划算法(4学时)一、实验目的与要求1、熟悉最长公共子序列问题的算法；2、初步掌握动态规划算法；二、实验题若给定序列X={x1,x2,…,xm}，则另一序列Z={z1,z2,…,zk}，是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xij。

例如，序列Z={B，C，D，B}是序列X={A，B，C，B，D，A，B}的子序列，相应的递增下标序列为{2，3，5，7}。

给定2个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。

1. 如果Q中仅包含2个点，则返回这个点对； 2. 求Q中点的中位数m。
Divide: 1. 用Q中点坐标中位数m把Q划分为两个 大小相等的子集合 Q1 = {xQ | xm}, Q2 = {xQ | x>m}
2013-4-25
20
2.5 最近点对问题
• 利用排序的算法
– 算法
• 把Q中的点排序 • 通过排序集合的线性扫描找出最近点对 – 时间复杂性 • T(n)=O(nlogn)
2013-4-25
21
2.5 最近点对问题
一维最近点对的Divide-and-conquer算法
Preprocessing:
10
2.3 分治算法—设计
• 设计过程分为三个阶段

Divide：
整个问题划分为多个子问题


Conquer：求解各子问题(递归调用正设计的算法)
Combine：合并子问题的解, 形成原始问题的解
• 分析过程
– 建立递归方程 – 求解
• 递归方程的建立方法
– 设输入大小为n, T(n)为时间复杂性 – 当n<c, T(n)=(1)
2013-4-25
18
2.4 棋盘覆盖问题
void chessBoard(int tr, int tc, int dr, int dc, int size) { board[tr + s - 1][tc + s] = t; if (size == 1) return; // 覆盖其余方格 int t = tile++, // L型骨牌号 chessBoard(tr, tc+s, tr+s-1, tc+s, s);} s = size/2; // 分割棋盘 // 覆盖左下角子棋盘 // 覆盖左上角子棋盘 if (dr >= tr + s && dc < tc + s) if (dr < tr + s && dc < tc + s) // 特殊方格在此棋盘中 // 特殊方格在此棋盘中 chessBoard(tr+s, tc, dr, dc, s); chessBoard(tr, tc, dr, dc, s); else {// 用 t 号L型骨牌覆盖右上角 else {// 此棋盘中无特殊方格 board[tr + s][tc + s - 1] = t; // 用 t 号L型骨牌覆盖右下角 // 覆盖其余方格 board[tr + s - 1][tc + s - 1] = t; chessBoard(tr+s, tc, tr+s, tc+s-1, s);} // 覆盖其余方格 // 覆盖右下角子棋盘 // 覆盖右上角子棋chessBoard(tr, tc, tr+s-1, tc+s-1, s);}盘 s && dc >= tc + s) if (dr >= tr + if (dr < tr + s && dc >= tc + s) // 特殊方格在此棋盘中 // 特殊方格在此棋盘中 chessBoard(tr+s, tc+s, dr, dc, s); chessBoard(tr, tc+s, dr, dc, s); else {// 用 t 号L型骨牌覆盖左上角 else {// 此棋盘中无特殊方格 board[tr + s][tc + s] = t; // 用 t 号L型骨牌覆盖左下角 // 覆盖其余方格 chessBoard(tr+s, tc+s, tr+s, tc+s, s);} 2013-4-25 19 }

递归实验报告篇一：字符串,递归实验报告宁波工程学院电信学院计算机教研室实验报告一、实验目的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;}按实验要求首先定义顺序串，实验的难点在于密码的加密和解密的实现，特别是再解密时，字母的溢出问题，在参考网上程序后很好地解决了这个问题。