二叉树BT 模板类实现

于 2021-01-16 07:47:40 发布
阅读量342 收藏
点赞数
分类专栏： 清华大学《数据结构(C++语言版)》第三版 算法详析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Devil_DiabLo/article/details/112691391
版权

文章目录

1.题目

BT模板类 维护

2.数据结构与算法

BinNode：父节点、左孩子、右孩子、数据域、高度
BinTree：根节点指针、规模

3.源代码

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

#define BinNodePosi(T) BinNode<T>*
#define stature(p) ((p)? (p)->height : -1)
#define HasLChild(x) ((x).lChild)
#define HasRChild(x) ((x).rChild)


//BinNode
template<typename T> struct BinNode{
	//成员
	BinNodePosi(T) parent, lChild, rChild; //父亲、孩子
	T data; //数据域
	int height; //高度

	//构造函数
	BinNode(T e, BinNodePosi(T) p = NULL, BinNodePosi(T) lc = NULL, BinNodePosi(T) rc = NULL, int h = 0)
		:data(e), parent(p), lChild(lc), rChild(rc), height(h){}

	//操作接口
	int size(); //包含自身子树规模
	BinNodePosi(T) insertAsLC(T const &); //作为当前节点的左孩子插入
	BinNodePosi(T) insertAsRC(T const &); //作为当前节点的右孩子插入

	template<typename T, typename VST> static void visitAlongLeftBranch(stack<BinNodePosi(T)> &, BinNodePosi(T), VST &);
	template<typename T, typename VST> static void goAlongLeftBranch(stack<BinNodePosi(T)> &, BinNodePosi(T), VST &);
	template<typename T> static void gotoHLVF(stack<BinNodePosi(T)> &);
	
	template<typename VST> void travlevel(VST &); //层次遍历
	template<typename VST> void travPre(VST &);	//先序遍历
	template<typename VST> void travIn(VST &); //中序遍历
	template<typename VST> void travPost(VST &); //后序遍历

	//先序遍历各版本
	template<typename T, typename VST> void travPre_R(BinNodePosi(T), VST &);
	template<typename T, typename VST> void travPre_I1(BinNodePosi(T), VST &);
	template<typename T, typename VST> void travPre_I2(BinNodePosi(T), VST &);

	//中序遍历各版本
	template<typename T, typename VST> void travIn_R(BinNodePosi(T), VST &);
	template<typename T, typename VST> void travIn_I(BinNodePosi(T), VST &);

	//后序遍历个版本
	template<typename T, typename VST> void travPost_R(BinNodePosi(T), VST &);
	template<typename T, typename VST> void travPost_I(BinNodePosi(T), VST &);
};
//操作接口
template<typename T> int BinNode<T>::size(){
	int s = 1; //计入自身
	if(lChild) s += lChild.size(); //递归计入左孩子的规模
	if(rChild) s += rChild.size(); //递归计入右孩子的规模
	return s;
} //o(n)
template<typename T> BinNodePosi(T) BinNode<T>::insertAsLC(T const &e){
	return lChild = new BinNode<T>(e, this);
} //o(1)
template<typename T> BinNodePosi(T) BinNode<T>::insertAsRC(T const &e){
	return rChild = new BinNode<T>(e, this);
}//o(1)
template<typename T1> template<typename T, typename VST> static void BinNode<T1>::visitAlongLeftBranch(stack<BinNodePosi(T)> &s, BinNodePosi(T) x, VST &visit){
	while(x){
		visit(x);
		if(HasRChild(x)) s.push(x->rChild);
		x = x->lChild;
	}
}
template<typename T1> template<typename T, typename VST> static void BinNode<T1>::goAlongLeftBranch(stack<BinNodePosi(T)> &s, BinNodePosi(T) x, VST &visit){
	while(x){
		s.push(x);
		if(HasLChild(x)) x = x->lChild;
	}
}
template<typename T1> template<typename T> static void BinNode<T1>::gotoHLVF(stack<BinNodePosi(T)> &s){
	while(BinNodePosi(T) x = s.top()){
		if(HasLChild(*x)){
			if(HasRChild(*x)) s.push(x->rChild);
			s.push(x->lChild);
		}else{
			s.push(x->rChild);
		}
	}
	s.pop();
}

