二叉树先序非递归遍历C语言算法

Posted 2023-05-08

#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=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;
elsepop(&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;
elsepop(&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");
参考技术A #include<stdio.h>
#include<stdlib.h>
#define MS 10
struct BTreeNode

char data;
struct BTreeNode * left;
struct BTreeNode * right;
;
void InitBTree(struct BTreeNode * * BT)

* BT=NULL;


void CreatBTree(struct BTreeNode * * BT,char * a)

struct BTreeNode * p;
struct BTreeNode * s[MS];
int top=-1;
int k;
int i=0;
* BT=NULL;
while(a[i])

switch(a[i])

case ' ':break;
case '(':
if(top==MS-1)

printf("栈空间太小，需增加MS的值!\n");
exit(1);

top++;s[top]=p;k=1;
break;

case ')':
if(top==-1)

printf("二叉树广义表字符串有错!\n");
exit(1);


top--;break;
case ',' : k=2;break;
default :
if((a[i]>='a'&&a[i]<='z')||(a[i]>='A'&&a[i]<='Z'))

p=malloc(sizeof(struct BTreeNode));
p->data=a[i];p->left=p->right=NULL;
if(* BT==NULL) * BT=p;
else

if(k==1) s[top]->left=p;
else s[top]->right=p;


else printf("二叉树广义表字符串有错!\n");exit(1);


i++;



void Preorder(struct BTreeNode * BT)

struct BTreeNode * s[10];
int top=-1;
struct BTreeNode * p=BT;
while(top!=-1||p!=NULL)

while(p!=NULL)

top++;
s[top]=p;
printf("%c",p->data);
p=p->left;


if(top!=-1)

p=s[top];
top--;
p=p->right;






void main()

struct BTreeNode * p;
char * a="A(B(C),D(E(F,G),H(,I)))";
InitBTree(&p);
CreatBTree(&p,a);
printf("结点的访问序列为:\n");
Preorder(p);printf("\n");
本回答被提问者采纳 参考技术B #define LEN sizeof(struct tree)
#define NULL 0
#include<stdio.h>
#include<malloc.h>
struct tree

char data;
struct tree *lchild,*rchild;
;
//创建二叉树
struct tree *creat()

char c;
struct tree *t;
c=getchar();
if(c==' ')
t=NULL;
else

t=(struct tree*)malloc(LEN);
t->data=c;
t->lchild=creat();
t->rchild=creat();

return t;

//前序遍历
void Preprint(struct tree*t)

if(t!=NULL)

printf("%c->",t->data);
Preprint(t->lchild);
Preprint(t->rchild);


//中序遍历
void Inprint(struct tree*t)

if(t!=NULL)

Inprint(t->lchild);
printf("%c->",t->data);
Inprint(t->rchild);


//后序遍历
void Postprint(struct tree*t)

if(t!=NULL)

Postprint(t->lchild);
Postprint(t->rchild);
printf("%c->",t->data);


main()

struct tree *t;
printf("Please input tree in order:\n");
t=creat();
printf("The result of Preorder traversal is\n");
Preprint(t);
printf("^\nThe result of Inorder traversal is\n");
Inprint(t);
printf("^\nThe result of Postorder traversal is\n");
Postprint(t);
printf("^\n");
getch();
追问

这是递归的啊，我要的是非递归的

追答

#include
#include
#include

#define Maxsize 20

#define Max 20

typedef struct BTree

char data;

struct BTree *Lchild, *Rchild;
BTree;

typedef struct Stack

BTree *data[Maxsize];

int top;

Stack;

void InitBTree(BTree *&B)

B=(BTree *)malloc(sizeof(BTree));

B=NULL;

printf("\n 目前已经创建一棵空二叉树\n");


void CreateBTree(BTree *&B) // 创建二叉树

char ch;

ch=getchar();

if(ch=='#')

B=NULL;

else

B=(BTree *)malloc(sizeof(BTree));

B->data=ch;

CreateBTree(B->Lchild);

CreateBTree(B->Rchild);



//先序遍历 递归算法
void Display(BTree *B)

if(B!=NULL)

printf("%c ", B->data);

Display(B->Lchild);

Display(B->Rchild);




void Preorder(BTree *B)

Stack *s;

s=(Stack *)malloc(sizeof(Stack));

s->top=0;

printf(" 先序遍历 非递归算法 输出二叉树所有结点内容:\n ");

while(B!=NULL||s->top>0)

if(B!=NULL)

printf("%c ", B->data);

s->data[s->top++]=B;

B=B->Lchild;


else

B=s->data[--s->top];
B=B->Rchild;






int main(void)

srand((unsigned)time(NULL));

BTree *B;

InitBTree(B);

printf("\n 开始初始化二叉树的结点内容:\n ");

CreateBTree(B);

printf("\n 二叉树的结点内容:\n ");

Display(B);

printf("\n");

Preorder(B);

printf("\n");

return 0;

二叉树先序遍历 递归 非递归

先序遍历的操作如下：
1）访问根节点；
2）先序遍历左子树；
3）先序遍历右子树；

---

对应的递归算法如下：

void PreOrder(Bitree T) {
    if (T != NULL) {
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

对应的非递归算法如下：

void PreOrder2(Bitree T) {
    //借助栈实现
    InitStack(S); Bitree p = T;   //初始化栈，p是遍历指针
    while (p || !IsEmpty(S)) {
        if (p) {
            Push(S, p);
            visit(p);               //访问根节点
            p = p->lchild;      //遍历左子树
        }
        else {
            Pop(S, p);
            p = p->rchild;     //遍历左子树
        }
    }
}