猴子吃桃子递归算法
C++函数递推递归
编辑课件
1
9
第九讲——函数、递推、递归
递归调用
直接调用
间接调用
注意：上述两种情况都是无终止的自身调用；显然， 程序中不应该出现这种无终止的调用，而只应出现 有限次的，有终止的递归调用；可以用if语句控制， 实现递归调用结束；
编辑课件
2
0
第九讲——函数、递推、递归
递归函数
q(3) = 1 + 1 + 2 + 3 = 7
q(4) = 1 + 1 + 2 + 3 + 4 = 11
编辑课件
1
1
分析：
第九讲——函数、递推、递归
切一刀
切二刀
切三刀
切四刀
在切法上是让每两条线都有交点。用归纳法可得出
q(n) = q(n-1) + n q(0) = 1 (边界条件)
编辑课件
1
2
递推算例（3） 参考程序：
编辑课件
2
6
第九讲——函数、递推、递归
递归算例（3）
编辑课件
2
7
第九讲——函数、递推、递归
递归算例（4）
例: (猴子吃桃问题)
猴子第1天摘下若干桃子，当即吃了一半，还不过瘾， 又多吃了一个。第2天早上又将剩下的桃子吃掉一半， 又多吃了一个。以后每天早上都吃了前一天剩下的一 半另加一个。到第10天早上想再吃时，就只剩下一个 桃子了。问第1天猴子共摘了多少桃子？
第九讲——函数、递推、递归
编辑课件
1
3
递归
第九讲——函数、递推、递归
递归算法在可计算理论中占有重要地位，它是算法设计的有 力工具，对于拓展编程思路非常有用。 就递归算法而言不涉及高深数学知识，只不过初学者建立起递 归概念不太容易。
数据结构与算法 猴子吃桃
课程设计说明书课程名称：数据结构与算法设计题目：猴子吃桃问题院系：计算机科学与信息工程系学生姓名：学号：专业班级：指导教师：2010年6月18日课程设计任务书设计题目猴子吃桃问题学生姓名蒋耀辉所在院系计算机科学与信息工程系专业、年级、班08软件工程班设计要求：分别用以下三种方法实现对猴子吃桃问题的求解：（1）数组数据结构（2）链表数据结构（3）递归问题描述如下：有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第十天就只剩下一只桃子，求出它们第一天摘了多少桃子。
学生应完成的工作：以小组为单位，分工合作完成以下任务（1）编写程序实现对上述猴子偷桃问题的求解并运行出结果；（2）在制定期限内提交程序并完成答辩；（3）提交出详细的课程设计说明书。
参考文献阅读：（1）严蔚敏，吴伟民.数据结构（C语言版）—北京：清华大学出版社2007IBSN978-7-302-14751-0；（2）谭浩强.C语言程序教程—北京：清华大学出版社2007.7 IBSN978-7-302-15157-9；（3）（美）（Liang，Y.D）C++程序设计—北京：机械工业出版社 2008.5 IBSN978-7-111-23996-3。
工作计划：1、确定自己负责模块的作用2、写出模块算法3、写出源代码4、验证与修改任务下达日期：2010 年 6 月7 日任务完成日期：2010 年 6 月18 日指导教师（签名）：学生（签名）：（设计题目）摘要：有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
要求：1)采用数组数据结构实现上述求解2)采用链数据结构实现上述求解3)采用递归实现上述求解关键词：数组链递归目录1. 设计背景 (1)1.1时代背景 (1)1.2能力要求 (1)2.设计方案 (1)2.1初步分析 (1)2.2 问题细化 (2)3. 方案实施 (2)3.1初步探讨 (2)3.2 详细过程 (2)4.结果与结论 (3)5. 收获与致谢 (3)6. 参考文献 (3)7. 附件 (4)源程序 (4)1. 设计背景1.1时代背景数据结构是由数据元素依据某种逻辑联系组织起来的。
猴子吃桃子递归算法
递归算法案例—猴子吃桃子一、案例描述某天，一只猴子摘了一堆桃子，具体多少它没数。
猴子每天吃了其中的一半然后再多吃了一个，第二天吃剩余的一半后再多吃了一个，直到第10天，猴子发现只有一只桃子。
问这只猴子在第一天摘了多少个桃子二、算法分析这只猴子共用了10天吃桃子，只知道最后一天剩余1只桃子，要想求出第1天剩余的桃子数，就先要求出第2天剩余的桃子数，以此类推。
假设An表示第n天剩余的桃子数量，则有如下关系：A1=(A2+1) x 2A2=(A3+1) x 2A3=(A4+1) x 2….A1=(A10+1) x 2A10=1从上述的式子可知，只能通过倒推来求得第一天的桃子数三、算法实现算法代码实现如下：#include<stdio.h>/***@briefpeach*@paramn：猴子吃桃子的天数*@return*/long peach(int n){int pe;if(n==1){return1;}else{pe=(peach(n-1)+1)*2;}return pe;}int main(void){int n;//天数long peachnum;//最初桃子数printf("pleasenumberofDate");scanf("%d",&n);peachnum=peach(n);printf("Thepreviousnumberis:%1d",peachnum);return0;}程序中使用递归调用peach函数来计算第一天的桃子数量。
其中关键是前一天总比后一天多一半加1.当n=10的时候，正好求出猴子吃桃子问题。
VB递归算法
if 是最初两项 then 斐波纳切数=1 else 斐波纳切数=前两个斐波纳切数之和 end if
案例二、斐波那契数列问题
1、1、2、3、5、8、13、21、34、65…… 求第N个斐波纳切数 if 是最初两项 then 斐波纳切数=1 else 斐波纳切数=前两个斐波纳切数之和 end if
我们能不能这样设一个函数：
• 算法描述： • function 你有多少桃子？（第几天） • 如果 第10天，那么 • 桃子数 = 1 • 否则 • 桃子数= （ 明天的桃数+1）* 2 • end function
第n天的桃子数 2 -1 = 第n+1天的桃子数 第n天的桃子数 = (第n+1天的桃子数+1)*2
递归算法
老和尚的故事… 从前有座山， 山里有座庙， 庙里有个老和尚， 给小和尚讲故事，
从前有座山，
山里有座庙，
从前有座山，
山里有座庙，
庙里有个老和尚，
庙里有个老和尚，
给小和尚讲故事，
给小和尚讲故事，
故事是什么呢• 有一天小猴子摘若干个桃子,当即 吃了一半还觉得不过瘾,又多吃了 一个。第二天接着吃剩下桃子中 的一半，仍觉得不过瘾又多吃了 一个，以后小猴子都是吃尚存桃 子一半多一个。到第10天早上小 猴子再去吃桃子的时候，看到只 剩下一个桃子。问小猴子第一天 共摘下了多少个桃子?
Tao(1)=(tao(2)+1)*2
• 算法实现：
• Function tao(days As Integer) As Integer
调用 Tao(2)=(tao(3)+1)*2 调用 Tao(3)=(tao(4)+1)*2 调用 Tao(8)=(tao(9)+1)*2 调用 Tao(9)=(tao(10)+1)*2 调用 Tao(10)= 1
计算机程序设计(c++)第周编程作业
计算机程序设计(c++)第6周编程作业1递归猴子摘桃（20分）题目内容：猴子摘桃：一天，一只猴子摘了若干桃子，当天吃掉一半，觉得不过瘾，又吃了一个；第二天将剩下的桃子吃掉一半又多吃了一个；…，每天将前一天剩下的桃子吃掉一半又多吃一个，直到第n天，发现只剩下一个桃子，问第一天它摘了多少桃子。
编写递归函数，计算第一天猴子摘的桃子的数量。
在主函数中输入n，调用函数计算第一天摘的桃子的数量，在主函数中输出。
输入:剩下一只桃子的天数n，n>=1。
输出：第一天摘的桃子数量。
【提示】函数格式：int monkeyandPeak(int k,int n)，其中n是1只桃子的天数，k是求哪天的桃子数，返回是第k天的桃子数。
主函数的调用格式：count= monkeyandPeak(1,n); //第n天只剩1只桃，求第1天的桃子数【注意】使用递归实现。
样例1输入：10样例1输出：1534#include<stdio.h># include <iostream>using namespace std;int peach(int n)//第N天只剩下一个桃子了{if(n==1)return 1;return 2*(peach(n-1)+1);}int main(){int a;cin>>a;printf("%d\n",peach(a));return 0;}编写内联函数求矩形的面积和周长（20分）题目内容：编写函数求矩形的面积和周长，由于算式非常简单，请使用内联函数方式编写，提高程序运行效率输入格式:矩形的长和宽，均为整数输出格式：矩形的面积和周长输入样例：3 5输出样例：15 16# include <iostream>using namespace std;inline int GetSize(int a, int b){int size = a*b;return size;}inline int GetPerimeter(int a, int b){int perimeter = 2*(a+b);return perimeter;}int main(){//---define---int a,b;//---input---cin>>a;cin>>b;//---execute---//---output---cout<<GetSize(a,b)<<" ";cout<<GetPerimeter(a,b)<<endl;return 0;}编写重载函数显示字符串（20分）题目内容：编写函数print_spaced 显示字符串，要求显示出的字符串每个字母之间都有一个空格。
实验7 递归算法
实验七:1、阶乘的递归实现2、Fibonacci数列的递归实现3、猴子吃桃问题一只猴子吃一棵桃树上的桃子，按每天吃树上1/2的桃子，再多一个，到第10天，树上只有一个桃子，问：树上原有多少个桃子？（要求：用递归方法实现）1、方法1: 递归实现#include"stdio.h"int fact(int n){if(n==0)return 1;return n*fact(n-1);}void main(){int m;printf("请输入阶乘数：");scanf("%d",&m);printf("%d!阶乘的值为：%d",m,fact(m));getch();}方法2: 循环实现#include"stdio.h"void main(){int i,n,x=1;printf("请输入阶乘数：");scanf("%d",&n);if(n==0) x=1;elsefor(i=n;i>=1;i--){x=x*i;}printf("%d",x);getch();}2、#include"stdio.h"int fact(int n){if(n<=2)return 1;return fact(n-1)+fact(n-2);}void main(){int n,i;printf("请输入斐波那契的项数：");scanf("%d",&n);printf("前%d项的数为：",n);for(i=1;i<=n;i++){printf(" %d",fact(i));}getch();}3、方法一:由第一天到第十天计算#include"stdio.h"int fact(int n){if(n==10)return 1;return ((fact(n+1)+1)*2);}void main(){int day;printf("***********猴子吃桃问题***********\n");printf("请输入天数：");scanf("%d",&day);printf("在第%d天的桃子个数为：%d",day,fact(day));getch();}方法二:由第十天到第一天计算#include "stdio.h"void main(){int day,i,x=1;printf("***********猴子吃桃问题***********\n");printf("请输入天数：");scanf("%d",&day);for(i=day;i<10;i++){x=(x+1)*2;}printf("在第%d天的桃子个数为：%d",day,x);getch();}。
猴子吃桃的数学公式
猴子吃桃的数学公式猴子吃桃是一个经典的数学问题，也被称为“猴子爬山”问题。
它涉及到一个猴子每天吃掉一半的桃子，然后再多吃一个，最后在第十天的时候吃完。
那么，我们可以用数学公式来推导出猴子吃桃的过程。
首先，我们将问题抽象为一个递推式。
设第一个桃子从第十天开始吃，那么第九天的桃子数量是第十天的桃子数量减去一半再加一，以此类推，我们可以得到第一天的桃子数量。
设第n天的桃子数量为x(n)，那么有以下递推公式：x(n)=(x(n+1)+1)*2其中，n=10,9,8,...,1我们可以从第十天开始，带入递推公式，反推出每一天的桃子数量。
首先，带入n=10：x(10)=(x(11)+1)*2=(1+1)*2=4再带入n=9：x(9)=(x(10)+1)*2=(4+1)*2=10以此类推，我们可以得到：x(8)=22x(7)=46x(6)=94x(5)=190x(4)=382x(3)=766x(2)=1534x(1)=3066所以，第一天的桃子数量是3066个。
通过以上推导，我们可以得出结论：猴子吃桃的数学公式为x(n)=(x(n+1)+1)*2，其中n=10,9,8,...,1、根据这个公式，我们可以计算出任意一天的桃子数量。
除了递推公式外，还可以使用数列求和的方法来计算猴子吃桃的总数。
设第一天的桃子数量为x(1)，第二天的桃子数量为x(2)，以此类推，第十天的桃子数量为x(10)。
我们可以得到以下等差数列：x(1),x(2),x(3),...,x(9),x(10)其中，首项为x(1)，公差为1，项数为10。
那么，这个等差数列的和可以用数列求和公式来计算：S=(n/2)(a+l)其中，S代表数列的和，n代表项数，a代表首项，l代表末项。
带入数值，我们可以得到：S=(10/2)(x(1)+x(10))=5(x(1)+x(10))=5(3066+4)这就是猴子吃桃的数学公式及推导过程。
通过数学公式，我们可以计算出任意一天的桃子数量，以及猴子吃桃的总数。
C语言猴子分桃算法
C语言猴子分桃算法猴子分桃算法是一种经典的问题，常用于测试递归和数学推理的能力。
该问题的描述为：有一堆桃子，N个猴子来分。
第一个猴子将这堆桃子平均分为等份，多出一个桃子，这只猴子将多出的桃子扔掉，然后拿走了自己的一份。
接下来，第二个猴子将剩下的桃子平均分为等份，再次多出一个桃子，扔掉后拿走了自己的一份，依此类推，直到第N个猴子拿走自己的一份。
问原来最少有多少个桃子。
这个问题可以通过递归和数学推理两种方式来解决。
1.递归解法假设原来有x个桃子，则第一个猴子拿走自己的一份后剩余(x-1)份，第二个猴子拿走自己的一份后剩余[(x-1)/(N-1)]份，第三个猴子拿走自己的一份后剩余[(x-1)/(N-1)]/[(N-1)]份，依此类推，第N个猴子拿走自己的一份后剩余1份。
我们可以建立递归函数来求解剩余桃子的数量：int peach(int N)if (N == 1)return 1;} elsereturn (peach(N-1) + 1) * N;}这里，递归步骤的关键在于每个猴子拿走自己份额后，桃子的数量变成了原来的[(x-1)/(N-1)]倍，加上1是因为剩余的一份要留给下一个猴子。
当N为1时，也就是只有一个猴子时，剩余的桃子数量就是12.数学推理解法通过数学推理，我们也可以求解原来有多少个桃子。
我们可以按照逆向的方式来推导。
假设最后一个猴子拿走自己的一份后剩余的桃子数量为1，那么上一个猴子拿走自己的一份前剩余的桃子数量可以表示为[(1+1)*N]，在第二个猴子拿走自己的一份前剩余的桃子数量可以表示为[((1+1)*N+1)*N]，依此类推，第一个猴子拿走自己的一份前剩余的桃子数量可以表示为[((((1+1)*N+1)*N+1)*N+1)*N]。
这个过程可以用一个循环来表示，其中x表示最后剩余的桃子数量。
int peach(int N)int x = 1;for (int i = 1; i < N; i++)x=(x+1)*N;}return x;这样，无论是递归解法还是数学推理解法，都能求解出猴子分桃问题的答案。
C语言程序开发经典实例
main(){int i,j,k;for(i=0;i<=3;i++){for(j=0;j<=2-i;j++)printf(" ");for(k=0;k<=2*i;k++)printf("*");printf("\n");}for(i=0;i<=2;i++){for(j=0;j<=i;j++)printf(" ");for(k=0;k<=4-2*i;k++)printf("*");printf("\n");}}==============================================================【程序24】题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
1.程序分析：请抓住分子与分母的变化规律。
2.程序源代码：main(){int n,t,number=20;float a=2,b=1,s=0;for(n=1;n<=number;n++){s=s+a/b;t=a;a=a+b;b=t;/*这部分是程序的关键，请读者猜猜t的作用*/}printf("sum is %9.6f\n",s);for(i=0;i<5;i++)printf("\40:%d!=%d\n",i,fact(i));}int fact(j)int j;{int sum;if(j==0)sum=1;elsesum=j*fact(j-1);return sum;}==============================================================【程序27】题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
猴子吃桃问题
软件综合课程设计猴子吃桃问题学生搭配问题二〇一四年六月《猴子吃桃子课程设计》报告一、问题陈述猴子吃桃子问题：有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
二、需求分析要求：1．采用数组数据结构实现上述求解；2．采用链数据结构实现上述求解；3．采用递归实现上述求解。
三、概要设计四、详细设计猴子每天都吃当前桃子的一半多一个，假设今天还有n个桃子，则前一天就有（n+1）*2个桃子。
又已知第十天只剩下一个桃子，则可代入以上公式求出第九天的桃子数，以此类推求下去便可得到第一天的桃子数。
1．采用数组数据结构实现上述求解声明一个长度为10的整形数组arr[10],分别存放各天猴子吃前的桃子数。
下图所示arr[0] arr[1]arr[2]arr[3] arr[4]arr[5]arr[6]arr[7] arr[8]arr[9]先将arr[9]赋值为1，用一个循环语句for (int i=9; i>0; i--){ arr[i-1]=2*(arr[i]+1); }为其余各数组元素赋值，则数组元素arr[0]的值便是该问题的解。
2．采用链数据结构实现上述求解 建立单链表，声明一个类用来对链表的结点指针进行定义，在初始化函数中利用头插法创建具有10个元素的链表。
那么N 10便是要求问题的解。
3．采用递归实现上述求解利用一个递归函数来进行求值：依据返回值来记录每一天剩余桃子情况。
int UseRecursion(int n) {int m; if(n==1) m=1; elsem=(UseRecursion(n-1)+1)*2; return m; }五、程序代码1．头文件“MEP.h “ #ifndef MEP_H #define MEP_H#include<iostream> #include<malloc.h> using namespace std; typedef struct LNode {int data;struct LNode *next; }LNode,*LinkList; void UseLinkList();int UseRecursion(int n);int Swicth();void Diaoyong();void UseArray();void Fenxi();void LinkListAnalysis();void RecursionAnalysis();void ArrayAnalysis();static unsigned short arr[10]={0,0,0,0,0,0,0,0,0,1};#endif MEP_H;2.主函数void Diaoyong();void main(){Diaoyong();}3．Diaoyong：调用函数#include"MEP.h"void Diaoyong(){cout<<" --猴子吃桃子问题-- \n\n";cout<<"有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一\n";cout<<"半且再多吃一个，到了第10天就只余下一个桃子。
数据结构猴子吃桃
目录1 问题描述 (1)2 需求分析 (1)3 概要设计 (1)3．1抽象数据类型定义 (1)3．2模块划分 (2)4 详细设计 (3)4．1数据类型的定义 (3)4．2主要模块的算法描述 (3)5 测试分析 (6)6 课程设计总结 (7)参考文献 (8)附录（源程序清单） (9)1 问题描述有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子,求原来这群猴子共摘了多少个桃子。
一种采用数组数据结构实现；一种采用栈链数据结构实现；一种采用递归实现上述求解。
2 需求分析(1)由问题可知,题目中知道第十天所剩的桃子数,所以可以及往前算,算出前一天所剩余的桃子数,到第一天时即为总的桃子数,所以可用数组来存每天所剩的桃子数,容易实现求解。
(2)根据问题设第n天的桃子数为f(n),则前一天的桃子数为f(n+1)=f(n)-(f(n)/2+1)，化解可得f(n)=2f(n+1)+2,以此为依据实现递归。
(3)由栈与递归的实现可知调用函数各被调用函数之间的链接及信息交换是通过栈来实现的，因此可以用栈模拟函数递归。
即可通过用栈的链表储存结构模拟函数的递归调用过程来实现问题的求解。
3 概要设计3．1抽象数据类型定义栈的抽象数据类型定义AST Stack{数据对象：D={ai|ai∈ElemSet,i=1,2,...,n, n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D，i=2,...,n}约定an端为栈顶，a1端为栈底。
基本操作：InitStack(&S)操作结果：构造一个空栈S。
DestroyStack(&S)初始条件：栈S已存在。
操作结果：栈S被销毁。
ClearStack(&S)初始条件：栈S已存在。
操作结果：将栈S清为空栈。
StackEmpty(S)初始条件：栈S已存在。
操作结果：若栈S为空栈，则返回TRUE，否则FALSE。
数据结构猴子吃桃子问题
猴子吃桃子问题（1）需求分析：猴子每天都吃当前桃子的一半且再多吃一个，假设第一天开始时，即摘的桃子总数有a0只桃子，第一天吃过之后剩下a1只桃子，第二天吃过之后剩下a2只，. . .，第9天吃过之后剩下a9只，第10天吃过之后剩下a10只，在a0，a1，a2，. . .，a1 0中，只有a10= 1是知道的，现要求a0，a9= 2 * ( a1 0+ 1 )a8= 2 * ( a9+ 1 )┇a1= 2 * ( a2+ 1 )a0= 2 * ( a1+ 1 )也就是：ai= 2 * ( ai + 1)，其中i=10,9，8，7，6，...，1，0（2）概要设计：采用数组和递归方法，不管是采用哪种方法、哪种数据结构，其基本语句都是ai= 2 * ( ai + 1+1)，其中i=10,9，8，7，6，...，1，0（3）详细设计：采用数组数据结构：构建子函数void Array(int a[])，初始化i=10，从10开始计算，i--，通过语句while(i>0)，来循环运行a[i-1]=2*a[i]+2，以求出每天剩下的桃子数当i<=1时退出循环。
在主函数中定义数组int a[11]来存储每天剩下的桃子总数，初始化a[10] =1，通过调用子函数Array(a)，并利用for循环来输出每天剩下的桃子总数，其中a[0]即为原来猴群所摘的桃子的总数。
void Array(int a[]){int i=10;while(i>0){a[i-1]=2*a[i]+2;i--;}}采用递归算法：子函数中，关键语句为N=2*recursion(N+1)+2，采用判断语句 if…else…，“if(N==10) return 1；”，给出第十天吃过桃子后剩下桃子数为1，其他天数return N=2*recursion(N+1)+2，即通过递归调用计算，通过已知的后一天剩下的桃子总数来求出前一天剩下的桃子总数。
猴子吃桃问题
福建工程学院课程设计课程：数据结构课程设计题目：猴子吃桃问题专业：软件工程班级： 1002座号： 5号姓名：蔡梓楠年月日实验题目：猴子吃桃问题一、要解决的问题有一群猴子摘了一堆桃，他们每天都吃当前桃子的一半且在多吃一个，到了第十天就只剩下一个桃子。
用多种方法实现求出原来这群猴子一共摘了多少个桃子。
要求：1.采用数组数据结构实现上述求解2.采用链表数据结构实现上述求解3.采用递归算法实现上述求解4.（个人）采用堆栈数据结构实现上述求解（个人）本程序可实现10天以内第n天的桃子数。
二、算法基本思想描述：本次课程设计要采用回溯思想，因为题目中只告诉你第十天的桃子数量为1，则第九天的桃子数为（1+1）*2，之前几天的桃子树可用此公式m=(n+1)*2（m为前一天桃子数，n 为当天桃子数）公式解决。
若要求第一天到底有几个桃子，可将之前几天的桃子树一一存入各自结构中，然后求出第一天的桃子树；而如果用递归算法，则必须连续十次进行该函数。
三、设计1．数据结构的设计和说明本次试验四个要求中，除了“递归算法”要求不需要特殊存储结构意外，其他三个都要。
typedef int elemtype; /*定义新类型elemtype为int型*/ （1）数组存储结构typedef struct{elemtype data[n];int len;}Sequenlist;（2）链表存储结构typedef struct node{elemtype data;struct node *next;}linklist;（3）堆栈存储结构typedef struct{elemtype data[MAXSIZE];int top;}SeqStack;2．模块结构图及各模块的功能：void main() /*主函数*/ void Digui() /*递归算法*/ void duizhan() /*堆栈存储结构*/ void shuzu() /*数组结构存储*/ void lianbiao() /*链表存储结构*/ 3．关键算法的设计递归算法描述：int z;int digui(int j,int k){z自加1;当z等于输入天数时，返回j;j=(j+1)*2;digui(j,k);}四、源程序清单：#include"malloc.h"#define MAXSIZE 100#define n 100#define NULL 0int z=0;typedef int elemtype;/*定义新类型为elemtype*/typedef struct{elemtype data[MAXSIZE];int top;}SeqStack;/*定义栈类型*/typedef struct{elemtype data[n];int len;}Sequenlist;/*定义数组类型*/typedef struct node{elemtype data;struct node *next;}linklist;/*定义链表类型*/linklist *Initlinklist(linklist *L){L=(linklist *)malloc(sizeof(linklist));L->next=NULL;return(L);}/*初始化链表*/linklist *Creatlinklist(linklist *L){int i,j;linklist *r,*p;r=L;j=1;for(i=0;i<=9;i++){p=(linklist *)malloc(sizeof(linklist));p->data=j;p->next=NULL;r->next=p;r=r->next;j=(j+1)*2;}return(L);}/*链表创建*/Sequenlist *InitList(Sequenlist *L){L=(Sequenlist *)malloc(sizeof(Sequenlist));L->len=0;return(L);}/*初始化数组*/Sequenlist *CreatList(Sequenlist *L){int i,j,k;L->data[0]=1;k=1;for(j=0;j<9;j++){i=(L->data[j]+1)*2;L->data[j+1]=i;L->len++;k++;}L->len=k;return(L);}/*将算好每天的桃子数存入数组*/ SeqStack *InitStack(SeqStack *S){S=(SeqStack *)malloc(sizeof(SeqStack));S->top=-1;return(S);}/*初始化栈*/int Push(SeqStack *S,int item){if(S->top==MAXSIZE-1){printf("Stack overflow\n");return 0;}else{S->data[++S->top]=item;return 1;}}/*进栈*/elemtype Pop(SeqStack *S){if(S->top==-1){printf("Stack is empty.\n");return 0;}else{S->top--;return(S->data[S->top+1]);}}/*出战*/SeqStack *CreatStack(SeqStack *S){int i,j,k;Push(S,1);k=1;for(j=0;j<9;j++){i=(k+1)*2;k=i;Push(S,i);}}/*将算好每天的桃子数存入栈*/int digui(int j,int k){z++;if(z==k) return j;j=(j+1)*2;digui(j,k);}/*利用递归算法计算每天桃数*/void lianbiao()/*数据存储方式为链表*/{linklist *P,*u;int i,k;P=Initlinklist(P);Creatlinklist(P);u=P->next;printf("（链表算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/for(i=0;i<10-k;i++){u=u->next;/*寻找第k天桃子数*/}printf("第%d天桃子数为%d\n",k,u->data);printf("\n");}void shuzu()/*数据存储方式为数组*/{int k;Sequenlist *L;L=InitList(L);L=CreatList(L);printf("（数组算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/printf("第%d天桃子数为%d\n",k,L->data[10-k]);printf("\n");}void duizhan()/*数据存储方式为堆栈*/{int i,k;SeqStack *S;S=InitStack(S);CreatStack(S);printf("（堆栈算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/for(i=0;i<=k-2;i++) Pop(S);printf("第%d天桃子数为%d",k,Pop(S));printf("\n");printf("\n");}void Digui()/*递归算法*/{int k;z=0;printf("（递归算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/printf("第%d天桃子数为%d",k,digui(1,11-k));printf("\n");printf("\n");}void print()/*选择列表函数*/{printf("---------请输入你的选择---------\n");printf("-a:数组算法-\n");printf("-b:链表算法-\n");printf("-c:递归算法-\n");printf("-d:堆栈算法-\n");printf("-e:关闭程序-\n");printf("--------------------------------\n");}main(){char c;print();/*打印选择列表*/c=getchar();/*输入选择*/while(c!='e'){switch(c){case 'a': shuzu();break;/*选择用数组存储方式*/case 'b': lianbiao();break;/*选择用链表存储方式*/case 'c': Digui();break;/*计算过程选择用递归算法*/case 'd': duizhan();break;/*选择用堆栈存储方式*/case 'e': return;/*程序结束*/}print();/*打印选择列表*/getchar();c=getchar();}getch();getch();}五、测试数据及测试结果：测试过程：测试开始后，屏幕打印四种方法的选项：输入“a”；屏幕打印：提示输入天数：输入“1”；输出“1534”。
猴子吃桃递归算法c语言
猴子吃桃递归算法c语言猴子吃桃问题是一个很有趣的编程小案例呢。
在C语言里用递归算法来解决这个猴子吃桃的问题呀，我们先得搞清楚这个问题的逻辑。
就说有这么一只猴子，它每天都要吃桃子，而且每天吃的桃子数量都有一定的规律。
我们假设猴子在第n天早上还没吃桃子之前，有x个桃子。
那到了第n - 1天早上没吃之前呢，桃子的数量就是(x + 1) * 2个。
这就是这个问题里很关键的一个关系啦。
那我们怎么用C语言来写这个递归算法呢？我们可以先写一个函数，比如说就叫peach(int n)。
这个函数的作用就是根据给定的天数n，算出那天早上还没吃之前有多少个桃子。
#include <stdio.h>.// 这个函数就是用来计算第n天猴子没吃之前的桃子数量。
int peach(int n) {if (n == 1) {// 如果是第一天，那就只有1个桃子啦，这是题目给定的初始条件哦。
return 1;} else {// 按照我们前面说的那个逻辑关系，递归地计算桃子数量。
return (peach(n - 1) + 1) * 2;}}你看这个代码呀，是不是还挺简单的呢？当n等于1的时候，就直接返回1，因为第一天就只有1个桃子。
当n不是1的时候呢，就根据前面说的逻辑关系，调用自己（这就是递归啦），算出前一天的桃子数量，然后再按照那个计算方式算出当天的桃子数量。
在写这个代码的时候呀，一定要注意递归的终止条件，就像我们这里的n == 1就是终止条件。
要是没有这个终止条件，这个函数就会一直调用自己，那就像个无底洞一样，程序就会出错啦。
而且在理解这个递归算法的时候呢，你可以想象自己就是那只小猴子，从最后一天往前推，每天的桃子数量是怎么变化的。
这样想的话，就会觉得这个算法还挺好玩的呢。
你要是自己去运行这个代码呀，就可以在main函数里这样写：int main() {int days = 10; // 这里假设是第10天，你可以改成任何你想要的天数哦。
递归问题经典
几个经典的递推或递归问题猴子分桃海滩上有一堆桃子，五只猴子来分。
第1只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个吃掉，拿走了一份。
第二只猴子把剩下的桃子又平均分为五份，又多了一个，它同样把多的一个吃掉，拿走了一份，第3、第4、第5只猴子都是这样做的。
问海滩上原来最少有多少个桃子？汉诺塔问题汉诺塔问题又称河内塔问题,是源于印度一个古老传说的益智玩具。
大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。
大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘,按此规则完成所有圆盘从一根柱子搬到另一根柱子上时即是世界末日，假定将一个圆盘移到另一根柱子上用时1秒，问整个搬完用时几何？下图分析圆盘数目为3时的情况，可通过其观察移动的一般规律。
2-涂色问题例对于1×n表格，用黑白两色对方格任意涂色，但是任何两个黑格不可以相邻，求不同的涂色方法数。
a 1=2,an=3，,an=an-1+an-2偶数个数码1的n位数用1,2,3,4这四个数字，可以组成多少个含有偶数个1的n位数？a 1=3,an=(4n-1-an-1)+3an-1天平需要多少种不同的操作过程？例＊设n是一个给定的正整数，有一个天平以及n个质量分别为20，21，22，23，24，……，2n-1的砝码，现在通过n次操作逐个将所有的砝码都放上天平，每次操作都是将一个尚未放上天平的砝码放在天平的左边或者右边，并且天平的右边质量始终不超过天平左边的质量。
问有多少种不同的操作过程？a 1=1,an=(2n-1)an-1,an=(2n-1)!!1988年IMO加拿大训练题例由0,1,2这3个数组成长为n的序列，其中0和2不相邻，但0可排首位，问有多少个不同的序列？ s1=3,s2=7, s n+1=2s n+s n-1美国中学奥赛题正整数的n（n＞1）进制表示中，各位数字各不相同，且每个数字均与相邻数字相差（大数减小数）1，这样的正整数有多少个？a 1=1,an=bn-(n-1) ， an=2n+1-n-2第229页设广义的（首位为0的）满足条件的n进制数有bn个b n+1=2bn+n+1。
猴子吃桃问题数据结构课程设计
一、设计题目猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
二、运行环境（软、硬件环境）VC++6.0 PC电脑一台三、算法的需求分析1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用递归实现上述求解4) 如果采用4种方法者,适当加分//用户界面int Desk(int n){printf("**************************************************\n");printf("| 欢迎进入猴子吃桃子系统|\n");printf("| 1-数组法2-链表法3-递归法4-二叉树法5-退出|\n");printf("***************************************************\n");printf("请输入要选择的方法: ");scanf("%d",&n);getchar();system("cls"); //刷新屏幕while(n<1 || n>5){printf("***输入错误! 请重新输入***\n");scanf("%d",&n);}return n;}四、算法概要设计//采用链数据结构 (栈) 实现上述求解typedef struct{int *top;int *base;}stack;//初始化一个栈stack Init(stack *s){s->base=(int *)malloc(STACK_SIZE*sizeof(int));if(s->base == NULL){printf("Init failed !\n");exit(-1);}s->top = s->base;return *s;}//二叉树创建一个大小为DAYS(由用给出)的二叉树,二叉树的左孩子节点存放当天的桃子数，右节点存放数字1，即为多吃的一个桃子。
数据结构猴子吃桃课程设计
课程设计报告书课程名称：数据结构与算法题目：猴子吃桃子问题学生姓名：专业：计算机科学与技术班别：学号：指导老师：日期：2012 年12 月日目录一、问题描述 (2)二、基本要求 (2)三、工具和准备工作 (2)1．工具 (2)2．准备工作 (2)2.1分析题目 (2)四、分析与实现 (3)4.1数组实现 (3)4．2链结构实现 (4)4．3 递归结构实现 (6)五、测试与结论 (8)5.1 数组结构算法实现 (8)5.2 链式结构算法实现 (8)5.3 递归算法实现 (9)六、总结 (10)一、问题描述有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
二、基本要求1)采用数组数据结构实现上述求解2)采用链式数据结构实现上述求解3)采用递归实现上述求解三、工具和准备工作1．工具一台电脑、运行平台是WindonsXP 、Visual C++6.02．准备工作2.1分析题目猴子每天吃当前桃子的一半加多一个，所以可以设它们总共所摘的桃子有m 个。
因此用数学的方法可以求出总共的桃子有多少。
即：m=2m ⎥⎥⎦⎤⎢⎢⎣⎡⎪⎭⎫ ⎝⎛-n 211+2∑⎪⎪⎭⎫ ⎝⎛-+⎥⎥⎦⎤⎢⎢⎣⎡⎪⎭⎫ ⎝⎛---11212211n n n +1(n=1,2,3,…,9），其中，猴子在前9天里每天所吃的桃子数为：m ⎥⎥⎦⎤⎢⎢⎣⎡⎪⎭⎫ ⎝⎛-n 211+2⎥⎥⎦⎤⎢⎢⎣⎡⎪⎭⎫ ⎝⎛-n 211，在前9天里每天所剩下的桃子数为：m ⎥⎥⎦⎤⎢⎢⎣⎡⎪⎭⎫ ⎝⎛-n 211+∑⎪⎪⎭⎫ ⎝⎛--1212n n (n=1,2,3,…,9）。
其实也可以这样想：设猴子总摘了m 个桃子。
它们第一天吃了⎪⎭⎫ ⎝⎛+12m 个，第二天吃了⎪⎭⎫ ⎝⎛+214m 个，第三天吃了⎪⎭⎫ ⎝⎛+418m 个,…,第九天吃了⎪⎭⎫ ⎝⎛+-1212n n m 个，所以这不难看出第一天吃的桃子是第二天的2倍。
猴子吃桃算法教案
猴子吃桃算法教案教案标题：猴子吃桃算法教案教案目标：1. 学生能够理解并运用递归算法解决问题；2. 学生能够运用递归算法解决猴子吃桃问题；3. 学生能够分析和解释递归算法的工作原理。
教学资源：1. 猴子吃桃问题的故事或图片；2. 白板/黑板和彩色粉笔/白板标记笔；3. 学生练习册。
教学步骤：引入活动：1. 引入猴子吃桃问题的故事，激发学生对问题的兴趣和好奇心。
2. 引导学生思考如何解决猴子吃桃问题，鼓励他们提出自己的解决方法。
讲解递归算法：1. 解释递归算法的概念：递归算法是一种通过调用自身来解决问题的方法。
2. 通过简单的例子（如计算阶乘）来说明递归算法的工作原理和基本步骤。
引导学生解决猴子吃桃问题：1. 将猴子吃桃问题呈现在白板/黑板上，引导学生思考如何使用递归算法解决该问题。
2. 鼓励学生以小组为单位合作讨论，并给予他们一定的时间来寻找解决方案。
3. 引导学生分享他们的解决方案，并逐步引导他们理解和掌握正确的递归算法解决方法。
练习与巩固：1. 将猴子吃桃问题的练习题分发给学生，让他们独立完成。
2. 检查学生的答案，解答他们可能遇到的问题，并给予必要的指导和反馈。
3. 鼓励学生在练习中尝试不同的方法和变化，加深对递归算法的理解和应用。
拓展活动（可选）：1. 引导学生思考其他可以用递归算法解决的问题，并鼓励他们尝试解决。
2. 分享学生的解决方案，并进行讨论和比较。
总结与评价：1. 对递归算法的概念、工作原理和应用进行总结和归纳。
2. 评价学生的学习效果，鼓励他们在今后的学习中继续运用递归算法解决问题。
扩展练习（可选）：1. 提供更复杂的递归算法问题，让学生进一步挑战和巩固所学知识。
2. 鼓励学生设计自己的递归算法问题，并与同学分享解决方案。
教学反思：1. 回顾教学过程，评估教学效果，并对今后的教学进行调整和改进。
2. 收集学生的反馈和建议，以便更好地满足他们的学习需求。
学习常用算法之（4）递推法
学习常用算法之（4）递推法
递推法:递推法实际上是一种递推关系，就是为了得到问题的解，把它推到比原问题简单的问题求解，可分为顺推法和倒推法。
i.顺推法，就是先找到递推关系式，然后从初始条件出发，一步步地按递推关系式递推，直至求出最终结果
ii.倒推法，就是在不知道初始条件的情况下，经某种递推关系而获知问题的解，再倒过来，推知它的初始条件。
示例：猴子分食桃子
五只猴子采得一堆桃子，猴子彼此约定隔天早起后再分食。
不过，就在半夜里，一只猴子偷偷起来，把桃子均分成五堆后，发现还多一个，它吃掉这桃子，并拿走了其中一堆。
第二只猴子醒来，又把桃子均分成五堆后，还是多了一个，它也吃掉这个桃子，并拿走了其中一堆。
第三只，第四只，第五只猴子都依次如此分食桃子。
那么桃子数最少应该有几个呢？。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
递归算法案例—猴子吃桃子
一、案例描述
某天，一只猴子摘了一堆桃子，具体多少它没数。
猴子每天吃了其中的一半然后再多吃了一个，第二天吃剩余的一半后再多吃了一个，直到第10天，猴子发现只有一只桃子。
问这只猴子在第一天摘了多少个桃子
二、算法分析
这只猴子共用了10天吃桃子，只知道最后一天剩余1只桃子，要想求出第1天剩余的桃子数，就先要求出第2天剩余的桃子数，以此类推。
假设An表示第n天剩余的桃子数量，则有如下关系：
A1=(A2+1) x 2
A2=(A3+1) x 2
A3=(A4+1) x 2
….
A1=(A10+1) x 2
A10=1
从上述的式子可知，只能通过倒推来求得第一天的桃子数
三、算法实现
算法代码实现如下：
#include<stdio.h>
/**
*@briefpeach
*@paramn：猴子吃桃子的天数
*@return
*/
long peach(int n){
int pe;
if(n==1){
return1;
}else{
pe=(peach(n-1)+1)*2;
}
return pe;
}
int main(void)
{
int n;//天数
long peachnum;//最初桃子数
printf("pleasenumberofDate");
scanf("%d",&n);
peachnum=peach(n);
printf("Thepreviousnumberis:%1d",peachnum);
return0;
}
程序中使用递归调用peach函数来计算第一天的桃子数量。
其中关键是前一天总比后一天多一半加1.当n=10的时候，正好求出猴子吃桃子问题。