数据结构--二叉树的实现（C++）

前言

数据结构实验作业--用二叉链表实现二叉树（c++版）

包括二叉树的构建、二叉树的销毁，前序遍历、中序遍历、后序遍历、层序遍历等基本操作。

还有求二叉树的叶子结点个数，二叉树的深度、结点个数等。

---

提示：以下是本篇文章正文内容，下面案例可供参考

1.二叉树的结点定义：

template<typename Datatype>
struct BiNode {
	Datatype data;
	BiNode<Datatype> *lchild, *rchild;
};

2.二叉链表类定义：

template<typename Datatype>
class BiTree {
public :
	BiTree() { root = Creat(); }//构造函数，构造一颗二叉树
	~BiTree() { Release(root); }//析构函数，释放各结点的存储空间
	void PreOrder() { PreOrder(root); }//前序遍历
	void InOrder() { InOrder(root); }//中序遍历
	void PostOrder() { PostOrder(root); }//后序遍历
	void LevelOrder();//层序遍历
	int NodeNum() { return NodeNum(root); }//二叉树的结点总个数
	int TreeDepth() { return TreeDepth(root); }//二叉树的深度
	void LeafNode() { LeafNode(root); }//二叉树叶子结点数量
private:
	BiNode<Datatype>* Creat();//构造函数调用
	void Release(BiNode<Datatype>* bt);//析构函数调用
	void PreOrder(BiNode<Datatype>* bt);//前序遍历函数调用
	void PostOrder(BiNode<Datatype>* bt);//后序遍历函数调用
	void InOrder(BiNode<Datatype>* bt);//中序遍历函数调用
	int NodeNum(BiNode<Datatype>* bt);//结点个数函数调用
	int TreeDepth(BiNode<Datatype>* bt);//树深度函数调用
	void LeafNode(BiNode<Datatype>* bt);//叶子结点函数调用
	BiNode<Datatype>* root;//指向根结点的头指针
};

3.基本操作的实现

构造函数

template<typename Datatype>
BiNode<Datatype>* BiTree<Datatype>::Creat() {
	BiNode<Datatype>* bt;
	char ch;
	cin >> ch;
	if (ch == '#') {
		bt = nullptr;
	}
	else {
		bt = new BiNode<Datatype>;//生成一个头结点
		bt->data = ch;
		bt->lchild = Creat();//递归建立左子树
		bt->rchild = Creat();//递归建立右子树
	}
	return bt;
}

析构函数

template<typename Datatype>
void BiTree<Datatype>::Release(BiNode<Datatype>* bt) {
	if (bt == nullptr) {
		return;
	}
	else {
		Release(bt->lchild);//释放左子树
		Release(bt->rchild);//释放右子树
		delete bt;
	}
}

前序遍历

template<typename Datatype>
void BiTree<Datatype>::PreOrder(BiNode<Datatype>* bt) {
	if (bt == nullptr) return;//递归调用结束条件
	else {
		cout << bt->data << '\t';//访问根结点数据域
		PreOrder(bt->lchild);//前序递归遍历bt左子树
		PreOrder(bt->rchild);//前序递归遍历bt右子树
	}
}

中序遍历

template<typename Datatype>
void BiTree<Datatype>::InOrder(BiNode<Datatype>* bt) {
	if (bt == nullptr) return;
	else {
		InOrder(bt->lchild);
		cout << bt -> data << '\t';
		InOrder(bt->rchild);
	}
}

后序遍历

template<typename Datatype>
void BiTree<Datatype>::PostOrder(BiNode<Datatype>* bt) {
	if (bt == nullptr) return;
	else {
		PostOrder(bt->lchild);
		PostOrder(bt->rchild);
        cout << bt->data << '\t';
	}
}

层序遍历

template<typename Datatype>
void BiTree<Datatype>::LevelOrder() {
	BiNode<Datatype>* Q[100], * q = nullptr;
	int front = -1, rear = -1;//队列初始化
	if (root == nullptr) {//二叉树为空，算法结束
		return;
	}
	Q[++rear] = root;//根指针入队
	while (front != rear) {//当队列非空
		q = Q[++front];//出队
		cout << q->data << "\t";
		if (q->lchild != nullptr) Q[++rear] = q->lchild;
		if (q->rchild != nullptr) Q[++rear] = q->rchild;
	}
}

结点个数

template<typename Datatype>
int BiTree<Datatype>::NodeNum(BiNode<Datatype> *bt) {
	//递归遍历所有结点 如果不是空结点的话，递归返回值加1
	if (bt == nullptr) return 0;
	else {
		return NodeNum(bt->lchild) + NodeNum(bt->rchild) + 1;
	}
}

二叉树的深度

template<typename Datatype>
int BiTree<Datatype>::TreeDepth(BiNode<Datatype>* bt) {
	//每个节点都有自己的左右子树，每次返回当前节点左右子树长度大的那个
	//如果根节点为空，则深度为0，返回0，递归出口
	//否则深度至少为1，然后累加他们左右子树的深度
	int ldepth = 1, rdepth = 1;
	if (bt == nullptr) return 0;
	else {
		ldepth += TreeDepth(bt->lchild);
		rdepth += TreeDepth(bt->rchild);
	}
	return ((ldepth > rdepth) ? ldepth : rdepth);
}

叶子结点

template<typename Datatype>
void BiTree<Datatype>::LeafNode(BiNode<Datatype>* bt) {
	//找到叶子结点返回值加1，返回值计数，
	//2种情况
	//1.节点为空 返回0，递归出去
	//2.每当到达叶子结点，返回1，递归给上一层函数
	if (bt != nullptr) {
		if (bt->lchild == 0 && bt->rchild == 0) {
			cout << bt->data;
		}
		LeafNode(bt->lchild);
		LeafNode(bt->rchild);
	}
}

具体使用

int main() {
	BiTree<char> T{};
	cout << "该二叉树的前序遍历序列是:";
	T.PreOrder();
	cout << "\n该二叉树的中序遍历序列是:";
	T.InOrder();
	cout << "\n该二叉树的后序遍历序列是:";
	T.PostOrder();
	cout << "\n该二叉树的层序遍历序列是:";
	T.LevelOrder();
	cout << "\n该二叉树的结点个数为:"<<T.NodeNum();;
	cout << "\n该二叉树的深度为:" <<T.TreeDepth();
	cout << "\n该二叉树叶子结点是:";
	T.LeafNode();
	return 0;
}

注意：输入的格式

运行结果：

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。