二叉树建立、各种遍历、求叶子节点

最新推荐文章于 2024-04-24 14:01:27 发布

转载最新推荐文章于 2024-04-24 14:01:27 发布 · 632 阅读

文章标签：

#bt #数据结构 #算法 #编程

本文介绍了如何使用递归和非递归的方式对二叉树进行中序、先序和后序遍历，并详细阐述了非递归遍历算法的实现过程，包括使用栈和队列的数据结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <stdio.h>

#include <stdlib.h>

typedef struct BiTNode

{

int data;

struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

void CreateBiTree(BiTree &bt)//按先序遍历创建一个二叉树

{

int tmp;

scanf("%d",&tmp );

if(tmp==-1)

bt=NULL;

else

{

bt=(BiTree)malloc(sizeof(BiTNode));

if(!bt) return;

bt->data =tmp;

CreateBiTree(bt->lchild );

CreateBiTree(bt->rchild );

}

void InOrderTraverse(BiTree bt)//中序递归遍历

{

if(bt==NULL) return;

else

{

InOrderTraverse(bt->lchild );

printf("%d ",bt->data );

InOrderTraverse(bt->rchild );

}

void PreOrderTraverse(BiTree bt) //先序遍历二叉树

{

if ( bt )

{ printf(“%4d”, bt->data);

PreOrderTraverse(bt->lchild);

PreOrderTraverse(bt->rchild);

}

void PostOrderTraverse(BiTree bt) //后序遍历二叉树

{

if ( bt )

{

PostOrderTraverse(bt->lchild);

PostOrderTraverse(bt->rchild);

printf(“%4d”, bt->data);

}

#define MAXSTACK 15

typedef struct { //定义栈的存储结构

BiTree *base;

int top;

}SqStack;

//栈操作的相关函数

void InitStack(SqStack &S)

{ S.base=(BiTree*)malloc(sizeof(BiTNode));

if( !S.base ) exit(0);

S.top=0;

}

void Push(SqStack &S, BiTree e)

{

if( S.top== MAXSTACK )

exit(0);

S.base[S.top] = e;

S.top++;

}

void Pop(SqStack &S, BiTree &e)

{

if( S.top==0)

exit(0);

S.top--;

e=S.base[S.top];

}

int GetTop(SqStack S, BiTree &e)

{

if( S.top== 0 )

return 0;

e=S.base[S.top-1];

return 1;

}

int StackEmpty(SqStack S )

{

if ( S.top == 0 )

return 1;

else return 0;

}

void InOrderTraverse1(BiTree bt)//中序非递归遍历----用到栈

{

SqStack S;

BiTree p;

if ( bt )

{ InitStack( S ); Push( S, bt );

while( !StackEmpty( S ))

{

while(GetTop( S, p ) && p )

Push( S, p->lchild );

Pop( S, p );

if( !StackEmpty( S ))

{

Pop( S, p ); printf("%d ", p->data );

Push( S, p->rchild );

}

}//if

}

void PreOrderTraverse1(BiTree bt) //先序遍历二叉树的非递归算法

{

SqStack S;

BiTree p;

if ( bt )

{ InitStack( S ); Push( S, bt );

while( !StackEmpty( S ))

{

while(GetTop( S, p ) && p )

{ printf(“%4d”, p->data ); Push( S, p->lchild ); }

Pop( S, p );

if( !StackEmpty( S ))

{ Pop( S, p ); Push( S, p->rchild ); }

}

}//if

}

void PostOrderTraverse1(BiTree bt) //后序遍历二叉树的非递归算法

{

SqStack S;

BiTree p, q;

if ( bt )

{ InitStack( S ); Push( S, bt );

while( !StackEmpty( S ))

{

while(GetTop( S, p ) && p )

Push( S, p->lchild );

Pop( S, p );

if( !StackEmpty( S ))

{

GetTop( S, p );

Push( S, p->rchild );

if(GetTop( S, p ) && !p )

{ Pop( S, p ); //空结点出栈

Pop( S, p );

printf(“%4d”, p->data );

while( !StackEmpty(S) && GetTop( S, q) && q->rchild == p)

{ Pop( S, p ); printf(“%4d”, p->data ); }

if( !StackEmpty(S) )

{ GetTop( S, p ); Push( S, p->rchild ); }

}//if(!p)

}//if(!StackEmpty(S))

}//whie

}//if

}

#define MAXQSIZE 100 //最大队列长度

typedef struct {

BiTree *base; //初始化动态分配空间

int front;

int rear;

} SqQueue;

int InitQueue(SqQueue &Q){

//构造一个空队列

Q.base = (BiTree *)malloc(MAXQSIZE * sizeof(BiTNode));

if ( ! Q.base) return 0;

Q.front = Q.rear = 0;

return 1;

} //InitQueue

int EnQueue(SqQueue &Q, BiTree e){

//插入元素e为Q的新的队尾元素

if ((Q.rear+1)%MAXQSIZE == Q.front)

return 0;

Q.base[Q.rear] = e;

Q.rear = (Q.rear+1) % MAXQSIZE;

return 1;

}

int DeQueue(SqQueue &Q, BiTree &e){

// 删除Q的队头元素, 并用e返回其值

if(Q.front == Q.rear) return 0;

e = Q.base[Q.front];

Q.front = (Q.front+1) % MAXQSIZE;

return 1;

}

int EmptyQueue(SqQueue Q)//判队空

{

if(Q.front ==Q.rear )

return 1;

else return 0;

}

void LevelOrderTraverse(BiTree bt)

{ //按层次遍历二叉树算法——用到队列这种数据结构

SqQueue Q;

BiTree p;

if( !bt ) return ; //空树

InitQueue(Q);//初始化空队列Q

//p=bt;

EnQueue(Q, bt); //根入队

while( !EmptyQueue(Q))

{

DeQueue(Q, p); //队头p出队

printf("%d ",p->data ); //访问p

if(p->lchild) EnQueue(Q,p->lchild); //p的左孩子入队

if(p->rchild) EnQueue(Q,p->rchild); //p的右孩子入队

}

void LeavesCount(BiTree bt,int &count)//求二叉树的叶子结点数

{

SqQueue Q;

BiTree p;

//p=bt;

if(!bt) count=0;

else

{

InitQueue(Q);

EnQueue(Q,bt);

while( !EmptyQueue(Q))

{

DeQueue(Q, p);

if(!p->lchild && !p->rchild)count++;

if(p->lchild) EnQueue(Q,p->lchild); //p的左孩子入队

if(p->rchild) EnQueue(Q,p->rchild); //p的右孩子入队

}

void main()

{

BiTree bt;

printf("建立二叉树:\n");

CreateBiTree(bt);

printf("中序递归遍历二叉树：\n");

InOrderTraverse(bt);

printf("\n");

printf("中序非递归遍历二叉树：\n");

InOrderTraverse1(bt);

printf("\n");

printf("层次遍历二叉树：\n");

LevelOrderTraverse(bt);

printf("\n");

int count=0;

LeavesCount(bt,count);

printf("叶子结点数为：%d\n",count);////引申：如果求二叉树中所有结点总数呢？？

}