㈠ 1-100用c语言的递归法求和
1、首先本题的思路已经给出，要求用递归算法。
2、程序源代码如下：
#include<stdio.h>
int sum(int n);
int main()
{
int i=100;
printf("1~%d的和为：
",i);
printf("%d
",sum(100));
return 0;
}
//下面是一个递归求和函数
int sum(int n)
{
if (n==1)
return 1;
else
return n+sum(n-1);
}
3、程序的输出结果如下：
㈡ C语言二叉树递归算法怎么做
#include<stdio.h>
#include<string.h>
structtreenode{
intvalue;
treenode*left;
treenode*right;
};
typedeftreenode*BiTree;
voidvisit(treenode*node)
{
printf("%2d",node->value);
}
//结点总数
intnode(BiTreeT)
{
if(!T){
return0;
}
returnnode(T->left)+node(T->right)+1;
}
//前序
voidpreOrder(BiTreeT)
{
if(T){
visit(T);
preOrder(T->left);
preOrder(T->right);
}
}
//中序
voidinOrder(BiTreeT)
{
if(T){
inOrder(T->left);
visit(T);
inOrder(T->right);
}
}
//后序
voidpostOrder(BiTreeT)
{
if(T){
postOrder(T->left);
postOrder(T->right);
visit(T);
}
}
//叶子节点数
intleafnode(BiTreeT)
{
if(T){
if(!T->left&&!T->right)
return1;
else
leafnode(T->left)+leafnode(T->right);
}else{
return0;
}
}
intheight(BiTreeT)
{
if(T){
intlh=height(T->left);
intrh=height(T->right);
return(lh>rh?lh:rh)+1;
}else{
return0;
}
}
intmain()
{
return0;
}
㈢ C语言递归算法
本人学c++，c的语法已经淡忘了，但是递归不管什么语言都是一个原理
其实简单一点来说就像数学里面的数列的通项公式：
例如一个数列是2，4，6，8，10......
很容易就可以得到通项公式是a[n]=2*n n是大于0的整数
你肯定学过这个数列的另外一种表示方式就是： a[1]=2, a[n]=a[n-1]+2 n是大于1的整数
其实这就是一个递归的形式，只要你知道初始项的值，未知项和前几项之间的关系就可以知道整个数列。
程序例子：比如你要得到第x项的值
普通循环：
for(int i=1; i<=n; i++)
if (i == x)
cout << 2*i; /*cout 相当于 c里面的printf,就是输出.*/
递归：
int a(int x) {
if (x = 1)
return 2; /* 第一项那肯定是2了，这个也是递归的终止条件！ */
else return a(x-1)+2; /* 函数自身调用自身是递归的一个特色 */
比如x=4,那么用数学表示就是a(4)=a(3)+2=(a(2)+2)+2=((a(1)+2)+2)+2
其实递归方法最接近自然，也是最好思考的一个方法，难点就是把对象建模成递归形式，但是好多问题本身就是以递归形式出现的。
普通递归就是数据结构上的堆栈，先进后出。
例如上面x=4,把a(4)放入栈底，然后放入a(3),然后a(2),a(1),a(1)的值已知，出栈，a(1)=2,a(2)出栈a(2)=a(1)+2=2+2=4,a(3)出栈a(3)=a(2)+2=(a(1)+2)+2=6,a(4)出栈a(4)=a(3)+2=(a(2)+2)+2=((a(1)+2)+2)+2=8
再比如楼上的阶乘例子，当n=0 或 1时,0!=1,1!=1,这个是阶乘的初始值，也是递归的终止条件。然后我们知道n!=n*(n-1)!,当n>1时,这样我们又有了递归形式，又可以以递归算法设计程序了。（楼上已给出谭老的程序，我就不写了）。
我给出一种优化的递归算法---尾递归。
从我给出的第一算法可以看出，先进栈再出栈，递归的效率是很低的。速度上完全比不上迭代（循环）。但是尾递归引入了一个新的函数参数，用这个新的函数参数来记录中间值.
普通递归阶乘fac(x),就1个x而已，尾递归用2个参数fac(x,y),y存放阶乘值。
所以谭老的程序就变成
// zysable's tail recursive algorithm of factorial.
int fac(int x, int y) {
if (x == 1)
return y;
else return fac(x-1, y*x);}
int ff(int x) {
if (x == 0)
return 1;
else return fac(x,1);}
对于这个程序我们先看函数ff，函数ff其实是对fac的一个封装函数，纯粹是为了输入方便设计的，通过调用ff(x)来调用fac(x,1),这里常数1就是当x=1的时候阶乘值了，我通过走一遍当x=3时的值即为3!来说明一下。
首先ff(3),x!=0,执行fac(3,1).第一次调用fac，x=3,y=1,x!=1,调用fac(x-1,y*x),新的x=2,y=3*1=3,这里可以看到，y已经累计了一次阶乘值了，然后x还是!=1,继续第三次调用fac(x-1,y*x),新的x=1,y=2*3=6,然后x=1了，返回y的值是6，也就是3！.你会发现这个递归更类似于迭代了。事实上我们用了y记录了普通递归时候，出栈的乘积，所以减少了出栈后的步骤，而且现在世界上很多程序员都在倡议用尾递归取消循环，因为有些在很多解释器上尾递归比迭代稍微效率一点.
基本所有普通递归的问题都可以用尾递归来解决。
一个问题以递归来解决重要的是你能抽象出问题的递归公式，只要递归公式有了，你就可以放心大胆的在程序中使用，另外一个重点就是递归的终止条件；
其实这个终止条件也是包含在递归公式里面的，就是初始值的定义。英文叫define initial value. 用普通递归的时候不要刻意让自己去人工追踪程序，查看运行过程，有些时候你会发现你越看越不明白，只要递归公式转化成程序语言正确了，结果必然是正确的。学递归的初学者总是想用追踪程序运行来让自己来了解递归，结果越弄越糊涂。
如果想很清楚的了解递归，有种计算机语言叫scheme,完全递归的语言，因为没有循环语句和赋值语句。但是国内人知道的很少，大部分知道是的lisp。
好了，就给你说到这里了，希望你能学好递归。
PS:递归不要滥用，否则程序极其无效率，要用也用尾递归。by 一名在美国的中国程序员zysable。
㈣ C语言如何用递归算法求1!+2!+3!+...n!
#include<stdio.h>
float fun(int n)
{
if(n==1) return 1;//如果n=1则直接返回1
return n*fun(n-1);//否则返回n*fun(n-1),以此计算n的阶乘，这条语句就是递归体
}
void main()
{
int i;
float sum=0;
for(i=1;i<=n;i++){
sum+=fun(i); //循环调用，用sum累计
}
printf("sum=%.2f\n",sum);
}
㈤ c语言算n的阶乘的递归算法
思路：递归求阶乘函数，如果输入的参数等于1则返回1，否则返回n乘以该函数下次递归。
参考代码：
#include<stdio.h>
intfun(intn)
{
if(n==1||n==0)return1;//如果参数是0或者1返回1
returnn*fun(n-1);//否则返回n和下次递归的积
}
intmain()
{
intn;
scanf("%d",&n);
printf("%d
",fun(n));
return0;
}
/*
5
120
*/
㈥ c语言 函数递归调用的简单例子
举一个用递归调用函数求输入非负整数的阶乘的例子，如下：
//#include"stdafx.h"//Ifthevc++6.0,withthisline.
#include"stdio.h"
intfact(intn){
if(n==1||n==0)return1;
elsereturnn*fact(n-1);
}
intmain(void){
intx;
while(1){
printf("Inputx(int12>=x>=0)...
x=");
if(scanf("%d",&x),x>=0&&x<=12)//x>12时会使结果溢出
break;
printf("Error,redo:");
}
printf("%d!=%d
",x,fact(x));
return0;
}
㈦ 求用C语言实现二叉树层次遍历的递归算法，谢谢！！！
算法思想：层次遍历目前最普遍用的就是队列的那种方式，不是递归，但是用到while循环，既然题目要求用递归，可以用递归实现该while循环功能。算法如下：
void TransLevele(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
if (r->left != NULL)
{
InsertQueue(r->left);
}
if (r->right != NULL)
{
InsertQueue(r->right);
}
Tree *t = DeleteQueue();
TransLevele(t);
}
//测试程序，创建树输入例如ABD##E##C##,根左右创建的方式。
如下代码是测试通过的。
#include "stdlib.h"
#define MAX 100
typedef int Element;
typedef struct tree
{
Element ch;
struct tree *left;
struct tree *right;
}Tree;
typedef struct queue
{
Tree *a[MAX];
int front;
int rear;
}Queue;
Queue Qu;
void Init();
int InsertQueue(Element ch);
Tree *DeleteQueue();
void CreateTree(Tree **r);
void TransLevele(Tree *r);
void PrintTree(Tree *r);
int main()
{
Tree *r=NULL;
CreateTree(&r);
PrintTree(r);
printf("\n");
TransLevele(r);
return 0;
}
void Init()
{
int i=0;
for (i=0; i<MAX; i++)
{
Qu.a[i] = NULL;
}
Qu.front = 0;
Qu.rear = 0;
}
int InsertQueue(Tree *r)
{
if ( (Qu.rear+1)%MAX == Qu.front)
{
printf("Queue full!");
return 0;
}
Qu.a[Qu.rear] = r;
Qu.rear = (Qu.rear+1)%MAX;
return 1;
}
Tree *DeleteQueue()
{
if (Qu.front == Qu.rear)
{
printf("Queue empty");
return NULL;
}
Tree *t=NULL;
t = Qu.a[Qu.front];
Qu.front = (Qu.front+1)%MAX;
return t;
}
void CreateTree(Tree **r)
{
Element ch;
ch=getchar();
if (ch=='#')
{
(*r)=NULL;
return ;
}
*r = (Tree *)malloc(sizeof(Tree));
(*r)->ch = ch;
CreateTree(&((*r)->left));
CreateTree(&((*r)->right));
}
void PrintTree(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
PrintTree(r->left);
PrintTree(r->right);
}
void TransLevele(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
if (r->left != NULL)
{
InsertQueue(r->left);
}
if (r->right != NULL)
{
InsertQueue(r->right);
}
Tree *t = DeleteQueue();
TransLevele(t);
}
㈧ C语言折半查找之递归算法
T的elem没初始化，没有申请内存空间。
而且Create的参数T必须要用引用传递，不然main中执行完Create(T,a)后，T的值不会变化 。
void Create(SSTable &T,int a[]){
int j;
T.elem=new ch[len(a)];
for(j=1;j<len(a)+1;j++)T.elem[j].key=a[j];
T.length=len(a);
}
㈨ C语言迭代与递归比较（举例）
我举个例子：
①斐波那契数列：1，1，2，3，5，8，13，21，34......
迭代：int Fib[N];
Fib[0]=1;Fib[1]=1;
for(i=2;i<N;i++)
Fib[i]=Fib[i-1]+Fib[i-2];
}
递归：int Fib(int n)
{ if(n==0||n==1)return 1;
else return (Fib(n-1)+Fib(n-2));
}
㈩ 关于c语言递归调用的经典例题，求跪大神详解 ！
这是汉诺塔吧。
原理：(总共n个盘子)
1、将第一个位置（起始位置）上的n-1个盘子移到第二个位置上，此时第一个位置只剩第n个盘子
2、将第一个位置上的最后一个盘子（第n个盘子）移到第三个位置（目标位置）上，再将第二个位置上的n-1个盘子移到第三个位置上。
你不需要晓得n-1个盘子如何从一个位置移到另一个位置，让程序做。n-->n-1-->n-2......1，问题不断的小化，当n=1时，直接从第一个位置移到第三个位置，再倒过来推1-->2-->3......-->n。最终问题就会被解决。
hanoi()函数就是将问题小化，使n-->1
move()函数中char x是起始位置,char y是目标位置，即x-->y.用A、B、C来显示盘子是如何移动的
