谨以此文记录二叉树的实现:
#include <iostream>
using namespace std;
#define MAXSIZE 100
//二叉树
typedef char TElemType;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;
//顺序栈
typedef BiTree SElemType;
typedef struct
{
SElemType *base = nullptr;
SElemType *top = nullptr;
int stacksize;
} SqStack;
//链队列
typedef BiTree QElemType;
typedef struct QNode
{
QElemType data;
QNode *next;
} QNode, *QueuePtr;
typedef struct
{
QueuePtr front = nullptr, rear = nullptr;
} LinkQueue;
/**
* @brief 初始化栈
*
* @param S
* @return true
* @return false
*/
bool InitStack(SqStack &S)
{
S.base = new SElemType[MAXSIZE];
S.top = S.base;
S.stacksize = MAXSIZE;
return true;
}
/**
* @brief 销毁栈
*
* @param S
* @return true
* @return false
*/
bool DestroyStack(SqStack &S)
{
if (S.base)
{
delete[] S.base;
S.stacksize = 0;
S.base = S.top = nullptr;
}
return true;
}
/**
* @brief 入栈
*
* @param S
* @param e
* @return true
* @return false
*/
bool Push(SqStack &S, SElemType e)
{
if (S.top - S.base == S.stacksize)
return false;
*S.top++ = e;
return true;
}
/**
* @brief 出栈
*
* @param S
* @param e
* @return true
* @return false
*/
bool Pop(SqStack &S, SElemType &e)
{
if (S.top == S.base)
return false;
e = *--S.top;
return true;
}
/**
* @brief 判断栈是否为空
*
* @param S
* @return true
* @return false
*/
bool StackEmpty(SqStack S)
{
if (S.top == S.base)
return true;
return false;
}
/**
* @brief 初始化队列
*
* @param Q
* @return true
* @return false
*/
bool InitQueue(LinkQueue &Q)
{
Q.front = Q.rear = new QNode;
Q.front->next = nullptr;
return true;
}
/**
* @brief 销毁队列
*
* @param Q
* @return true
* @return false
*/
bool DestroyQueue(LinkQueue &Q)
{
while (Q.front)
{
Q.rear = Q.front->next;
delete Q.front;
Q.front = Q.rear;
}
return true;
}
/**
* @brief 判断队列是否为空
*
* @param Q
* @return true
* @return false
*/
bool QueueEmpty(LinkQueue Q)
{
return Q.front == Q.rear;
}
/**
* @brief 入队
*
* @param Q
* @param e
* @return true
* @return false
*/
bool EnQueue(LinkQueue &Q, QElemType e)
{
QNode *p = new QNode;
p->data = e;
p->next = nullptr;
Q.rear->next = p;
Q.rear = p;
return true;
}
/**
* @brief 出队
*
* @param Q
* @param e
* @return true
* @return false
*/
bool DeQueue(LinkQueue &Q, QElemType &e)
{
if (Q.front == Q.rear)
return false;
QNode *p = Q.front->next;
e = p->data;
Q.front->next = p->next;
if (Q.rear == p)
Q.rear = Q.front;
delete p;
return true;
}
void printUI()
{
cout << "*******************************************************" << endl;
cout << "********* 1.创建二叉树 *********" << endl;
cout << "********* 2.先序遍历二叉树 *********" << endl;
cout << "********* 3.中序遍历二叉树1 *********" << endl;
cout << "********* 4.中序遍历二叉树2 *********" << endl;
cout << "********* 5.后序遍历二叉树 *********" << endl;
cout << "********* 6.层序遍历二叉树 *********" << endl;
cout << "********* 7.求二叉树的深度 *********" << endl;
cout << "********* 8.退出 *********" << endl;
cout << "*******************************************************" << endl;
}
/**
* @brief 先序遍历创建二叉树
*
* @param T
*/
void CreateBiTree(BiTree &T)
{
char ch;
cin >> ch;
if (ch == '$')
T = nullptr;
else
{
T = new BiTNode;
T->data = ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}
/**
* @brief 先序遍历二叉树
*
* @param T
*/
void PreOrderTraverse(BiTree T)
{
if (T)
{
cout << T->data << " ";
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
/**
* @brief 中序遍历二叉树(递归)
*
* @param T
*/
void InOrderTraverse1(BiTree T)
{
if (T)
{
InOrderTraverse1(T->lchild);
cout << T->data << " ";
InOrderTraverse1(T->rchild);
}
}
/**
* @brief 中序遍历二叉树(非递归)
*
* @param T
*/
void InOrderTraverse2(BiTree T)
{
SqStack S;
InitStack(S);
BiTree p = T, q;
while (p || !StackEmpty(S))
{
if (p)
{
Push(S, p);
p = p->lchild;
}
else
{
Pop(S, q);
cout << q->data << " ";
p = q->rchild;
}
}
DestroyStack(S);
}
/**
* @brief 后序遍历二叉树
*
* @param T
*/
void PostOrderTraverse(BiTree T)
{
if (T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout << T->data << " ";
}
}
/**
* @brief 层序遍历二叉树
*
* @param T
*/
void LevelOrderTraver(BiTree T)
{
LinkQueue Q;
InitQueue(Q);
EnQueue(Q, T);
while (!QueueEmpty(Q))
{
BiTree p;
DeQueue(Q, p);
cout << p->data << " ";
if (p->lchild)
EnQueue(Q, p->lchild);
if (p->rchild)
EnQueue(Q, p->rchild);
}
DestroyQueue(Q);
}
/**
* @brief 求二叉树深度
*
* @param T
* @return int
*/
int Depth(BiTree T)
{
if (T == nullptr)
return 0;
else
{
int m = Depth(T->lchild);
int n = Depth(T->rchild);
if (m >= n)
return m + 1;
else
return n + 1;
}
}
int main()
{
BiTree T = nullptr;
int mode;
printUI();
while (true)
{
cout << "请输入选择:";
cin >> mode;
if (mode == 8)
break;
if (mode < 1 || mode > 8)
continue;
if (!T && mode != 1)
{
cout << "尚未初始化" << endl;
continue;
}
switch (mode)
{
case 1:
cout << "请输入节点序列:";
CreateBiTree(T);
cout << "创建成功" << endl;
break;
case 2:
PreOrderTraverse(T);
cout << endl;
break;
case 3:
InOrderTraverse1(T);
cout << endl;
break;
case 4:
InOrderTraverse2(T);
cout << endl;
break;
case 5:
PostOrderTraverse(T);
cout << endl;
break;
case 6:
LevelOrderTraver(T);
cout << endl;
break;
case 7:
cout << "二叉树深度为" << Depth(T) << endl;
break;
}
}
return 0;
}