题目 6 建立二叉树，层序、先序遍历（用非递归的方法）

Posted 2023-04-24

题目 6 建立二叉树，层序、先序遍历（用非递归的方法）
1、问题描述
要求能够输入树的各个结点，并能够输出用不同方法遍历的遍历序列；分别建立建立二叉树存储结构的的输入函数、输出层序遍历序列的函数、输出先序遍历序列的函数；
2、要求
在上交资料中请写明：存储结构、基本算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法。

#include
#include
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***(注意*代表空格，因为空格你看不到就不好表示). 参考技术A #include <iostream>
#define M 1000
using namespace std;
template<class T>
struct Btnode //定义二叉链表结点类
T d; //数据域
Btnode *lchild; //左指针域
Btnode *rchild; //右指针域
; //二叉链表类
template<class T> //类模板，T为虚拟类型
class Binary_Tree
private:
Btnode<T> *BT; //而叉链表根结点指针
public: //成员函数
Binary_Tree()BT=NULL;return; //二叉链表初始化
void creat_Binary_Tree(T); //生成二叉链表
void pretrav_Binary_Tree(); //前序遍历二叉链表
void intrav_Binary_Tree(); //中序遍历二叉链表
void postrav_Binary_Tree(); //后序遍历二叉链表
;
//——————————————生成二叉链表————————————————
template<class T>
void Binary_Tree<T>::creat_Binary_Tree(T end)
Btnode<T> *p;
T x;
cin>>x;
if(x==end)
return;
p=new Btnode<T>;
p->d=x;
p->lchild=NULL;
p->rchild=NULL;
BT=p;
creat(p,1,end);
creat(p,2,end);
return;

template<class T>
static creat(Btnode<T> *p,int k,T end)

Btnode<T> *q;
T x;
cin>>x;
if(x!=end)

q=new Btnode<T>; q->d=x;
q->lchild=NULL;
q->rchild=NULL;
if(k==1) p->lchild=q; if(k==2) p->rchild=q; creat(q,1,end);
creat(q,2,end);
return 0;

//————————————前序遍历二叉链表——————————————
template<class T>
void Binary_Tree<T>::pretrav_Binary_Tree( )

Btnode<T> *p;
p=BT;
pretrav(p); cout<<endl;
return;


template<class T>
static pretrav(Btnode<T> *p)

if(p!=NULL)

cout<<p->d<<" "; pretrav(p->lchild); pretrav(p->rchild);
return 0;

//————————————中序遍历二叉链表——————————————
template<class T>
void Binary_Tree<T>::intrav_Binary_Tree( )

Btnode<T> *p;
p=BT;
intrav(p); cout<<endl;
return;


template<class T>
static intrav(Btnode<T> *p)

if(p!=NULL)

intrav(p->lchild); cout<<p->d<<" "; intrav(p->rchild);
return 0;

//————————————后序遍历二叉链表———————————————
template<class T>
void Binary_Tree<T>::postrav_Binary_Tree( )

Btnode<T> *p;
p=BT;
postrav(p); cout<<endl;
return;


template<class T>
static postrav(Btnode<T> *p)

if(p!=NULL)

postrav(p->lchild); postrav(p->rchild); cout<<p->d<<" ";
return 0;

int main( )

Binary_Tree<int>b;
cout<<"输入各结点值(-1为结束符值):"<<endl;
b.creat_Binary_Tree(-1);
cout<<"前序序列:"<<endl;
b.pretrav_Binary_Tree( );
cout<<"中序序列:"<<endl;
b.intrav_Binary_Tree( );
cout<<"后序序列:"<<endl;
b.postrav_Binary_Tree( );
return 0;
参考技术B 我靠 那么复杂 才20分 懒得理你

建立二叉树，层序、先序遍历

用非递归算法，c++语言
1、问题描述
要求能够输入树的各个结点，并能够输出用不同方法遍历的遍历序列；分别建立建立二叉树存储结构的的输入函数、输出层序遍历序列的函数、输出先序遍历序列的函数；
2、要求
在上交资料中请写明：存储结构、基本算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法。

#include <iostream>
#include "sq_Queue.h"
#define M 1000
using namespace std;
template<class T>
struct Btnode
T d;
Btnode *lchild;
Btnode *rchild;
;
template<class T>
class Binary_Tree
private:
Btnode<T> *BT;
public:
Binary_Tree()BT=NULL;return;
void creat_Binary_Tree(T);
void pretrav_Binary_Tree();
void level( );
；
template<class T>
void Binary_Tree<T>::creat_Binary_Tree(T end)