//先序遍历
template<typename T> template<typename VST> void BinNode<T>::travPre(VST & visit){
	switch(rand()%3){
	case 1: travPre_R(this, visit);break;
	case 2: travPre_I1(this, visit);break;
	default: travPre_I2(this, visit);break;
	}
}	
//先序遍历各版本
template<typename T1> template<typename T, typename VST> void  BinNode<T1>::travPre_R(BinNodePosi(T) x, VST &visit){
	if(!x) return;
	visit(x->data);
	travPre_R(x->lChild, visit);
	travPre_R(x->rChild, visit);
}
template<typename T1> template<typename T, typename VST> void  BinNode<T1>::travPre_I1(BinNodePosi(T) x, VST &visit){
	stack<BinNodePosi(T)> s; //辅助栈
	if(x) s.push(x); //根节点入栈
	while(!s.empty()){
		x = s.top();s.pop();visit(x); 
		if(HasLChild(*x)) s.push(x->rChild); //右孩子先入栈
		if(HasRChild(*x)) s.push(x->lChild); //左孩子后入栈
	}
}
template<typename T1> template<typename T, typename VST> void  BinNode<T1>::travPre_I2(BinNodePosi(T) x, VST &visit){
	if(!x) return;
	stack<BinNodePosi(T)> s;
	while(true){
		visitAlongLeftBranch(s, x, visit);
		if(s.empty()) break;
		x = s.top(); s.pop();
	}
}

//中序遍历
template<typename T> template<typename VST> void BinNode<T>::travIn(VST &visit){
	switch(rand()%2){
	case 1: travIn_R(this, visit);break;
	default: travIn_I(this, visit);break;
	}
}
//中序遍历各版本
template<typename T1> template<typename T, typename VST> void BinNode<T1>::travIn_R(BinNodePosi(T) x, VST &visit){
	if(!x) return;
	travIn_R(x->lChild, visit);
	visit(x->data);
	travIn_R(x->rChild, visit);
}
template<typename T1> template<typename T, typename VST> void BinNode<T1>::travIn_I(BinNodePosi(T) x, VST &visit){
	stack<BinNodePosi(T)> s;
	while(true){
		goAlongLeftBranch(x);
		if(s.empty()) break;
		x = s.top(); s.pop();
		visit(x);
		x = x->rChild;
	}
}

//后序遍历
template<typename T> template<typename VST> void BinNode<T>::travPost(VST &visit){
	switch(rand()%2){
	case 1: travPost_R(this, visit);break;
	default: travPost_I(this, visit);break;
	}
}
//后序遍历各版本
template<typename T1> template<typename T, typename VST> void BinNode<T1>::travPost_R(BinNodePosi(T) x, VST &visit){
	if(!x) return;
	travIn_R(x->lChild, visit);
	travIn_R(x->rChild, visit);
	visit(x->data);
}
template<typename T1> template<typename T, typename VST> void BinNode<T1>::travPost_I(BinNodePosi(T) x, VST &visit){
	stack<BinNodePosi(T)> s;
	if(x) s.push(x);
	while(!s.empty()){
		if(s.top() != x->parent)
			goAlongLeftBranch(s);
		x = s.top(); s.pop(); 
		visit(x);
	}
}

//层次遍历
template<typename T> template<typename VST> void BinNode<T>::travlevel(VST &visit){
	queue<BinNodePosi(T)> q;
	q.push(this);
	BinNodePosi(T) x;
	while(!q.empty()){
		x = q.front(); q.pop();visit(x->data);
		if(HasLChild(*x)) q.push(x->lChild);
		if(HasRChild(*x)) q.push(x->rChild);
	}
}

/********华丽的分割线************************************************************************************************/

//BinTree模板类
template<typename T> class BinTree{
protected:
	int _size; //规模
	BinNodePosi(T) _root;
	virtual int updateHeight(BinNodePosi(T) x); //更新节点x的高度
	void updateHeightAbove(BinNodePosi(T) x); //更新节点x及其祖先的高度
public:
	int size() const{ return _size;}
	bool empty() const{ return !_root;}
	BinNodePosi(T) root() const{return _root;}
	BinNodePosi(T) insertAsLC(BinNodePosi(T) x, T const &);
	BinNodePosi(T) insertAsRC(BinNodePosi(T) x, T const &);

	template<typename VST> void travLevel(VST &visit){
		if(_root) _root->travlevel(visit);
	}
	template<typename VST> void travPre(VST &visit){
		if(_root) _root->travPre(visit);
	}
	template<typename VST> void travIn(VST &visit){
		if(_root) _root->travIn(visit);
	}
	template<typename VST> void travPost(VST &visit){
		if(_root) _root->travPost(visit);
	}
};

