使用C++实现二叉树的创建、删除和遍历

钊洺

已于 2023-08-10 23:45:29 修改

阅读量247

点赞数 1

文章标签： c++ 数据结构开发语言

于 2023-08-10 17:12:57 首次发布

本文链接：https://blog.csdn.net/weixin_43872506/article/details/132214204

版权

本文详细介绍了C++中的队列类LinkQueue和二叉树类BiTree的定义、构造与析构函数，以及它们的遍历方法（前序、中序、后序和层序）和辅助函数。还展示了如何在主函数中调用这些类的方法。

摘要由CSDN通过智能技术生成

1、头文件

#ifndef QUEUE_H
#define QUEUE_H

typedef struct binode {
char data;
struct binode* lchild, * rchild;
}BiNode;

template <class DataType>
class LinkQueue {//队列的类

private:
typedef struct Node {
DataType data;
struct Node* next;
}node, *Link;
Node* front, * rear;
int length;
public:

LinkQueue();//构造函数
~LinkQueue();//析构函数
void enQueue(DataType x);//入队
bool deQueue(DataType& item);//出队
void clearQueue();//清空队列
bool isEmpty();//判断是否为空队列
};

typedef LinkQueue<BiNode> BiQueue;

class BiTree {//二叉树的类

private:
BiNode* root;//指向根节点的头指针
int leafnum;
public:
BiTree() { root = creat(root); }
~BiTree() { release(root); }
void preOrder() { preOrder(root); }//前序遍历二叉树
void inOrder() { inOrder(root); }//中序遍历二叉树
void postOrder() { postOrder(root); }//后序遍历二叉树
void leverOrder() { LeverOrder(); }//层序遍历二叉树
int deep() { return Deep(root); }
int leaf() { return Leaf(root, leafnum); }
private:
BiNode* creat(BiNode* bt);//构造函数
void release(BiNode* bt);//析构函数调用
void preOrder(BiNode* bt);//前序遍历函数调用
void inOrder(BiNode* bt);//中序遍历函数调用
void postOrder(BiNode* bt);//后序遍历函数调用
void LeverOrder();//层次遍历函数调用
int Deep(BiNode* bt);
int Leaf(BiNode* bt, int num);
};

#endif // ! QUEUE_H

2、队列的相关函数实现

#include <iostream>
#include "queue.h"

template <class DataType>
LinkQueue<DataType>::LinkQueue()
{
   front = new Node;
   front->next = NULL;
   rear = front;
   length = 0;
}

template <class DataType>
LinkQueue<DataType>::~LinkQueue()
{
   clearQueue();
   if (front)
   {
       delete front;
   }
}

template <class DataType>
void LinkQueue<DataType>::clearQueue()
{
   Link p;
   p = front->next;
   while (p != NULL)
   {
       front->next = p->next;
       delete p;
       length--;
       p = front->next;
   }
   rear = front;
}

template <class DataType>
void LinkQueue<DataType>::enQueue(DataType x)
{
   Link s;
   s = new Node;
   s->next = NULL;
   s->data = x;
   rear->next = s;
   rear = s;
   length++;
}
template <class DataType>
bool LinkQueue<DataType>::isEmpty()
{
   return (front == rear) || (length == 0);
}
template <class DataType>
bool LinkQueue<DataType>::deQueue(DataType& item)
{
   Link p;
   p = front->next;
   if (isEmpty())
   {
       return false;
   }
   else
   {
       item = p->data;
       front->next = p->next;
       if (p->next == NULL)
       {
           rear = front;
       }
       delete p;
       length--;
   }
   return true;
}

template class LinkQueue <BiNode>;

3、二叉树的相关函数实现

#include <iostream>
#include "queue.h"

using namespace std;

BiNode* BiTree::creat(BiNode* bt) {
char ch;
cin >> ch;
if (ch == '#')//建立一颗空树
{
bt = NULL;
}
else {
bt = new BiNode;
bt->data = ch;//生成一个结点，数据域为ch
bt->lchild = creat(bt->lchild);//递归创建左子树
bt->rchild = creat(bt->rchild);//递归创建右子树
}
return bt;
}
void BiTree::release(BiNode* bt) {
if (!bt) return;
release(bt->lchild);
release(bt->rchild);
delete bt;
}

void BiTree::preOrder(BiNode* bt) {
if (bt == NULL) {
return;
}
else {
cout << bt->data << " ";//返回bt的内容
preOrder(bt->lchild);
preOrder(bt->rchild);
}
}

void BiTree::inOrder(BiNode* bt) {
if (bt == NULL) {
return;
}
else {
inOrder(bt->lchild);
cout << bt->data << " ";//返回bt的内容
inOrder(bt->rchild);
}
}

void BiTree::postOrder(BiNode* bt) {
if (bt == NULL) {
return;
}
else {
postOrder(bt->lchild);
postOrder(bt->rchild);
cout << bt->data << " ";//返回bt的内容
}
}
typedef LinkQueue<BiNode> BiQueue;
void BiTree::LeverOrder()
{
BiQueue biqueue;
BiNode q;
if (root == NULL)
{
return;
}
biqueue.enQueue(*root);//根指针入队
while (!biqueue.isEmpty())//当队列非空时
{
biqueue.deQueue(q);//出队
cout << q.data << " ";
if (q.lchild != NULL)
{
biqueue.enQueue(*q.lchild);
}
if (q.rchild != NULL)
{
biqueue.enQueue(*q.rchild);
}
}
}

int BiTree::Deep(BiNode* bt)
{
int m, n;

if (bt == NULL)
return 0; //如果是空树，深度为0，递归结束
else
{
m = Deep(bt->lchild); //递归计算左子树的深度记为m
n = Deep(bt->rchild); //递归计算右子树的深度记为n
if (m > n)
return (m + 1); //二叉树的深度为m 与n的较大者加1
else
return (n + 1);
}
}
int BiTree::Leaf(BiNode* bt, int num)
{
if (bt != NULL)
{
if (bt->lchild == NULL && bt->rchild == NULL)
num++;
num = Leaf(bt->lchild, num);
num = Leaf(bt->rchild, num);
}
return num;
}

4、主函数调用

#include <iostream>
#include "queue.h"
using namespace std;

int main()
{
int num;
BiTree tree;
tree.preOrder();
cout << endl;
tree.inOrder();
cout << endl;
tree.postOrder();
cout << endl;
tree.leverOrder();
cout << endl;
num = tree.deep();
cout << num;
num = tree.leaf();
cout << num;
}