Btnode<T> *p;
T x;
cin>>x;
if(x==end)
return; p=new Btnode<T>;
p->d=x;
p->lchild=NULL;
p->rchild=NULL;
BT=p;
creat(p,1,end);
creat(p,2,end);
return;

template<class T>
static creat(Btnode<T> *p,int k,T end)

Btnode<T> *q;
T x;
cin>>x;
if(x!=end)

q=new Btnode<T>; q->d=x;
q->lchild=NULL;
q->rchild=NULL;
if(k==1) p->lchild=q; if(k==2) p->rchild=q; creat(q,1,end); creat(q,2,end);
return 0;

//————————————前序遍历二叉链表——————————————
template<class T>
void Binary_Tree<T>::pretrav_Binary_Tree( )

Btnode<T> *p;
p=BT;
pretrav(p); cout<<endl;
return;


template<class T>
static pretrav(Btnode<T> *p)

if(p!=NULL)

cout<<p->d<<" "; pretrav(p->lchild); pretrav(p->rchild);
return 0;

//————————————按层次遍历二叉链表——————————————
template<class T>
void Binary_Tree<T>::level( )

Btnode<T> *k;
sq_Queue<Btnode<T>*>q(M);
if(BT!=NULL)
q.ins_sq_Queue(BT);
while(q.flag_sq_Queue( ))

k=q.del_sq_Queue( );
cout<<k->d<<endl;
if(k->lchild!=NULL) q.ins_sq_Queue(k->lchild);
if(k->rchild!=NULL) q.ins_sq_Queue(k->rchild);

return;

int main( )

Binary_Tree<int>b; cout<<"输入各结点值(-1为结束符值):"<<endl;
b.creat_Binary_Tree(-1); cout<<"前序序列:"<<endl;
b.pretrav_Binary_Tree( );
cout<<"按层次输出二叉链表中所有结点值:"<<endl;
b.level( );
再建立一个用户自定义文件sq_Queue,把下面的考进去
#include <iostream>
using namespace std;
//定义循环队列类
template<class T> //模板声明，数据元素虚拟类型为T
class sq_Queue
private: //数据成员
int mm; //存储空间容量
int front; //排头指针
int rear; //队尾指针
int s; //标志
T *q; //循环队列存储空间首地址
public: //成员函数
sq_Queue(int); //构造函数，建立空循环队列
void prt_sq_Queue(); //输出排头与队尾指针以及队中元素
int flag_sq_Queue(); //检测循环队列的状态
void ins_sq_Queue(T); //入队
T del_sq_Queue(); //退队
;
//建立容量为mm的空循环队列
template<class T>
sq_Queue<T>::sq_Queue(int m)
mm=m; //存储空间容量
q=new T[mm]; //动态申请存储空间
front=mm;
rear=mm;
s=0;
return;

//输出排头与队尾指针以及队中元素
template<class T>
void sq_Queue<T>::prt_sq_Queue()
int i;
cout<<"front="<<front<<endl;
cout<<"rear="<<rear<<endl;
if(s==0)cout<<"队列空！"<<endl;
return;

i=front;
doi=i+1;
if(i==mm+1)i=1;
cout<<q[i-1]<<endl;
while(i!=rear);
return;

//检测循环队列的状态
template<class T>
int sq_Queue<T>::flag_sq_Queue()
if((s==1)&&(rear==front))return(-1); //存储空间已满，返回-1
if(s==0)return(0); //循环队列为空，返回0
return(1); //正常返回1

//入队
template<class T>
void sq_Queue<T>::ins_sq_Queue(T x)
if((s==1)&&(rear==front)) //存储空间已满，上溢错误
cout<<"Queue_overflow!"<<endl;
return;

rear=rear+1; //队尾指针进一
if(rear==mm+1)rear=1;
q[rear-1]=x; //新元素入队
s=1; //入队后队列非空
return;

//退队
template<class T>
T sq_Queue<T>::del_sq_Queue()
T y;
if(s==0) //队列为空，下溢错误
cout<<"Queue_underflow!"<<endl;
return(0);

front=front+1; //排头指针进一
if(front==mm+1)front=1;
y=q[front-1]; //将退队元素赋值给变量
if(front==rear)s=0;
return(y); //返回退队元素
参考技术A #include
<iostream>
#include
"sq_Queue.h"
#define
M
1000
using
namespace
std;
template<class
T>
struct
Btnode
T
d;
Btnode
*lchild;
Btnode
*rchild;
;
template<class
T>
class
Binary_Tree
private:
Btnode<T>
*BT;
public:
Binary_Tree()BT=NULL;return;
void
creat_Binary_Tree(T);
void
pretrav_Binary_Tree();
void
level(
);
;
template<class
T>
void
Binary_Tree<T>::creat_Binary_Tree(T
end)

