递归算法求猴子吃桃问题
猴子吃桃子问题大数据结构课程设计
标准文档目录1、 .................................................. 需求分析12、 .................................................. 概要设计12.1. 用数组数据结构实现上述求解 (1)2.2. 用链数据结构实现上述求解 (1)2.3用栈数据结构实现求解 (1)2.4用递归实现上述求解 (2)3、运行环境 (2)3.1硬件环境 (2)3.2软件环境 (2)4、详细设计 (2)4.1系统流程图 (2)4.2用数组数据结构实现上述求解 (3)4.3用链数据结构实现上述求解 (4)4.4用栈数据结构实现求解 (5)4.5用递归实现上述求解 (6)5、调试分析 (7)6、 .................................................. 运行结果7课程设计总结 (8)参考文献 (9)附录： (9)1、需求分析1、猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10 天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
要求：1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用栈实现上述求解4) 采用递归实现上述求解2、概要设计2.1. 用数组数据结构实现上述求解在taozi 函数中定义一个一维数组，分别存储每天的桃子个数，根据题目的内容找出各个数之间的关系，用数组元素表示出来，根据用户输入要计算哪一天的桃子，用for 循环控制结束。
在main 函数中让用户输入要计算的哪一天，调用taozi 函数，以便用户可查出任意一天的桃子个数，用switch 语句判断用户要执行的功能，然后用while 循环控制，直到用户输入0 为止。
2.2. 用链数据结构实现上述求解先写出预定义常量和类型，写出结点的类型定义，创建结点，初始化链表，定义变量并初始化，找出结点与其后继结点之间的联系，然后在主函数中控制。
c语言经典案例1
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时，见只剩下一个桃子了。
求第一天共摘了多少。
1.程序分析：采取逆向思维的方法，从后往前推断。
2.程序源代码：main(){int day,x1,x2;day=9;x2=1;while(day>0){x1=(x2+1)*2;/*第一天的桃子数是第2天桃子数加1后的2倍*/x2=x1;day--;}printf("the total is %d\n",x1);}-----------------------------------------------------------------------------【程序22】题目：两个乒乓球队进行比赛，各出三人。
甲队为a,b,c三人，乙队为x,y,z三人。
已抽签决定比赛名单。
有人向队员打听比赛的名单。
a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
2.程序源代码：main(){char i,j,k;/*i是a的对手，j是b的对手，k是c的对手*/for(i='x';i<='z';i++)for(j='x';j<='z';j++){for(k='x';k<='z';k++){ if(i!=k&&j!=k){ if(i!='x'&&k!='x'&&k!='z')printf("order is a--%c\tb--%c\tc--%c\n",i,j,k);}}}}-----------------------------------------------------------------------------【程序23】题目：打印出如下图案（菱形）****************************1.程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重for循环，第一层控制行，第二层控制列。
课程设计-猴子吃桃
湖南工学院数据结构课程设计题目：数据结构实现—猴子吃桃系别：专业：年级：班级：学生：学号：目录●论文提要 (3)●需求分析 (4)●详细设计 (5)⏹数组结构 (5)⏹递归 (7)⏹链表 (9)●调试结果 (11)●调试分析 (12)论文提要初步分析说明数据结构和抽象数类型等基本概念；从抽象数据类型的角度，通过数学应用的分析，把问题进行分析，整理，面后通过观察选择适当的逻辑结构、存储结构入及其相应的算法来解决问题,数据结构课程主要是为了培养我们对数据的抽象能力和对算法在时间和空间和复杂度上进行优化，猴子吃桃这一数学方面的例题是很典型的一道程序例题，在这里主要以C语言作为数据结构和描述语言，分析并采用数组数据结构，递归，链数据结构实现上述问题。
需求分析实现课题——猴子吃桃摘要：猴子吃桃这一典型的数学课题,其主要实现的过程是将其数学课题公式化，用一些简单的数据定义、初使化、通过一系列的条件判断和循环用来实现学数公式的计算机化。
通过C语言基础分析和数据结构初步了解,我们使用C语言,利用C和数据结构的结合使用,让我们在短时间内建立起对数据结构的进一步认识。
然后,形成正确的对算法和优有个的理解观念。
关键词：C语言的基本了解，数据结构的基本了解, 数据中数组的使用，递归调用，用C语言实现数据链表题目：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时，见只剩下一个桃子了，求第一天共摘了多少？要求：采用数组，递归，链数据结构实现上述求解详细设计1．数组结构把猴子吃桃的天数倒过来看的话，以天数作为数组的下标i，剩下桃子的个数a[i]的递推公式为a[i]=(a[i-1]+1)*2。
a[i]实际代表了倒数第i天剩下的桃子数。
数组结构算法的流程图如图3-1：程序如下：#include<stdio.h>void main(){int i,tao[10];tao[9]=1;//tao[9]代表第10天剩的桃子数for(i=8;i>=0;i--){tao[i]=2*(tao[i+1]+1);}printf("共摘了%d个桃子！\n",tao[0]); }2.链结构建立一个链表，根据每天桃子数与后一天桃子数的关系n=2*n+2,依次将每天的桃子数存进链表中，最后输出第一天的桃子数。
猴子吃桃子递归算法
递归算法案例—猴子吃桃子一、案例描述某天，一只猴子摘了一堆桃子，具体多少它没数。
猴子每天吃了其中的一半然后再多吃了一个，第二天吃剩余的一半后再多吃了一个，直到第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的时候，正好求出猴子吃桃子问题。
C语言程序设计例子（3）：猴子吃桃问题
C语⾔程序设计例⼦（3）：猴⼦吃桃问题题⽬：猴⼦吃桃问题：猴⼦第⼀天摘下若⼲个桃⼦，当即吃了⼀半，还不瘾，⼜多吃了⼀个 第⼆天早上⼜将剩下的桃⼦吃掉⼀半，⼜多吃了⼀个。
以后每天早上都吃了前⼀天剩下 的⼀半零⼀个。
到第10天早上想再吃时，见只剩下⼀个桃⼦了。
求第⼀天共摘了多少。
思路分析：采⽤逆向思维，从后往前推断，发现其中有相同的地⽅，即出现递推公式，可以采⽤递归⽅法。
令S10=1,容易看出S9=2(S10+1),简化⼀下S9=2S10+2S8=2S9+2…..Sn=2Sn+1+2下⾯我将解决这个问题。
（第⼀种为普通循环⽅式，第⼆种为递归⽅式）⽅法⼀：while#include<stdio.h>int main(){int day,x1,x2;day=9;x2=1;while(day>0){x1=(x2+1)*2;x2=x1;day--;}printf("the total is %d\n",x1);}⽅法⼆:递归#include<stdio.h>int sumPeach(int day);int main(){int sum;sum=sumPeach(1);printf("%d",sum);}int sumPeach(int day){if(day==10){return1;}elsereturn2*sumPeach(day+1)+2;}。
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
JS之递归（例题：猴子吃桃）
JS之递归（例题：猴⼦吃桃）
例题1：公园⾥有200个桃⼦，猴⼦每天吃掉⼀半以后扔掉⼀个，问6天以后还剩余多少桃⼦？
var sum = 200;
for(var i= 0;i<6;i++)
{
sum = parseInt(sum/2)-1
}
alert(sum);
例题2：公园⾥有⼀些桃⼦，猴⼦每天吃掉⼀半以后扔掉⼀个，第6天的时候发现还剩下1个桃⼦，问开始有⼏个桃⼦？var sum = 1;
for(var i = 0;i<6;i++)
{
sum = (sum+1)*2;
}
alert(sum);
使⽤函数解决例题2
function ShuLiang(n)//⽤来返回第n天的数量
{
if(n == 6)//已知第6天
{
return 1;//桃⼦数量为1
}
var sl = (ShuLiang(n+1)+1)*2;//第n天的桃⼦数量=（下⼀天的桃⼦数量+1）*2
return sl;//return第n天的数量
}
alert(ShuLiang(0));
函数功能：给⼀个天数，返回该天数的桃⼦的数量。
最主要的是下⼀天的桃⼦数量怎么求，函数实现过程是想要求第1天的桃⼦数量就需要2天桃⼦数量；
想要求第2天的桃⼦数量就需要3天桃⼦数量；
想要求第3天的桃⼦数量就需要4天桃⼦数量；
想要求第4天的桃⼦数量就需要5天桃⼦数量；
想要求第5天的桃⼦数量就需要6天桃⼦数量；
⽽第6天的桃⼦的数量已经知道了，是1。
进⽽5-4-3-2-1-0的数量的桃⼦就能⽤公⽰算出来了。
猴子吃桃子问题
L=(LinkList *)malloc(sizeof(LinkList));
while(1){
printf("\n");
printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
int k;
scanf("%d",&k);
switch(k){
case 1:
for(i=0;i<=10;i++){
N=recursion(i);
printf("第 %d 天,还剩桃子 %d 个\n",i,N);
}
printf("桃子原来的总数为：%d",a[0]);
break;
case 3:
L=CreatList(); DisplayList(L);
printf("桃子原来的总数为：%d\n",L->data);
p->next=L;
L=p;
}
return L;
}
void DisplayList(LinkList *L){
LinkList *p;
int i=0;
p=L;
while(p!=NULL){
printf("第%d 天，还剩桃子%d 个\n",i++,p->data);
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;这样，无论是递归解法还是数学推理解法，都能求解出猴子分桃问题的答案。
猴子吃桃问题
软件综合课程设计猴子吃桃问题学生搭配问题二〇一四年六月《猴子吃桃子课程设计》报告一、问题陈述猴子吃桃子问题：有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第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天就只余下一个桃子。
C++实现猴子吃桃的示例代码
C++实现猴⼦吃桃的⽰例代码题⽬详情有⼀天，某只猴⼦摘了⼀些桃⼦，当时吃了⼀半，⼜不过瘾，于是就多吃了⼀个。
以后每天如此，到第n天想吃时，发现就只剩下⼀个桃⼦。
输⼊n，表⽰到第n天剩下1个桃⼦，请计算第⼀天猴⼦摘的桃⼦数。
程序运⾏结果如下：101534要求时间限制：2000ms内存限制：32000kb输⼊格式:输⼊⼀个整数n,n>0，表⽰到第n天剩下1个桃⼦。
输出格式：⼀个整数，表⽰第1天摘的桃⼦数。
输⼊样例：10输出样例：1534个⼈思路根据题意，设想第0天是第⼀天刚摘桃⼦没吃的时候。
其实第n天发现想吃的时候只有⼀个桃⼦的时候其实是第(n-1)天吃完⼀半再减⼀个桃⼦，也就是就剩最后⼀个桃⼦了。
对于夹在中间的天数有这样规律的递推an+1 = an/2 - 1反过来也就是an = 2*an+1 + 2,这样⽤递归也就可以从第(n-1)天倒推回第0天(第⼀天刚摘桃⼦没吃的时候)的桃⼦总数。
天数总数0sum1sum/2 + 12(sum/2-1)/2 -13((sum/2-1)/2 -1)/2 - 1……下⾯代码#include <iostream>using namespace std;int main(){int Geshu(int day, int n);int n;cin>>n;cout<<Geshu(1,n-1)<<endl; //其实第n天发现想吃的时候只有⼀个桃⼦的时候return 0; //也就是第(n-1)天吃完后就剩最后⼀个桃⼦了}int Geshu(int sum, int day){if(day==0) //设想第0天是第⼀天刚摘桃⼦没吃的时候return sum;return Geshu(2*sum+2,day-1);}到此这篇关于C++实现猴⼦吃桃的⽰例代码的⽂章就介绍到这了,更多相关C++ 猴⼦吃桃内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
猴子吃桃问题
福建工程学院课程设计课程：数据结构课程设计题目：猴子吃桃问题专业：软件工程班级： 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”。
猴子吃桃子问题
数据结构课程设计班级：姓名：学号：日期：2011—1—3目录1 问题描述 (1)2 需求分析................................................................. 错误!未定义书签。
3 概要设计 (2)3．1函数应用23．2模块划分错误!未定义书签。
4 详细设计 (3)5 测试分析 (10)6 课程设计总结 (11)1.问题描述猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
要求：1)采用数组数据结构实现上述求解2)采用链数据结构实现上述求解3)采用递归实现上述求解2 需求分析1）根据问题已知第十天剩余桃子数，求总共桃子数，我们先列出方程可知，有后往前推可知道每天剩余桃子数，这样来求解。
2）栈链比较困难，需要跟递归联系，递归实现在说。
3）递归实现可以有数组上体现f(n)=2f(n+1)+2,跟数组的道理查不多，而栈链实现也需要这个方程，所以整个程序是相通的。
1）函数应用除了主函数以外大部分都是算法函数，还有栈的输入与输出函数：void main()Push(&S,&e)Pop(&S,&e)2）模块划分本程序包括四个模块：( 1 ) 主程序模块void main(){初始化；数组求解；递归求解；栈链求解；}( 2 ) 栈模块——实现栈的抽象数据类型( 3 )数组模块——实现数组的运用( 4 ) 递归模块——实现递归的运用#include"stdio.h"#include"stdlib.h"#define N 20typedef struct node{ int datax;int datay;struct node *next;}Node;typedef Node *LinkStack;LinkStack Push(LinkStack s,int a, int b) {Node *p;p=(LinkStack)malloc(sizeof(Node));p->datax=a;p->datay=b;p->next=s;s=p;return s;}LinkStack Pop(LinkStack s) {LinkStack p;if(s==NULL){printf("栈已空\n");return NULL;}p=s;s=s->next;free(p);return s;}void Zhanlian(int n){int f;LinkStack s=NULL;for(n=1;n<=10;n++) {if(n==10){f=1;while(s){f=s->datax*f+s->datay; s=Pop(s);}printf("%d\n",f);}elses=Push(s,2,2);}}void suzhu(){int i,a[N];a[10]=1;for(i=9;i>=1;i--)a[i]=2*a[i+1]+2; printf("%d\n",a[1]); }int fun(int n){if(n==10)return 1;elsereturn(2*fun(n+1)+2); }/*主函数*/void main(){int sum;printf("数组实现:"); suzhu();printf("栈链实现:"); Zhanlian(1);printf("递归实现:"); sum=fun(1);printf("%d\n",sum); }5 测试分析测试数据及结果如下图：6 课程设计总结总的来说这次课程设计还是学到了一些东西，可能还有很多不足的地方，但希望在以后是学习中补足。
C#之猴子吃桃儿问题的解法——猴子吐桃儿
C#之猴⼦吃桃⼉问题的解法——猴⼦吐桃⼉猴⼦第⼀天摘了许多个桃⼦，先吃了所有桃⼦的⼀半，后⼜吃了⼀个；第⼆天⼜吃了剩下桃⼦的⼀半，后⼜吃了⼀个……第⼗天，剩1个桃⼦。
问：猴⼦第⼀天摘了多少个桃⼦？⾸先对“猴⼦吃桃”的过程进⾏正向推导，设：猴⼦第⼀天摘了N个桃⼦，第n天剩Ln个桃⼦。
则——L1 = N/2 - 1L2 = L1/2 - 1/2 - 1L3 = L2/2 - 1/2^2 - 1......Ln = L(n-1)/2 - 1；然后对“猴⼦吐桃”的过程进⾏逆向推导，因为Ln = L(n-1)/2 - 1，所以L(n-1) = 2Ln + 2。
即——从某⼀天剩余的桃⼦量我们可以逆推出上⼀天的桃⼦量。
可以想象猴⼦把当天吃的桃⼦吐了出来（先吐出⼀个，再吐出⽬前桃⼦数2倍的桃⼦），就是上⼀天吃剩下的桃⼦量。
由于我们已经知道了第10天猴⼦吃完桃后剩余桃⼦数为1，这样就可以把“第10天”和“1个桃”作为两个参数传⼊⼀个“猴⼦吐桃”的函数中，让猴⼦把吃的桃⼉都吐出来，⼀直吐到第1天，并返回第⼀天猴⼦摘的桃⼦数：using System;namespace MonkeyEatPeaches{class Program{static void Main(string[] args){int left = 1;int days = 10;Console.WriteLine(MonkeyVomitPeaches(days, left));Console.ReadKey();}private static int MonkeyVomitPeaches(int days, int left){if (days > 1){left = (left + 1) * 2;days--;return MonkeyVomitPeaches(days, left);}else{return (left + 1) * 2;}}}}结果得出：答：第⼀天猴⼦摘了3070个桃⼦。
猴子吃桃问题数据结构课程设计
一、设计题目猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第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，即为多吃的一个桃子。
数据结构与算法 猴子吃桃
课程设计说明书课程名称：数据结构与算法设计题目：猴子吃桃问题院系：计算机科学与信息工程系学生姓名：学号：专业班级：指导教师：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时代背景数据结构是由数据元素依据某种逻辑联系组织起来的。
数据结构猴子吃桃课程设计
课程设计报告书课程名称：数据结构与算法题目：猴子吃桃子问题学生姓名：专业：计算机科学与技术班别：学号：指导老师：日期：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. 收集学生的反馈和建议，以便更好地满足他们的学习需求。
猴子摘桃递归+循环
#include<iostream>using namespace std;//猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。
第二天早上又将剩下的桃子吃掉了一半，又多吃了一个。
//以后每天早上都吃了前一天剩下的一半零一个。
到第十天早上看时，只剩下一个桃子了。
求第一天共摘了多少个桃子// (((n/2-1)/2-1)/2-1)==>((((1+1)*2+1)*2+1)*2+1)int total_circulation(int day, int n) //循环法{while (day!=1){n = (n + 1) * 2;day--;}return n;}int total_recursion(int n, int day) //递归法 1{if (day == 1)return n;n = (n + 1) * 2;day--;n = total_recursion(n, day);}int total_recursion_1(int n, int day) //递归法 1的简化{if (day == 1)return n;#include<iostream>using namespace std;//猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。
第二天早上又将剩下的桃子吃掉了一半，又多吃了一个。
//以后每天早上都吃了前一天剩下的一半零一个。
到第十天早上看时，只剩下一个桃子了。
求第一天共摘了多少个桃子// (((n/2-1)/2-1)/2-1)==>((((1+1)*2+1)*2+1)*2+1)int total_circulation(int day, int n) //循环法{while (day!=1){n = (n + 1) * 2;day--;}return n;}int total_recursion(int n, int day) //递归法 1{if (day == 1)return n;n = (n + 1) * 2;day--;n = total_recursion(n, day);}int total_recursion_1(int n, int day) //递归法 1的简化{if (day == 1)return n;n = total_recursion_1(((n + 1) * 2), --day);}void main(void){cout << total_circulation(10, 1) << endl;cout << total_recursion(1, 10) << endl;cout << total_recursion_1(1, 10) << endl;cout << "hello..." << endl;system("pause");return;}n = total_recursion_1(((n + 1) * 2), --day);}void main(void){cout << total_circulation(10, 1) << endl;cout << total_recursion(1, 10) << endl;cout << total_recursion_1(1, 10) << endl;cout << "hello..." << endl;system("pause");return;}。