//操作接口
template<typename T> int BinTree<T>::updateHeight(BinNodePosi(T) x){
	return x->height = 1 + max(stature(x->lChild), stature(x->rChild));
}
template<typename T> void BinTree<T>::updateHeightAbove(BinNodePosi(T) x){
	while(x){
		updateHeight(x);
		x = x->parent;
	}
}
template<typename T> BinNodePosi(T) BinTree<T>::insertAsLC(BinNodePosi(T) x, T const &e){
	_size++; x->insertAsLC(e);
	updateHeightAbove(x);
	return x->lChild;
}
template<typename T> BinNodePosi(T) BinTree<T>::insertAsRC(BinNodePosi(T) x, T const &e){
	_size++; x->insertAsRC(e);
	updateHeightAbove(x);
	return x->rChild;
}

4.时间复杂度

5.结论

树：最小连通图、最大无环图
根据长子、兄弟表示法，外加有根、有序的条件，所有树都可以转化为二叉树。
所以只需研究二叉树BT。

如有错误，请您批评指正。
参考书籍：清华大学《数据结构（C++语言版）》（第三版） 邓俊辉

孤独的咬杀君
关注
专栏目录
模板
BT_zhb的博客
07-25 525
1.泛型编程 泛型编程：编写与类型不管的同样代码，是代码复用的一种手段，模板是泛型编程的基础。 不是使用泛型编程，使用函数重载可以实现实现一个通用的交换函数： void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } void Swap(double& left, do...
二叉树（Binary Tree,BT）的概念和性质
derty_min的博客
07-06 5203
二叉树是一种比较特殊的树形结构，也比较常见，其特点是每个节点最多只有二棵子树，即二叉树中不存在度大于2的节点。二叉树的子树有左子树、右子树之分，孩子同样也有左孩子、右孩子之分（次序不能颠倒）。一般地，二叉树有如下5种形态。...
数据结构（一）、二叉树（BT），二叉查找树（BST），平衡二叉树（AVL树）
王义凯 的博客
07-30 4846
数据结构中有很多树的结构，其中包括二叉树、二叉搜索树、红黑树等等。本文中对数据结构中的二叉树以及二叉查找树，平衡二叉树AVL进行介绍，如果对你有帮助的话，请点个赞吧~谢谢！
后序线索化二叉树及遍历（图解）
热门推荐
CodingStart
08-01 7万+
线索二叉树的后序遍历详细介绍，图解，特别适合初学者，以及懒得画图的童鞋了
21款免费的HTML5响应式模板（附下载
BTfan123的专栏
11-07 3301
HTML5主题模板看起来总是那样专业和引人入胜，吸引了无数Web开发者的“芳心”。响应式也是最近比较流行的一种技术，如果将两种技术结合起来，网站效果堪称完美。本文提供了21款免费的HTML5响应式模板下载，请收藏、请分享！ Folder Responsive Html5 Theme zCumbeton – Free Responsive Html5 Theme Katakli
数据结构之二叉树（类模板实现）（C++）
碣石观海的博客
05-28 3771
注：代码中使用的“ObjArrayList.h”、"SqStack.h"、"CQueue.h" 头文件代码在上三篇博文中已给出，分别为数据结构之顺序列表、栈、队列。//文件名："BiTree.h" #pragma once #ifndef BITREE_H_ #define BITREE_H_ #include &lt;string&gt; #include "ObjArrayList.h" //...
C++模板实现二叉树
m0_46346690的博客
11-07 465
Github完整代码下载地址 完整头文件在项目的路径为：inc/chapter6.h BinaryTree 类定义 BinaryTree类实现的二叉树能够实现以下功能： 清空二叉树 查找 插入 移除 前序(preorder)，中序（inorder），后序（postorder）的方式遍历整个二叉树 template <typename elemType> class BinaryTree{ friend class BTnode<elemType>; public:
数据结构-二叉树:C++模板类递归实现与非递归实现
Alan_1550587588的博客
04-16 904
C++模板类递归实现与非递归实现二叉树遍历 实现的功能:  1.存储，2.前序遍历，3.中序遍历，4.后序遍历，5.层序遍历。 递归实现二叉树代码： //二叉树-二叉链表-递归******************************************************************** //输入示范： // A
C++实现二叉树
11-09
首先，我们定义一个二叉树节点的模板类`Node<T>`，它包含一个数据成员`T data`，表示存储的数据，以及两个指针`Node* left`和`Node* right`，分别指向左子节点和右子节点。模板参数`<T>`代表我们可以使用任何类型的...
数据结构实验6：C++实现二叉树类
u25th_engineer的博客
11-19 2923
                                             实验6                                                                  学号：      姓名：      专业：   6.1 实验目的 掌握二叉树的动态链表存储结构及表示。 掌握二叉树的三种遍历算法（递归和非递归两类）。 运用二叉...
二叉树的链式存储及其部分函数实现
LaoXiangQ的博客
10-19 1855
题意 实现二叉树的链式存储和部分的函数 思路 这是一个链式存储实现的二叉树。首先 是构造了一个名为 node 的 二叉树数据结构内有（1）char 变量，（2）两个指向其本身的结构体指针变量 lch,rch.然后 用typedef分别给 node结构体起了一个Bn的别名和给 node* 起了一个Bt 的别名方便后面代码的使用。Bn和Bt分别是代表二叉树节点 类型和二叉树节...
c++利用模板实现二叉树插入删除以及遍历
M_Alan_walker的博客
07-29 254
#include <iostream> using namespace std; template <typename Type> class BinaryTree; template <typename valType> class BTnode{ friend class BinaryTree<valType>; public: BTnode(const valType &val); void insert_valu.
设计一个递归算法由二叉树BT复制产生另一棵二叉树BT1（假设二叉树采用二叉链存储结构）
慢慢的博客
10-03 3604
设计一个递归算法由二叉树BT复制产生另一棵二叉树BT1（假设二叉树采用二叉链存储结构） 源代码如下： #include <iostream> using namespace std; //二叉树的结构 typedef struct BTNode { char data; struct BTNode *left; struct BTNode *right; }BTNode; //由二叉树BT复制产生另一棵二叉树BT1 void copyBTree(BTNode*BT, BTNode
有序vector 二分查找(A、B、C版本)Fib查找
Devil_DiabLo的博客
01-14 482
文章目录1.题目2.数据结构与算法3.源代码4.时间复杂度5.结论 1.题目 给定一个有序向量A[0, n]，在[lo, hi)区间内查找元素e，返回元素e的索引。 若有重复元素，或查找失败 “返回不大于e的最大元素” 。 2.数据结构与算法 algorithm：二分查找（版本C） 3.源代码 #include "stdafx.h" #include <iostream> #include <algorithm> #include <vector> using name
LCS 递归与DP迭代
Devil_DiabLo的博客
01-11 454
文章目录1.题目2.数据结构与算法3.源代码4.时间复杂度5.结论 1.题目 给定两个字符串，两个字符串的公共子串中最长的即为"最长公共子串" LCS 2.数据结构与算法 给定两个字符A[0, n), B[0, m) 递归实现：比较两个字符串的末尾字符，总共有3种情况 1.递归基：m=0或 n=0, 其中一个字符为空字符，直接返回空串即可。 2. 末字符 A[n-1] == B[m-1] == "X" 减而治之: lcs(A[0, n-1), B[0,m-1)) + “X” 其中 子问题：两子串的lc
list 唯一化
Devil_DiabLo的博客
01-14 451
文章目录1.题目2.数据结构与算法3.源代码4.时间复杂度5.结论 1.题目 list唯一化 2.数据结构与算法 algorithm：先排序，再使用双指针进行唯一化 3.源代码 #include "stdafx.h" #include <iostream> #include <time.h> #include <stdlib.h> #include <list> #include <algorithm> using namespace std;
Max2 递归与分治
Devil_DiabLo的博客
01-10 437
文章目录1.题目2.数据结构与算法3.源代码4.时间复杂度5.结论 1.题目 从数组区间A[lo, hi)中找出最大的两个整数A[x1]和A[x2]，元素比较的次数，要求尽可能的少。 2.数据结构与算法 Algorithm：递归与分治 1.原问题：数组A的Max2？ 2.分治：将数组A二分为数组A1与数组A2 3.两个子问题：数组A1的Max2与数组2的Max2？ 4.合并：A1的Max2与A2的Max2这4个元素的Max2就是A的Max2 5.递归基：考虑子数组长度为2或3两种情况。 3.源代码 #in
中缀表达式转RPN
Devil_DiabLo的博客
01-15 363
文章目录1.题目2.数据结构与算法3.源代码4.时间复杂度5.结论 1.题目 中缀表达式转RPN 2.数据结构与算法 DS:stack Algorithm: 参考我的上一篇文章：《中缀表达式求值 延迟缓冲》 只需对其代码进行扩充，即可得到中缀表达式转RPN的算法。 扩充内容（可以使用文本对比工具） 扫描中缀表达式： 当遇到数字，将数字追加到RPN后。 当遇到符号，若执行计算(即>分支)，则将栈顶符号追加到RPN后。 3.源代码 #include "stdafx.h" #include <ios
C语言实现二叉树的创建与后序遍历编号
资源摘要信息:"按二叉树的形状打印二叉树后端- C" 知识点说明: 1. 二叉树的数据结构: 在这段代码中, 二叉树是使用C语言中...这一点需要注意，因为C++语言相对于C语言在标准库、类和模板等特性上提供了更多的支持。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值