用递归算法计算斐波拉契级数数列中第n项的值,1、1、2、3、5、8、13、21、

我用递归方式写的 你看看：
public class MainClass
{
public static void Main()
{
//下面的10就是需要这个规则下的第十个数.
Console.WriteLine(amwih(10));
}
public static int amwih(int i)
{
if (i 0 && i

给了一个程序给你参考，有前中后序遍历，实现了前5个功能。
提示：8功能可以用任意一种遍历方法，在程序中，将打印字符的部分换成自己的判断程序即可。
6功能用后续遍历，当遍历到任意一节点时，判断其孩子是不是叶子，是就删除。
7功能参考求广度的实现】
9功能参考6功能，用前序遍历也可以
10功能也参考求广度的方法
程序：
#include
#include
#include
#include
#define NUM_NODE 12
#define MOST_DEPTH 10
typedef struct BiTree{
int data;
BiTree *lchild;
BiTree *rchild;
}BiTree;
typedef struct Answear{
int Degree0;
int Degree1;
int Degree2;
int Depth;
} Answear;
BiTree* CreateTree(int n)
{
BiTree *t;
if (n NUM_NODE) return NULL;
if (!(t = (BiTree*)malloc(sizeof(BiTree))))
return NULL;
t->data = n;
printf("%d ", t->data);
t->lchild = CreateTree(2*n);
t->rchild = CreateTree(2*n+1);
return t;
}
void FreeTree(BiTree *t)
{
if (t)
{
if (t->lchild)
FreeTree(t->lchild);
if (t->rchild)
FreeTree(t->rchild);
printf("%d ", t->data);
free(t);
}
}
//中序遍历
void InOrder(BiTree *t)
{
BiTree **stack, **top, *p;
//创建堆栈
if (!(stack = (BiTree**)malloc(NUM_NODE * sizeof(BiTree))))
{
printf("InOrder failed for memeryn");
return;
}
//初始化堆栈
top = stack;
p = t;
while (p || top>stack)//p不为NULL，堆栈不空
if (p)
{
*top++ = p;//p入堆栈
p = p->lchild;
}
else
{
p = *--top;//p出栈
if (p) printf("%d ", p->data);
p = p->rchild;
}
}
//前序遍历
void PreOrder(BiTree *t)
{
BiTree **stack, **top, *p;
if (!(stack = (BiTree**)malloc(NUM_NODE * sizeof(BiTree))))
{
printf("InOrder failed for memeryn");
return;
}
top = stack;
p = t;
while (p || top>stack)
if (p)
{
*top++ = p;
if (p) printf("%d ", p->data);
p = p->lchild;
}
else
{
p = *--top;
p = p->rchild;
}
}
//后序遍历
void PostOrder(BiTree *t)
{
BiTree **stack, **top, *p, *p_old, *p_new;
int Flag;
if (!(stack = (BiTree**)malloc(NUM_NODE * sizeof(BiTree))))
{
printf("InOrder failed for memeryn");
return;
}
top = stack;
Flag = 0;
*top++ = t;
while (top > stack)
{
p = *(top-1);
if (p->lchild && !Flag)
*top++ = p->lchild;
else
{
if (p->rchild)
{
*top++ = p->rchild;
Flag = 0;
}
else
{
p_old = *--top;
printf("%d ", p_old->data);
while (top > stack)
{
p_new = *(top-1);
if (p_old == p_new->lchild)
{
Flag = 1;
break;
}
else
{
p_new = *--top;
printf("%d ", p_new->data);
p_old = p_new;
Flag = 0;
}
}
}
}
}
}
//中序遍历求结点的深度和度为0，1,2的结点数，结果保存在pAns指的。。。
void InOrderDO(BiTree *t , Answear * pAns)
{
//遍历用的数据
BiTree **stack, **top, *p;
//求深度的数据
int curDeep, MostDeep;
//创建堆栈
if (!(stack = (BiTree**)malloc(NUM_NODE * sizeof(BiTree))))
{
printf("InOrder failed for memeryn");
return;
}
//初始化堆栈
top = stack;
p = t;
//初始化数据
curDeep = MostDeep = 0;
pAns->Degree0 = pAns->Degree1 = pAns->Degree2 = 0;
//遍历循环
while (p || top>stack)//p不为NULL，堆栈不空
if (p)
{
*top++ = p;//p入堆栈
p = p->lchild;
curDeep++;
if (MostDeep < curDeep) MostDeep = curDeep; //保存最深度
}
else
{
p = *--top;//p出栈
curDeep--;
//if (p) printf("%d ", p->data); //Visit结点
//计算个结点的度
if (p->lchild && p->rchild) pAns->Degree2++;
else if (p->lchild || p->rchild) pAns->Degree1++;
else pAns->Degree0++;
p = p->rchild;
}
//得到深度
pAns->Depth = MostDeep;
return ;
}
//前序递归求广度
void Pre(BiTree *T, int* woed, int depth)
{
woed[depth]++;
if (T->lchild) Pre(T->lchild, woed, depth+1);
if (T->rchild) Pre(T->rchild, woed, depth+1);
}
//求广度的程序，返回值为广度
int GetTreeWidth(BiTree *root)
{
int i, WidthOfEachDepth[MOST_DEPTH]={0};
Pre(root, WidthOfEachDepth, 0);
for (i=1; i

求阶乘而已
#include
long fact(int n){ //递归求阶乘
if (n

int jiecheng(int z)
{
if(z>=0)
{if(z==0)
return 1;
else if(z==1)
return 1
else
return z*jiecheng(z-1);
}
else
return -1;
}
int binconf(int x,int y)
{
if(x>y)
return jiecheng(x)/(jiecheng(y)*jiecheng(x-y));
else
return -1;
}
没测试过,不知对不对

(1)
Function nn(n:integer):longint;
begin
if n=0 then nn:=1
else nn:=nn(n-1)+nn(n-1)
end;
(2)
【加法次数】= n
(3)
Function nn(n:integer):longint;
begin
nn:=1 shl n
end;

首先 你得注意 如果你求的斐波那契数的第几项项数较大 就需用到高精度
以下程序仅适用于“无需高精度”的情况：
此为递归算法：
#include
using namespace std;
int work(int x)
{
if(x==1)return 0;
else if(x==2)return 1;
else return work(x-1)+work(x-2);
}
int main(void)
{
int i;
cin>>i;
couti;
a[1]=0;a[2]=1;
for(j=3;j

ACD都用的是栈，B要用到队列

哗啦啦啦啦啦，我的宝贝 北京欢迎你 像音乐感动你纪敏加 屠洪刚 吴彤

这个就是斐波那契数列.
递归就像递推,跟数学上的递推很相似.
“又一层层代回去,最后加出正确答案”
这句话的意思是,比如算Foo(5)
(a) Foo(5) = Foo(4)+Foo(3)
(b) Foo(4) = Foo(3)+Foo(2)
(c) Foo(3) = Foo(2)+Foo(1) = 1 + 1 = 2;
然后把(c)的结果代入到(b)中,
(b) Foo(4) = Foo(3)+Foo(2) = 2 + 1 = 3
然后把(b)和(c)的结果代入到(a)中,
(a) Foo(5) = Foo(4)+Foo(3) = 3 + 2 = 5
最后得到Foo(5)
两次代入就是所说的一层层代回去

function fibonacci(n){
if(n == 1 | n ==2){
return 1;
}else{
return fibonacci(n-1) + fibonacci(n-2);
}
}

1,定义递归函数:
power(n)
if n=0
return 1
else
return 2*power(n-1)

2,这个递归算法是O(n)的.或者说,计算power(n)的计算次数等于计算power(n-1)的计算次数+1.
3,计算幂最好的方式是分治.利用 2^n = (2^(n/2))^2 递归或递推,这个方法的复杂度降到O(logN)

靠，缩进全被百度搞乱了，自己排版

　　#include
using namespace std;
　　//二叉树节点
struct BiTreeNode{
int data;
BiTreeNode *left;
BiTreeNode *right;
};
　　//写一个类，方便二叉树的建立和删除
class BiTree{
private:
void deleteAllNode(BiTreeNode *root);
public:
BiTreeNode *root;
BiTree();
~BiTree();
void CreateTree();
void deleteLeaves(BiTreeNode *root);
bool DepthOfTheNode(BiTreeNode *currentNode,BiTreeNode *p, int depthOfFather);
void FindMaxValue(BiTreeNode *currentNode, int *maxValue);
void ExchangeLeftAndRight(BiTreeNode *currentNode);
void OutputValueAndDepthByQIANXU(BiTreeNode *currentNode, int depthOfFather); //不好意思，用了拼音
};
BiTree::BiTree()
{
root = NULL;
}
BiTree::~BiTree()
{
deleteAllNode(root);
}
void BiTree::deleteAllNode(BiTreeNode *root)
{
if (root == NULL) return;
deleteAllNode(root->left);
deleteAllNode(root->right);
cout data data = 1;
root->left = new BiTreeNode;
root->left->data = 2;
root->right = new BiTreeNode;
root->right->data = 3;
　　BiTreeNode *p;
p = root->left;
p->left = NULL;
p->right = new BiTreeNode;
p->right->data = 4;
p->right->left = p->right->right = NULL;
　　p= root->right;
p->left = new BiTreeNode;
p->left->data = 5;
p->left->left = p->left->right = NULL;
　　p->right = NULL;
}
　　//用递归算法删除叶子
void BiTree::deleteLeaves(BiTreeNode *root)
{
if (root == NULL) return;
if (!root->left && !root->right) return; //表示是根节点(或者出错，跑到叶子节点了，这种情况应该不会)，不删除
if (root->left) //当前节点有左子树
{
if (root->left->left || root->left->right) //左子树不是叶子
deleteLeaves(root->left);
else //当前节点的左子节点是叶子
{
delete root->left;
root->left = NULL;
}
}
if (root->right)
{
if (root->right->left || root->right->right)
deleteLeaves(root->right);
else //当前节点的右子节点是叶子
{
delete root->right;
root->right = NULL;
}
}
}
　　int depth = 0; //一个用来存储深度的全局变量，虽然在实际编程中这样用不好
//但一切为了方便。
//节点p的深度,递归法
bool BiTree::DepthOfTheNode(BiTreeNode *currentNode,BiTreeNode *p, int depthOfFather)
{
if (currentNode == NULL) return false;
if (currentNode == p) //当前节点为要找的节点
{
depth = depthOfFather + 1;
return true;;
}
if (DepthOfTheNode(currentNode->left, p, depthOfFather+1)) //找当前节点的左子树
return true;
else
return DepthOfTheNode(currentNode->right, p, depthOfFather+1);
}
　　//用递归找最大值，最大值存储在maxValue所指的内存 ,这里使用前序遍历
void BiTree::FindMaxValue(BiTreeNode *currentNode, int *maxValue)
{
if (currentNode == NULL) return;
*maxValue = *maxValue > currentNode->data ? *maxValue : currentNode->data;
FindMaxValue(currentNode->left, maxValue); //遍历左子树
FindMaxValue(currentNode->right, maxValue);
}
　　//交换左右，用前序遍历
void BiTree::ExchangeLeftAndRight(BiTreeNode *currentNode)
{
if (currentNode == NULL) return;
BiTreeNode *temp;
temp = currentNode->left;
currentNode->left = currentNode->right;
currentNode->right = temp;
　　ExchangeLeftAndRight(currentNode->left);
ExchangeLeftAndRight(currentNode->right);
}
　　//以前序次序输出一棵二叉树所有结点的数据值及结点所在层次
void BiTree::OutputValueAndDepthByQIANXU(BiTreeNode *currentNode, int depthOfFather)
{
if (currentNode == NULL) return;
cout right, 0);
cout

设0 为数列的第一项
递推：
int f1(int n)
{
int i,item = -2;
for (i = 1; i

新手吧,好多新手都问这个问题.
str[10000];
sum=0;
function digui(j){
if(j10){
return;
}
if(j==10 ){
if(str[0]+str[1]+...+str[9]==90){
echo str;
sum+=1;
}
return;
}
for(i=1;i

每个数是前面3个数的和

1、先采用冒泡法对数组P(N)进行升序排列.
For I = 1 To N - 1
JHBZ = 0 '数据是否交换的标志,凡发生交换就置JHBZ=1,否则为0.
For J = 1 To N - I
If P(J) > P(J + 1) Then
T = P(J)
P(J) = P(J + 1)
P(J + 1) = T
JHBZ = 1
End If
Next J
If JHBZ = 0 Then Exit For
Next I
2、数组P(N)的最后一个元素就是我们所求的最大元素。

在考试中基本来说一般线性表,二叉树算法设计问题,这两个地方找出没有问题的,有时排序,这样一来就会.的算法教材不要求写的,把握的想法?现场算法的算法可以是一个特殊的数字.

A 对
B 尾递归优化
C 不是必须的
D 构造方法递归调用自己？不能吧

#include
int GetFibonacci(int n)
{
if (n == 1 || n == 2) return 1;
else return GetFibonacci(n-1)+GetFibonacci(n-2);
}
void main()
{
int n;
scanf("%d",&n);
for (int i = 1; i

所有的循环都可以改为递归.
只是这里用循环,判断点到圆心的距离即可,
速度/稳定性/资源使用/可读性 等都挺好.
觉得没必要为了递归而递归.

int fun(n){
if(n