A. c语言汉诺塔问题非递归解法代码求大神讲解
int game2()要改为int main()后才可编译运行：
#include<stdio.h>
#include<stdlib.h>
#define CSZL 10
#define FPZL 10
typedef struct hanoi
{
int n;
char x,y,z;
}hanoi;
typedef struct Stack //定义栈结点
{
hanoi *base,*top;
int stacksize;
}Stack;
int InitStack(Stack *S)
{
S->base=(hanoi *)malloc(CSZL*sizeof(hanoi)); //申请栈空间
if(!S->base) //若申请不成功返回失败信息
return 0;
S->top=S->base; //置为空栈
S->stacksize=CSZL; //栈结点数
return 1;
}
int PushStack(Stack *S,int n,char x,char y,char z) //入栈
{
if(S->top-S->base==S->stacksize) //若栈已满
{
S->base=(hanoi *)realloc(S->base,(S->stacksize+FPZL)*sizeof(hanoi)); //补充申请，扩充栈空间
if(!S->base) //若申请不成功返回失败信息
return 0;
S->top=S->base+S->stacksize; //重置栈顶指针
S->stacksize+=FPZL; //重置栈空间尺寸
}
S->top->n=n; //新结点信息存入栈顶结点
S->top->x=x;
S->top->y=y;
S->top->z=z;
S->top++; //栈中元素加1
return 1;
}
int PopStack(Stack *S,int *n,char *x,char *y,char *z) //出栈
{
if(S->top==S->base) //若栈已空
return 0; //返回出错信息
else
{
S->top--; //栈顶指针减1
*n=S->top->n; //返回出栈元素信息
*x=S->top->x;
*y=S->top->y;
*z=S->top->z;
return 1;
}
}
int EmptyStack(Stack *S) //判定是否空栈
{
if(S->base==S->top)
return 1;
else
return 0;
}
int i=1;
void Move(char x,char z) //打印移动盘子的信息
{
printf(" 第%d步，%c-->%c",i++,x,z);
}
int main() /* 非递归法 */
{
int n;
char x,y,z;
Stack *S;
system("cls"); /*清屏指令*/
S=(Stack *)malloc(sizeof(Stack)); //申请栈空间
if(!S)
return 0;
if(!InitStack(S)) //初始化栈
return 0;
printf("请输入汉诺塔的初始盘子数量以及轴的名称：");
scanf("%d %c%c%c",&n,&x,&y,&z);
if(!PushStack(S,n,x,y,z)) //要移动的盘子数及各轴名称入栈
return 0;
while(!EmptyStack(S)) //当栈非空时循环
{
if(!PopStack(S,&n,&x,&y,&z)) //若空栈则退出循环，否则出栈一个任务
break;
if(n==1) //若只有一个盘子，直接移动
{
Move(x,z);
}
else //有1个以上的盘子时入栈（注意栈的工作特点，是后进先出，所以最先做的事要最后入栈）
{
if(!PushStack(S,n-1,y,x,z)) //将上层的n-1个盘子从y移向z
break;
if(!PushStack(S,1,x,y,z)) //将底层的盘子从x移向z
break;
if(!PushStack(S,n-1,x,z,y)) //将上层的n-1个盘子从x移向y
break;
}
}
free(S->base);
S->base=NULL;
S->top=NULL;
S->stacksize=0;
return 0;
}
B. 急求C语言编程答案——递归、非递归
#include<stdio.h>
void apart(long);
void main()
{
long N;
printf("请输入要拆分的数N：\n");
scanf("%ld",&N);
printf("\n");
printf("拆分后的结果是：\n");
apart(N);
printf("\n");
}
void apart(long N)
{
int i;
char a[30]; // 存放N中的各位数
i=0;
while(N)
{
a[i++]=N%10+'0'; //转换成ascii码
N/=10;
}
while(i--) //倒序输出
{
printf("%c ",a[i]);
}
}
C. 数据结构C语言 一个递归和非递归的代码
#include "stdio.h"
#include "stdlib.h"
#define STACK_INIT_SIZE 10 //栈的初始长度
#define STACKINCREMENT 5 //栈的追加长度
typedef struct bitree{
char data;
struct bitree *lchild,*rchild;
}bitree; //二叉树结点定义
typedef struct {
bitree **base;
bitree **top;
int stacksize;
}sqstack; // 链栈结点定义top栈顶 base栈底 且栈元素是指向二叉树结点的二级指针
//建立一个空栈
int initstack(sqstack *s)
{s->base=(bitree **)malloc(STACK_INIT_SIZE*sizeof(bitree *)); //栈底指向开辟空间
if(!s->base) exit(1); //抛出异常
s->top=s->base; //栈顶=栈尾 表示栈空
s->stacksize=STACK_INIT_SIZE; //栈长度为开辟空间大小
return 1;
}
//进栈
int push(sqstack *s,bitree *e)
{if(s->top-s->base>=s->stacksize) //如果栈满 追加开辟空间
{s->base=(bitree **)realloc (s->base,(s->stacksize+STACKINCREMENT)* sizeof(bitree*));
if(!s->base) exit(1); //抛出异常
s->top=s->base+s->stacksize; //感觉这一句没用
s->stacksize+=STACKINCREMENT;}
*(s->top)=e;s->top++; //进栈 栈顶后移
return 1;
}
//出栈
int pop(sqstack *s,bitree **e)
{if(s->top==s->base) return 0; //栈空 返回0
--s->top;*e=*(s->top); //栈顶前移 取出栈顶元素给e
return 1;}
//取栈顶
int gettop(sqstack *s,bitree **e) //去栈顶元素 注意top指向的是栈顶的后一个
{if(s->top==s->base) return 0; //所以 s->top-1
*e=*(s->top-1);
return 1;
}
/*------------------------非递归-----先序建立二叉树----------------------------------*/
bitree *createprebitree()
{char ch;bitree *ht,*p,*q;
sqstack *s;
s=(sqstack *)malloc(sizeof(bitree)); //加上这一句为s 初始化开辟空间
ch=getchar();
if(ch!='#'&&ch!='\n') /* 输入二叉树先序顺序 是以完全二叉树的先序顺序
不是完全二叉树的把没有的结点以#表示 */
{ht=(bitree *)malloc(sizeof(bitree));
ht->data=ch;
ht->lchild=ht->rchild=NULL;
p=ht;
initstack(s);
push(s,ht); //根节点进栈
while((ch=getchar())!='\n') // 算
{if(ch!='#') {q=(bitree *)malloc(sizeof(bitree)); // 法
q->data=ch; //
if(p==*(s->top-1)) p->lchild=q; // 核
else p->rchild=q; //
push(s,q);p=q; // 心
} //
else {if(p==*(s->top-1)) p->lchild=NULL; // 的
else p->rchild=NULL; //
pop(s,&p);} // 步
//
} // 骤
return ht;
}
else return NULL;
}
/*--------------------------递归---------先序建立二叉树-------------------------------*/
void CreateBiTree(bitree **T) {
//按先序次序输入二叉树中的结点的值（一个字符），空格字符表示空树，
//构造二叉链表表示二叉树
char ch;
scanf("%c",&ch);
if(ch=='#') *T=NULL;
else{
*T=(bitree * )malloc(sizeof(bitree));
if(!*T) exit(1);
(*T)->data=ch; //生成根结点
CreateBiTree(&(*T)->lchild); //构造左子树
CreateBiTree(&(*T)->rchild); //构造右子树
}
}
/*--------------------------非递归-------中序建立二叉树-------------------------------*/
/*--------------------------递归---------中序建立二叉树-------------------------------*/
/*--------------------------非递归-------后序建立二叉树-------------------------------*/
/*--------------------------递归---------后序建立二叉树-------------------------------*/
/*-----------------------非递归------先序输出二叉树------------------------------*/
void preordertraverse(bitree *h)
{sqstack m;
initstack(&m);
while(h||m.base!=m.top)
{if(h) {push(&m,h);printf("%c",h->data);h=h->lchild;}
else{pop(&m,&h);
h=h->rchild;}
}
}
/*------------------------非递归-----中序输出二叉树----------------------------*/
void inordertraverse(bitree *h)
{sqstack m;
initstack(&m);
while(h||m.base!=m.top)
{if(h) {push(&m,h);h=h->lchild;}
else {
pop(&m,&h);
printf("%c",h->data);
h=h->rchild;
}
}
}
/*---------------------非递归----后序遍历二叉树----------------------------------*/
void postordertraverse(bitree *h)
{
sqstack m;
initstack(&m);
while(h||m.base!=m.top)
{if(h) {
push(&m,h);
h=h->lchild;}
else {
bitree *r; //使用r结点表示访问了右子树 代替标志域
gettop(&m,&h);
if(h->rchild&&h->rchild!=r)
{h=h->rchild;
push(&m,h);
h=h->lchild;}
else{pop(&m,&h);
printf("%c",h->data);
r=h;h=NULL;}
}
}
}
//层次遍历二叉树
/*-------------------------------主过程-------------------------------*/
int main()
{bitree *ht;
printf("先序非递归建立一个二叉树:");
if((ht=createprebitree())!=NULL) //非递归建立
//CreateBiTree(&ht);
//if(ht!=NULL) //递归建立
{
printf("先序遍历输出二叉树:");
preordertraverse(ht);
putchar('\n');
printf("中序遍历输出二叉树:");
inordertraverse(ht);
putchar('\n');
printf("后序遍历输出二叉树:");
postordertraverse(ht);
putchar('\n');
}
else printf("空二叉树\n");
}
D. 编写递归和非递归求阶乘的函数，用C语言
C语言递归函数和非递归函数求阶乘，参考代码如下:
#include<stdio.h>
long fun1(int n)
{
if(n<=1) return 1;
return fun1(n-1)*n;
}
long fun2(int n)
{
int i;
long m=1;
for(i=1; i<=n; ++i)
m*=i;
return m;
}
int main()
{
printf("%ld\n",fun1(9));
printf("%ld\n",fun2(9));
return 0;
}
E. C语言递归函数和反递归函数
//由于整数的位数是不确定的，可以很长，所以不能用int类型
//为了能表示长整数，我们采用字符串来表示
//一下的代码是用c++写的，和c区别不大
#include<iostream>
#include<cstring>
using namespace std;
void revstr1(char *str){
int length=strlen(str);
if(length>0){
char c=*(str+length-1);
*(str+length-1)='\0';
cout<<revstr1(str);
cout<<c;
}
}
void revstr2(char *str){
char *p;
int length=strlen(str);
//从后面将整数反序输出
for(p=str+length-1; p>=str,p--)
cout<<*p;
//补上换行符
cout<<endl;
}
void main(){
//整数最大长度100，可以调节
char str[101];
cin.getline(str,100);
//递归输出
revstr1(str);
//补上换行符
cout<<endl;
//非递归输出
revstr2(str);
return 0;
}
F. C语言，用非递归的算法（链栈）计算二叉树的结点数。
＃包括
使用命名空间std;
定义MAX 100
类二叉树
{
char数据;
二叉树* lchild;
二叉树* rchild;
};的
二叉树* creatree（）/ /非递归创建一棵二叉树
{ />字符CH;
诠释前面= 1，后= 0; / /初始化队列
B树*根*，S * Q [MAX];
根= NULL;
cout <<“请'@'表示'空'，'＃'，”结束“，他的贡献层：”<< endl;
CH = getchar函数（）;
而因素（ch! = '＃'）
{
= NULL，/ /读取的第一个假设是空的节点_at_
（ch! =“_at_'）
{
新的二叉树;
- >数据= CH;
- > lchild = NULL;
- > rchild = NULL;
}
后端的团队+ +; / /指针递增
Q [后] =;
如果（后部== 1）
根= / /根
其他
{
（S && Q [前方]）/ /当前节点的父节点是不是空的节点
（后部％2 == 0）
Q [前] - > lchild;
其他
Q [前] - > rchild =;
（背面％2 == 1）
前+ +;
} BR /> CH = getchar函数（）/ /读出下一个节点的值
}
返回根;
}
无效后序（B树* BT）
二叉树* p = BT，*栈[MAX] ;/ / p表示当前节点协议栈栈[]
INT标记用于存储节点[MAX];
顶部= -1 ;
{
在while（p! = NULL）/ /第一个处理器节点的左子节点都留给孩子，反过来堆栈
{
>栈[+ +顶部] = P;
[顶] = 0;
P = P-> lchild;
}
（TOP> = 0）/ /所有留守儿童处理
{
（标记[顶]）/ /如果当前节点的右子尚未被访问
{
P =堆栈[顶]; /输出的协议栈节点的顶部，但消失在堆栈中，因为要输出他们的孩子的第一个节点
p = P-> rchild; / /右子节点的处理
标签[顶] = 1; / /在被访问的的堆栈存储节点的右子榜首的位置，下一次你把它退栈直接输出
}
其他
{
法院<数据/ /在栈的栈顶元素，输出的节点，节点p指向NULL
}
}}而（（ P = NULL）| |（> = 0））;
}
廉政的main（）
{
二叉树BT;
BT = creatree（）;
法院<<'\ n'<<“后序”;
后序（BT）;
法院<< endl;
系统（“暂停“）;
返回0;
}
G. C语言中，递归先序遍历和非递归先序遍历的有何区别各自优缺点
1、递归就是函数调用函数本身，运行起来就是函数嵌套函数，层层嵌套，所以函数调用、参数堆栈都是不小的开销，但是程序简单。
2、非递归就是不断地对参数入栈、出栈，省去了函数层层展开、层层调用的开销。虽然参数出入栈次数多了，但是一般都开辟固定的足够大的内存来一次性开辟、重复使用。
3、非递归是从堆栈的角度来编写程序，速度快，但代码复杂。
递归是从问题本身的逻辑角度来编写，虽然速度相对慢，但代码容易理解。
如果对速度要求不高，建议用递归方式。
4、摘录例子如下：
#include <stdio.h>
#include <stdlib.h>
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;//二叉树的节点类型
typedef struct QNode
{
BiTNode data;
struct QNode *next;
} QNode,*QueuePtr;//队列节点类型
typedef struct
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;//队列的头尾指针
void InitQueue(LinkQueue *Q)//创建队列
{
Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
Q->rear->next=NULL;
}
void EnQueue(LinkQueue *Q,BiTNode e)//入队操作
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
p->data=e;
p->next=NULL;
Q->rear->next=p;
Q->rear=p;
}
BiTNode DeQueue(LinkQueue *Q)//出对操作
{
BiTNode e;QueuePtr p;
p=Q->front->next;
e=p->data;
Q->front->next=p->next;
if(Q->rear==p)
Q->rear=Q->front;
free(p);
return (e);
}
int QueueEmpty(LinkQueue *Q)//判断队列是否为空
{
if(Q->front==Q->rear )
return 1;
else
return 0;
}
BiTree CreateBiTree()//创建二叉树
{
char p;BiTree T;
scanf("%c",&p);
if(p==' ')
T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));
T->data=p;
T->lchild=CreateBiTree(T->lchild);
T->rchild=CreateBiTree(T->rchild);
}
return (T);
}
void PreOrder(BiTree T)//先序
{
if(T!=NULL)
{
printf("%c",T->data);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}
void LevelOrder(BiTree T)//层次遍历
{
LinkQueue Q; BiTNode p;
InitQueue(&Q);
EnQueue(&Q,*T);
while(!QueueEmpty(&Q))
{
p = DeQueue(&Q);
printf("%c",p.data);
if(p.lchild!=NULL)
EnQueue(&Q,*(p.lchild));
if(p.rchild!=NULL)
EnQueue(&Q,*(p.rchild));
}
}
void main()
{
BiTree Ta;
Ta=CreateBiTree();
printf("层次遍历:");
printf("\n");
LevelOrder(Ta);
printf("\n");
printf("先序遍历:");
printf("\n");
PreOrder(Ta);
}
层次使用非递归的，用到队列
先序是用递归的
创建树使用先序递归建树
输入个例子：
abc**de*f**g***(注意*代表空格，因为空格你看不到就不好表示).
H. C语言的两个问题： 所有的递归程序均可以用非递归算法实现递归函数中的形式参数是自动变量吗 c语言中
C语言所有递归都可以用非递归算法实现，最典型的就是迭代法，有时比递归更容易理解。至于递归中的形式参数是自动变量，没明白楼主的意思，形参就是形参啊，形参变量也是变量，其内存分配在栈区，随着函数的结束，其内存也会被释放，形参的生命周期与函数生命周期相同哈（同生共死）
I. C语言中递归函数是，非递归函数是能否举例子
直接或间接调用自已的函数就是递归函数，否则为非递归函数。如：
unsignedfun(unsignedx){
if(x==1||x==0)
return1;
returnx*fun(x-1);
}这个函数的体中出现了调用自己的语句fun(x-1);，所以是递归函数。
J. 用C语言编写非递归算法实现折半查找（二分查找）
char a[10][5];//按字典序递增
int search(char *x)//二分查找，返回有序表中大于等于x的元素位置
{
int low=0,high=9,mid,t;
while(low<=high)
{
mid=(low+high)/2;
t=strcmp(a[mid],x);//比较中点位置与x
if(t==0) return mid;//相等返回其位置
else
if(t>0) high=mid-1;//x小于mid元素，则在中点前
else low=mid+1;
}
return high+1;//返回大于x的第一个元素
}
这个是我曾经用过的字符串的二分查找~
请根据需要修改数据类型。。。