Btnode<T>
*p;
T
x;
cin>>x;
if(x==end)
return;
p=new
Btnode<T>;
p->d=x;
p->lchild=NULL;
p->rchild=NULL;
BT=p;
creat(p,1,end);
creat(p,2,end);
return;

template<class
T>
static
creat(Btnode<T>
*p,int
k,T
end)

Btnode<T>
*q;
T
x;
cin>>x;
if(x!=end)

q=new
Btnode<T>;
q->d=x;
q->lchild=NULL;
q->rchild=NULL;
if(k==1)
p->lchild=q;
if(k==2)
p->rchild=q;
creat(q,1,end);
creat(q,2,end);

return
0;

//------------前序遍历二叉链表--------------
template<class
T>
void
Binary_Tree<T>::pretrav_Binary_Tree(
)

Btnode<T>
*p;
p=BT;
pretrav(p);
cout<<endl;
return;

template<class
T>
static
pretrav(Btnode<T>
*p)

if(p!=NULL)

cout<<p->d<<"
";
pretrav(p->lchild);
pretrav(p->rchild);

return
0;

//------------按层次遍历二叉链表--------------
template<class
T>
void
Binary_Tree<T>::level(
)

Btnode<T>
*k;
sq_Queue<Btnode<T>*>q(M);
if(BT!=NULL)
q.ins_sq_Queue(BT);
while(q.flag_sq_Queue(
))

k=q.del_sq_Queue(
);
cout<<k->d<<endl;
if(k->lchild!=NULL)
q.ins_sq_Queue(k->lchild);
if(k->rchild!=NULL)
q.ins_sq_Queue(k->rchild);

return;

int
main(
)

Binary_Tree<int>b;
cout<<"输入各结点值(-1为结束符值):"<<endl;
b.creat_Binary_Tree(-1);
cout<<"前序序列:"<<endl;
b.pretrav_Binary_Tree(
);
cout<<"按层次输出二叉链表中所有结点值:"<<endl;
b.level(
);
再建立一个用户自定义文件sq_Queue,把下面的考进去
#include
<iostream>
using
namespace
std;
//定义循环队列类
template<class
T>
//模板声明，数据元素虚拟类型为T
class
sq_Queue
private:
//数据成员int
mm;
//存储空间容量int
front;
//排头指针int
rear;
//队尾指针int
s;
//标志T
*q;
//循环队列存储空间首地址public:
//成员函数
sq_Queue(int);
//构造函数，建立空循环队列
void
prt_sq_Queue();
//输出排头与队尾指针以及队中元素
int
flag_sq_Queue();
//检测循环队列的状态
void
ins_sq_Queue(T);
//入队
T
del_sq_Queue();
//退队;
//建立容量为mm的空循环队列
template<class
T>
sq_Queue<T>::sq_Queue(int
m)
mm=m;
//存储空间容量q=new
T[mm];
//动态申请存储空间front=mm;rear=mm;s=0;return;
//输出排头与队尾指针以及队中元素
template<class
T>
void
sq_Queue<T>::prt_sq_Queue()
int
i;cout<<"front="<<front<<endl;cout<<"rear="<<rear<<endl;if(s==0)cout<<"队列空!"<<endl;return;
i=front;
doi=i+1;if(i==mm+1)i=1;cout<<q[i-1]<<endl;while(i!=rear);
return;

//检测循环队列的状态
template<class
T>
int
sq_Queue<T>::flag_sq_Queue()
if((s==1)&&(rear==front))return(-1);
//存储空间已满，返回-1if(s==0)return(0);
//循环队列为空，返回0return(1);
//正常返回1
//入队
template<class
T>
void
sq_Queue<T>::ins_sq_Queue(T
x)
if((s==1)&&(rear==front))
//存储空间已满，上溢错误cout<<"Queue_overflow!"<<endl;return;
rear=rear+1;
//队尾指针进一
if(rear==mm+1)rear=1;
q[rear-1]=x;
//新元素入队
s=1;
//入队后队列非空
return;

//退队
template<class
T>
T
sq_Queue<T>::del_sq_Queue()
T
y;if(s==0)
//队列为空，下溢错误cout<<"Queue_underflow!"<<endl;return(0);
front=front+1;
//排头指针进一
if(front==mm+1)front=1;
y=q[front-1];
//将退队元素赋值给变量
if(front==rear)s=0;
return(y);
//返回退队元素