二叉树的递归 非递归 先序 中序 后序及层次遍历代码实现 其实这个代码还是有点缺陷的 如果谁有耐性看完的话 帮我改一下 ,这个二叉树的建立可以自己手动的,只要把main注释里面的一些东西去掉就行了,但是,用了if语句选择之后就不行了 不知道为什么
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
struct Binode
{
char data;
struct Binode * lchild;
struct Binode * rchild;
}Binode; //二叉树的结构
typedef struct node
{
struct Binode * data;
struct node * next;
}node,*pnode; //定义了链栈的每一个节点元素
typedef struct stack
{
pnode stacktop;//栈顶指针
pnode stackbottom; //栈底指针
}stack,*pstack; //栈的基本信息
typedef struct qnode
{
struct Binode * data;
struct qnode * next;
}qnode,*queueptr; // 定义链队列的每个节点的数据结构
typedef struct linkqueue
{
queueptr front;
queueptr rear;
}linkqueue; //层次遍历用的队列
struct Binode * createbitree(void); //创建二叉树
struct Binode * createbitree2(void); //创建二叉树
//递归遍历函数
void preorder(struct Binode * T); //递归先序遍历二叉树
void inorder(struct Binode * T); //递归中序遍历二叉树
void postorder(struct Binode * T);//递归后序遍历二叉树
//以下是非递归的函数
void Preorder(struct Binode * T);//非递归先序遍历二叉树
void Inorder(struct Binode * T);//第一种非递归中序遍历二叉树
void Inorder2(struct Binode * T);//第二种非递归中序遍历二叉树
void Postorder(struct Binode * T);//非递归后序遍历二叉树
void Levelorder(struct Binode * T); //层次遍历
void Levelorder2(struct Binode * T); //加一个栈可以实现从下至上,从有右至左层次的遍历
//遍历应用函数
void yellownode(struct Binode * T);//求叶子节点个数
void swapnode(struct Binode * B);//交换二叉树的左右子树
//以下是栈的相关函数
void intistack(pstack s);//初始化栈
bool is_empty(pstack s);
void pop(pstack s,struct Binode **val);
void push(pstack s,struct Binode ** val);
struct Binode * Gettop(pstack s);//获取栈顶元素
void visit(struct Binode * p); //访问节点的值
//以下是队列的函数
void initqueue(linkqueue *); //初始化队列
void dequeue(linkqueue *,struct Binode **); //删除队头元素 并返回删除的值
void enqueue(linkqueue *,struct Binode **); //在对尾插入元素
bool Is_empty(linkqueue q); //判断队列是否为空
void call(struct Binode * B); //调用操作函数
void main(void)
{ struct Binode * B;
//int i;
/*printf("自己生成树输入 1 (按先序遍历生成,子树为空的输入空格符)\n\n");
printf("自动生成树请输入 2\n\n");
*/
//scanf("%d",&i);
/* if(1==i)
{
B=createbitree2();
call(B);
}
else if(2==i)
{*/
B=createbitree();
call(B);
//}
/*else if(3==i)
{
swapnode(B);
}*/
//else
//{
// printf("选择有误\n\n");
//}
}
void call(struct Binode * B)
{
printf("递归先序遍历\n");
preorder(B); //递归先序遍历
printf("\n");
/* 求得当前时间 */
printf("递归中序遍历\n");
inorder(B); //递归中序递归遍历
printf("\n");
printf("递归后序遍历\n");
postorder(B); //递归后序递归遍历
printf("\n");
printf("非递归先序遍历\n");
Preorder(B);
printf("\n");
printf("第一种非递归中序遍历\n");
Inorder(B);//非递归中序遍历
printf("\n");
printf("第二种非递归中序遍历\n");
Inorder2(B);
printf("\n");
printf("非递归后序遍历二叉树\n");
Postorder(B);
printf("\n");
printf("层次遍历\n");
Levelorder(B);
printf("\n");
printf("加一个栈实现从下至上,从右至左层次的遍历\n");
Levelorder2(B);
printf("\n");
printf("\n");
yellownode(B);
printf("\n");
}
struct Binode * createbitree(void) //创建二叉树
{
struct Binode * A=(struct Binode *)malloc(sizeof(Binode));
struct Binode * B=(struct Binode *)malloc(sizeof(Binode));
struct Binode * C=(struct Binode *)malloc(sizeof(Binode));
struct Binode * D=(struct Binode *)malloc(sizeof(Binode));
struct Binode * E=(struct Binode *)malloc(sizeof(Binode));
struct Binode * F=(struct Binode *)malloc(sizeof(Binode));
A->data='1';
A->lchild=B;
A->rchild=C;
B->data='2';
B->lchild=D;
B->rchild=NULL;
C->data='3';
C->lchild=E;
C->rchild=F;
D->data='4';
D->lchild=NULL;
D->rchild=NULL;
E->data='5';
E->lchild=NULL;
E->rchild=NULL;
F->data='6';
F->lchild=NULL;
F->rchild=NULL;
return A;
}
struct Binode * createbitree2(void) //创建二叉树
{ struct Binode * T;
char i;
scanf("%c",&i);
if(i==' ')T=NULL;
else
{ T=(struct Binode *)malloc(sizeof(struct Binode));
if(!T) exit(-1);
T->data=i;
T->lchild= createbitree2();
T->rchild=createbitree2();
}
return T;
}
void preorder(struct Binode * T) //先序递归遍历
{if(NULL!=T)
{ printf("%c ",T->data);
if(NULL!=T->lchild)
{
preorder(T->lchild);
}
if(NULL!=T->rchild)
{
preorder(T->rchild);
}
}
}
void inorder(struct Binode * T) //中序递归遍历
{
if(NULL!=T)
{
if(NULL!=T->lchild)
{
inorder(T->lchild);
}
printf("%c ",T->data);
if(NULL!=T->rchild)
{
inorder(T->rchild);
}
}
}
void postorder(struct Binode * T)//后序递归遍历
{
if(NULL!=T)
{
if(NULL!=T->lchild)
{
postorder(T->lchild);
}
if(NULL!=T->rchild)
{
postorder(T->rchild);
}
printf("%c ",T->data);
}
}
void Preorder(struct Binode * T)//非递归先序遍历二叉树 这是自己写的 代码有点冗长
{ struct Binode * p=T;
stack s;
intistack(&s);
while(p||!is_empty(&s))
{
if(p)
{
visit(p);
push(&s,&p);
p=p->lchild;
}//if
else
{
pop(&s,&p);
p=p->rchild;
if(p)
{
visit(p);
push(&s,&p);
p=p->lchild;
}//if
else if(!is_empty(&s))
{
pop(&s,&p);
p=p->rchild;
}//else if
else
{
p=NULL; //退出循环的条件
} //else
}//外层的else
}//while
}
void Inorder(struct Binode * T)//第一种非递归中序遍历
{ struct Binode * p=T;
stack s;
intistack(&s);
push(&s,&T);
while(!is_empty(&s))
{ p=Gettop(&s);
while(p)
{ push(&s,&(p->lchild));
p=Gettop(&s);
}
pop(&s,&p);
if(!is_empty(&s))
{
pop(&s,&p);
visit(p);
push(&s,&(p->rchild));
}
}
}
void Inorder2(struct Binode * T) //第二种非递归中序遍历 相对第一种进出栈的次数减少了
{
struct Binode *p=T;
stack s;
intistack(&s);
while(p||!is_empty(&s))
{
if(p){push(&s,&p);p=p->lchild;}
else
{
pop(&s,&p);
visit(p);
p=p->rchild;
}
}
}
void Postorder(struct Binode * T) //非递归后序遍历二叉树 参照王道书籍
{ struct Binode *p=T;
struct Binode *r=NULL;
stack s;
intistack(&s);
while(p||!is_empty(&s))
{
if(p)
{
push(&s,&p);
p=p->lchild;
}
else
{
p=Gettop(&s);
if(p->rchild&&p->rchild!=r)
{ p=p->rchild;
push(&s,&p);
p=p->lchild;
}
else
{
pop(&s,&p);
visit(p);
r=p;
p=NULL;
}
}
}//while
}
void Levelorder(struct Binode * T) //层次遍历
{
struct Binode *p=T;
linkqueue q;
initqueue(&q);
enqueue(&q,&p);
while(!Is_empty(q))
{
dequeue(&q,&p);
visit(p);
if(p->lchild!=NULL)
enqueue(&q,&(p->lchild));
if(p->rchild!=NULL)
enqueue(&q,&(p->rchild));
}
}
void Levelorder2(struct Binode * T) //加一个栈可以实现从下至上,从有右至左层次的遍历
{
struct Binode *p=T;
stack s;
intistack(&s);
linkqueue q;
initqueue(&q);
enqueue(&q,&p);
while(!Is_empty(q))
{
dequeue(&q,&p);
push(&s,&p);
if(p->lchild!=NULL)
enqueue(&q,&(p->lchild));
if(p->rchild!=NULL)
enqueue(&q,&(p->rchild));
}
while(!is_empty(&s))
{
pop(&s,&p);
visit(p);
}
}
//将层次遍历该一下就可以得到叶子节点个数
void yellownode(struct Binode * T) //计算叶子节点的个数 叶子节点的个数为度为2的节点个数加1
{ int i; //计算节点的度数
int n=0; //计算度为2的节点数
struct Binode *p=T;
linkqueue q;
initqueue(&q);
enqueue(&q,&p);
while(!Is_empty(q))
{ i=0;
dequeue(&q,&p);
if(p->lchild!=NULL)
{
enqueue(&q,&(p->lchild));
i++;
}
if(p->rchild!=NULL)
{
enqueue(&q,&(p->rchild));
i++;
}
if(i==2)
{
++n;
}
}
printf("叶子节点个数为%d \n",n+1);
}
void swapnode(struct Binode * B)//交换二叉树的左右子树
{ struct Binode *T=B;
struct Binode * temp;
if(T)
{
swapnode(T->lchild);
swapnode(T->rchild);
temp=T->lchild;
T->lchild=T->rchild;
T->rchild=temp;
}
}
void intistack(pstack s) //初始化一个栈,栈底元素为无用元素 ,用来判断栈是否为空,相当于链表中的头元素
{
s->stacktop=(pnode)malloc(sizeof(node)); //生成一个节点 用作栈的头结点用,栈底指针指向该节点
if(NULL==s->stacktop)
{
//printf("初始化失败\n\n");
exit(-1);
}
else
{
s->stackbottom=s->stacktop;
s->stackbottom->next=NULL;
}
}
//更多资源 访问我的博客 http://www.17xuexiba.com
void push(pstack s,struct Binode ** val) //元素进栈 val 为进栈的元素
{
pnode p=(pnode)malloc(sizeof(node));
if(NULL==p)
{
//printf("压栈失败\n\n");
exit(-1);
}
else
{
p->data=*val;
p->next=s->stacktop;
s->stacktop=p;
}
}
void pop(pstack s,struct Binode ** val) //数据出栈,用val值返回出栈数据
{
pnode p=s->stacktop;
if(s->stackbottom==s->stacktop)
{
//printf("栈中值为空,操作失败");
exit(-1);
}
else
{
*val=p->data;
s->stacktop=p->next;
free(p);
}
//printf("出栈的值为 %c ",*val);
//printf("\n\n");
}
bool is_empty(pstack s) //判栈是否为空
{
if(s->stackbottom==s->stacktop)
return true;
else
return false;
}
struct Binode * Gettop(pstack s) //获取栈顶元素
{
struct Binode * p=s->stacktop->data;
return p;
}
void visit(struct Binode * p) //访问节点的值
{
printf("%c ",p->data);
}
//以下是队列的相关函数
void initqueue(linkqueue * q) //初始化队列
{
q->front=q->rear=(queueptr)malloc(sizeof(qnode));
if(NULL==q->front)
{
//printf("初始化失败\n\n");
exit(-1);
}
q->front->next=NULL;
}
void enqueue(linkqueue * q,struct Binode ** val) //在对尾插入元素
{
queueptr newptr=(queueptr)malloc(sizeof(qnode));
if(NULL==newptr)
{
//printf("加入失败\n");
exit(-1);
}
newptr->data=*val;
newptr->next=NULL;
q->rear->next=newptr;
q->rear=newptr;
}
void dequeue(linkqueue * q,struct Binode ** val) //删除队头元素 并返回删除的值
{ queueptr p;
if(q->front==q->rear)
{
//printf("队列为空");
exit(-1);
}
p=q->front->next;
*val=p->data;
q->front->next=p->next;
if(q->rear==p)
q->front=q->rear; //如果队列中删除元素后为空则要进行初始化的处理
//printf("删除的元素为 %c \n",*val);
//free(p);
}
bool Is_empty(linkqueue q) //判断队列是否为空
{
if(q.rear==q.front)
{
return true;
}
else
return false;
}