C++实现二叉树所有操作 -- 创建递归遍历迭代遍历拷贝清空查找

最新推荐文章于 2022-08-25 11:15:25 发布
最新推荐文章于 2022-08-25 11:15:25 发布
阅读量1k 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： C++ 二叉树 递归遍历 非递归遍历 前序中序后序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FreeeLinux/article/details/52122500
版权
本文提供了一种使用C++实现二叉树的各种操作的方法，包括通过输入流、字符串创建二叉树，递归与迭代遍历，拷贝、查找、比较等。所有代码均经过测试验证。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本文代码实现了二叉树输入流创建，字符串创建，带返回值的创建，前中后序递归及迭代遍历二叉树，拷贝二叉树，求大小，高度，查找元素，查找父节点，子节点，清空，比较等等二叉树所有操作。文中所有代码均经过测试。

#ifndef _BIN_TREE_H
#define _BIN_TREE_H

#include <iostream>
#include <vector>
#include <stack>
#include <assert.h>
#include <string.h>
using namespace::std;

template<typename _T>
class _Bin_Tree;

template<typename _T>
class _Tree_Node{
	friend class _Bin_Tree<_T>;
public:
	_Tree_Node() :m_data(_T()), leftChild(NULL), rightChild(NULL)
	{}
	_Tree_Node(_T data, _Tree_Node<_T>* left = NULL, _Tree_Node<_T>* right = NULL) 
				:m_data(data), leftChild(left), rightChild(left)
	{}
private:
	_T m_data;
	_Tree_Node<_T>  *leftChild;
	_Tree_Node<_T>  *rightChild;
};

template<typename _T>
class _Bin_Tree{
	typedef _Tree_Node<_T> node_type;
public:
	_Bin_Tree() = default;
	_Bin_Tree(const _T& ref) :refval(ref)
	{}
	_Bin_Tree(const _Bin_Tree<_T> &);
	~_Bin_Tree();
public:
	//create by cin/str 
	void init_bin_tree();
	node_type* init_tree_ret();   //has return value - root
	void init_bin_tree(const char *);
	node_type* init_tree_ret(const char *&);    //has return value - root

	//create by VLR-LVR   --   LVR-LRV
	void init_tree_pre_in(const char *, const char *);
	void init_tree_in_post(const char *, const char *); 

	//traverse  reverse/iter
	void preorder_traverse()const;
	void inorder_traverse()const;
	void postorder_traverse()const;
	void pre_iter_traverse()const;
	void in_iter_traverse()const;
	void post_iter_traverse()const;
	void level_traverse()const;
	
	size_t Size()const;
	size_t Height()const;
	node_type* Root()const;
	node_type* LeftChild(const node_type *)const;
	node_type* RightChild(const node_type *)const;
	node_type* Parent(const node_type *)const;
	node_type* Find(const _T &)const;
	bool Equal(const _Bin_Tree &)const;
	void make_empty();
protected:
	void init_bin_tree(node_type *&);
	node_type* init_tree_ret_();
	void init_bin_tree(node_type *&, const char *&);
	node_type* init_tree_ret_(const char *&);
	node_type* copy_tree(node_type *);
	
	void init_tree_pre_in(node_type *&, const char *, const char *, int);
	void init_tree_in_post(node_type *&, const char *, const char *, int); 

	void preorder_traverse(node_type *)const;
	void inorder_traverse(node_type *)const;
	void postorder_traverse(node_type *)const;
	void pre_iter_traverse(node_type *)const;
	void in_iter_traverse(node_type *)const;
	void post_iter_traverse(node_type *)const;
	void level_traverse(node_type *)const;
	
	size_t Size(node_type *)const;
	size_t Height(node_type *)const;
	node_type* Parent(node_type *, const node_type *)const;
	node_type* Find(node_type *, const _T &)const;
	bool Equal(node_type *, node_type *)const;
	void make_empty(node_type *);
private:
	_T refval;     //'#'
	node_type *root; 
};

/************************************public interface******************************************/

///

template<typename _T>
void _Bin_Tree<_T>::init_bin_tree()
{	
	init_bin_tree(root);
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::init_tree_ret()
{
	return root = init_tree_ret();
}

template<typename _T>
void _Bin_Tree<_T>::init_bin_tree(const char *str)
{
	init_bin_tree(root, str);
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::init_tree_ret(const char *&str)
{
	return root = init_tree_ret_(str);
}

template<typename _T>
_Bin_Tree<_T>::_Bin_Tree(const _Bin_Tree &bt)
{
	root = copy_tree(bt.root);
}

template<typename _T>
void _Bin_Tree<_T>::init_tree_pre_in(const char *VLR, const char* LVR)
{
	init_tree_pre_in(root, VLR, LVR, strlen(VLR));
}

template<typename _T>
void _Bin_Tree<_T>::init_tree_in_post(const char *LVR, const char *LRV)
{
	init_tree_in_post(root, LVR, LRV, strlen(LVR));
}
template<typename _T>
_Bin_Tree<_T>::~_Bin_Tree()
{
	make_empty();
	root = NULL;
}

///

template<typename _T>
void _Bin_Tree<_T>::preorder_traverse()const
{
	preorder_traverse(root);
}

template<typename _T>
void _Bin_Tree<_T>::inorder_traverse()const
{
	inorder_traverse(root);
}

template<typename _T>
void _Bin_Tree<_T>::postorder_traverse()const
{
	postorder_traverse(root);
}

template<typename _T>
void _Bin_Tree<_T>::pre_iter_traverse()const
{
	pre_iter_traverse(root);
}

template<typename _T>
void _Bin_Tree<_T>::in_iter_traverse()const
{
	in_iter_traverse(root);
}

template<typename _T>
void _Bin_Tree<_T>::post_iter_traverse()const
{
	post_iter_traverse(root);
}

template<typename _T>
void _Bin_Tree<_T>::level_traverse()const
{
	level_traverse(root);
}

///

template<typename _T>
size_t _Bin_Tree<_T>::Size()const
{
	return Size(root);
}

template<typename _T>
size_t _Bin_Tree<_T>::Height()const
{
	return Height(root);
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::Parent(const node_type *cur)const
{
	Parent(root, cur);
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::Find(const _T &key)const
{
	return Find(root, key);
}

template<typename _T>
bool _Bin_Tree<_T>::Equal(const _Bin_Tree<_T> &bt)const
{
	return Equal(root, bt.root);
}

template<typename _T>
void _Bin_Tree<_T>::make_empty()
{
	make_empty(root);
}


/***********************************protected interface****************************************/

///

template<typename _T>
void _Bin_Tree<_T>::init_bin_tree(node_type *&pt)
{
	_T elem;
	cin >> elem;

	if(refval == elem){
		pt = NULL;
	}
	else{
		pt = new node_type(elem);
		init_bin_tree(pt->leftChild);
		init_bin_tree(pt->rightChild);
	}
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::init_tree_ret_()
{
	node_type *pt;
	_T elem;

	cin >> elem;
	if(refval == elem){
		pt = NULL;
	}
	else{
		pt = new node_type(elem);
		pt->leftChild = init_tree_ret_();
		pt->rightChild = init_tree_ret_();
	}

	return pt;
}

template<typename _T>
void _Bin_Tree<_T>::init_bin_tree(node_type *&pt, const char *&str)
{
	if(*str == refval){
		pt = NULL;	
	}
	else{
		pt = new node_type(*str);
		init_bin_tree(pt->leftChild, ++str);
		init_bin_tree(pt->rightChild, ++str);
	}
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::init_tree_ret_(const char *&str)
{
	node_type *pt;

	if(*str == refval){
		pt = NULL;
	}
	else{
		pt = new node_type(*str);
		pt->leftChild = init_tree_ret_(++str);
		pt->rightChild = init_tree_ret_(++str);
	}

	return pt;
}

template<typename _T>
void _Bin_Tree<_T>::init_tree_pre_in(node_type *&pt, const char *VLR, const char *LVR, int len)
{
	if(len == 0){
		pt = NULL;
		return ;
	}
	else{
		int k = 0;
		while(LVR[k] != VLR[0])
			++k;
		
		pt = new node_type(LVR[k]);
		init_tree_pre_in(pt->leftChild, VLR+1, LVR, k);
		init_tree_pre_in(pt->rightChild, VLR+k+1, LVR+k+1, len-k-1);
	}
}

template<typename _T>
void _Bin_Tree<_T>::init_tree_in_post(node_type *&pt, const char *LVR, const char *LRV, int len)
{
	if(len == 0){
		pt = NULL;
		return ;
	}
	else{
		int k = 0;
		while(LVR[k] != LRV[len-1])
			k++;

		pt = new node_type(LVR[k]);
		init_tree_in_post(pt->leftChild, LVR, LRV, k);
		init_tree_in_post(pt->rightChild, LVR+k+1, LRV+k, len-k-1);
	}
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::copy_tree(node_type *pt)
{
	node_type *tmp;
	if(pt == NULL){
		return NULL;
	}
	else{
		tmp = new node_type(pt->m_data);
		tmp->leftChild = (copy_tree(pt->leftChild));
		tmp->rightChild = (copy_tree(pt->rightChild));
	}

	return tmp;
}

///

template<typename _T>
void _Bin_Tree<_T>::preorder_traverse(node_type *pt)const
{
	if(pt != NULL){
		cout << pt->m_data << " ";
		preorder_traverse(pt->leftChild);
		preorder_traverse(pt->rightChild);
	}
}

template<typename _T>
void _Bin_Tree<_T>::inorder_traverse(node_type *pt)const
{
	if(pt != NULL){
		inorder_traverse(pt->leftChild);
		cout << pt->m_data << " ";
		inorder_traverse(pt->rightChild);
	}
}

template<typename _T>
void _Bin_Tree<_T>::postorder_traverse(node_type *pt)const
{
	if(pt != NULL){
		postorder_traverse(pt->leftChild);
		postorder_traverse(pt->rightChild);
		cout << pt->m_data << " ";
	}
}

template<typename _T>
void _Bin_Tree<_T>::pre_iter_traverse(node_type *pt)const
{
	if(pt != NULL){
		stack<node_type*> st;
		node_type *tmp = NULL;

		st.push(pt);
		while(!st.empty()){
				tmp = st.top();
				st.pop();
			
				cout << tmp->m_data << " ";
			
				if(tmp->rightChild != NULL)
					st.push(tmp->rightChild);
				if(tmp->leftChild != NULL)
					st.push(tmp->leftChild);
		}
	}
}

template<typename _T>
void _Bin_Tree<_T>::in_iter_traverse(node_type *pt)const
{
	if(pt != NULL){
		stack<node_type*> st;
		node_type *tmp = pt;

		do{
			while(tmp != NULL){
				st.push(tmp);
				tmp = tmp->leftChild;
			}
			
			if(!st.empty()){
				tmp = st.top();
				st.pop();
			
				cout << tmp->m_data << " ";

				tmp = tmp->rightChild;
			}
		}while(tmp != NULL || !st.empty());
	}
}

//
//post_iter_traverse_1 -- struct
/*typedef enum{L, R}Tag;
template<typename _T>
struct Stknode{
	_Tree_Node<_T>* ptr;
	Tag tag;
	Stknode() :ptr(NULL), tag(L)
	{}
}; 
template<typename _T>
void _Bin_Tree<_T>::post_iter_traverse(node_type *pt)const
{
	Stknode<_T> stkn;
	node_type *tmp = pt;
	stack<Stknode<_T> > st;

	do{
		while(tmp != NULL){
			stkn.ptr = tmp;
			stkn.tag = L;

			st.push(stkn);
			tmp = tmp->leftChild;
		}

		bool isRun = true;
		while(isRun && !st.empty()){
			stkn = st.top();
			st.pop();
			
			switch(stkn.tag){
				case L:
					tmp = stkn.ptr;
					stkn.tag = R;
					st.push(stkn);
					tmp = tmp->rightChild;
					isRun = false;
					break;
				case R:
					cout << stkn.ptr->m_data << " ";
					break;
			}
		}
	}while(tmp != NULL || !st.empty());
}*/

//post_iter_traverse_2 -- pair
enum{L, R};
template<typename _T>
void _Bin_Tree<_T>::post_iter_traverse(node_type *pt)const
{
	if(pt != NULL){
		stack<pair<node_type*, int> > st;
		
		st.push(make_pair(pt, L));
		node_type* tmp;
		int tag;

		while(!st.empty()){
			tmp = st.top().first;
			tag = st.top().second;
				
			st.pop();
			if(tag == L){
				st.push(make_pair(tmp, R));
		
				if(tmp->rightChild != NULL)
					st.push(make_pair(tmp->rightChild, L));
				if(tmp->leftChild != NULL)
					st.push(make_pair(tmp->leftChild, L));
			}
			else{
				cout << tmp->m_data << " ";
			}
		}
	}
}

//

template<typename _T>
void _Bin_Tree<_T>::level_traverse(node_type *pt)const
{
	if(pt != NULL){
		vector<node_type *> vec;
		vec.push_back(root);

		int cur = 0;
		int end = 1;
	
		while(cur < vec.size()){
			end = vec.size();

			for( ; cur != end; ++cur){
				cout << vec[cur]->m_data << " ";

				if(vec[cur]->leftChild != NULL)
					vec.push_back(vec[cur]->leftChild);
				if(vec[cur]->rightChild != NULL)
					vec.push_back(vec[cur]->rightChild);
			}
		}	
	}
}

///

template<typename _T>
size_t _Bin_Tree<_T>::Size(node_type *pt)const
{
	if(pt == NULL)
		return 0;
	else
		return 1 + Size(pt->leftChild) + Size(pt->rightChild);
}

template<typename _T>
size_t _Bin_Tree<_T>::Height(node_type *pt)const
{
	if(pt == NULL)
		return 0;
	
	size_t left_height = Height(pt->leftChild);
	size_t right_height = Height(pt->rightChild);

	return (left_height > right_height ? left_height : right_height) + 1;	
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::Root()const
{
	return root;
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::LeftChild(const node_type *cur)const
{
	return cur->leftChild;
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::RightChild(const node_type *cur)const
{
	return cur->rightChild;
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::Parent(node_type *pt, const node_type *cur)const
{
	assert(cur != NULL);
	if(pt == NULL || cur == pt)
		return NULL;
	if(pt->leftChild == cur || pt->rightChild == cur)
		return pt;
	
	node_type* tmp = Parent(pt->leftChild, cur);
	if(tmp == NULL)
		tmp = Parent(pt->rightChild, cur);

	return tmp;
}

template<typename _T>
_Tree_Node<_T>* _Bin_Tree<_T>::Find(node_type *pt, const _T &key)const
{
	if(pt == NULL)
		return NULL;
	if(pt->m_data == key)
		return pt;
	
	node_type* tmp = Find(pt->leftChild, key);
	if(tmp == NULL)
		tmp = Find(pt->rightChild, key);
	
	return tmp;
}

template<typename _T>
bool _Bin_Tree<_T>::Equal(node_type *plhs, node_type *prhs)const
{
	if(plhs == NULL && prhs == NULL)
		return true;
	if(plhs != NULL && prhs != NULL && plhs->m_data == prhs->m_data
					&& Equal(plhs->leftChild, prhs->leftChild)
					&& Equal(plhs->rightChild, prhs->rightChild))
		return true;
	else
		return false;
}

template<typename _T>
void _Bin_Tree<_T>::make_empty(node_type *pt)
{
	if(pt != NULL){
		make_empty(pt->leftChild);
		make_empty(pt->rightChild);
		delete pt;
	}
}

///

#endif


⭐⭐⭐⭐⭐Linux C++性能优化秘籍：从编译器到代码，探究高性能C++程序的实现之道
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-06 2847
高性能C++编程涉及多个方面，包括编译器优化、C++代码性能优化基本原则、C++对象管理与性能优化、多线程编程与性能优化、Linux系统调用优化等。通过学习和掌握这些要点，程序员可以有效地提高C++程序在Linux环境下的性能。接下来的章节将对这些核心要点进行详细的介绍。
软开面试-C++
qq_42199510的博客
08-13 1387
软测面试一、计算机基础1.讲一下OSI七层协议应用层表示层会话层传输层网络层数据链路层物理层2.讲一下TCP/IP参考模型应用层传输层网际互联层网络接入层3.讲一下HTTPS和HTTP的区别（属于应用层）4.URI和URL的区别（应用层）5.讲一下三次握手（传输层）6.讲一下四次挥手（传输层）7.TCP是如何保证可靠的二、操作系统1.讲一下进程和线程的区别进程线程区别2.讲一下死锁三、C++基础1.C++堆和栈的区别 一、计算机基础 1.讲一下OSI七层协议 OSI是国际标准化组织（ISO）提出的一个试
用C++实现二叉树的查找功能
05-30
用c++实现二叉树的查找功能，利用外部文本输入并查找
二叉树的所有操作
weixin_30606669的博客
11-05 183
#include<iostream> #include<stdio.h> #include<malloc.h> using namespace std; #define MaxSize 100 #define MaxWidth 40 typedef char ElemType; typedef struct Node2 { char...
二叉树全部操作
baotongyu的博客
03-08 294
#include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;stdlib.h&gt; typedef struct Node { char value; struct Node *left, *right; } Node; Node *init(char value) { Node *root = (Node *)mal...
关于二叉树的所有操作
热情de马金的博客
04-20 368
合并两棵子树成一棵大树 判断一棵二叉树树是不是完全二叉树 判断一棵二叉树是不是满二叉树 计算一棵二叉树的高度 计算一棵二叉树的节点数 判断两棵二叉树是不是相同 前序遍历（递归和非递归实现） 中序遍历（递归和非递归实现） 后续遍历（递归和非递归实现） /********************************* * * 使用指向节点实现二叉树的节点表示 * copyright @ :
二叉树的递归，层次，以及非递归遍历
Superior's Blog
03-29 615
/*************************************************************** 二叉树的遍历操作：对于先序、中序、后序的非递归遍历来说，是借助于栈 来存储，而对于层次遍历来说是借助于队列来存储 具有代表性的实例：在控制台上输入：ABD00E00C00    A      / \  B   C  / \   D    E
C++实现二叉树操作与线索二叉树的详解
- 拷贝操作：实现二叉树的深度拷贝，创建一个与原树结构和数据完全相同的树。 - 清空操作：释放二叉树所占用的内存资源，将树变为空树。 - 树深度计算：计算二叉树的深度，即从根节点到叶节点的最大路径长度。 -...
C++数据结构-二叉树和线索二叉树
01-03
基于二叉链表的二叉树，实现了二叉树的多种操作：添加、删除、拷贝、清空、树深度计算、父节点、兄弟节点获取、先中后序递归及非遍历、按层次遍历、中序迭代器（非递归算法）、节点查找、先序和中序序列重建二叉树、...
如何在两个月之内掌握C++入门？
Ahahaha___的博客
08-25 1575
C++是C的扩展（而C被列入了容易学习的语言），C++是一种通用编程语言，据说谷歌Chromium浏览器、微软一些应用程序，甚至摩根士丹利的金融建模都是用C++完成。就在之前Springboard平台选出了最容易学习和最难学的编程语言Top 5，其中C++是第一难学的语言。除此之外最重要的就是重视编程基础，这决定了你的编程之路能走多远。浙江大学 C++ 翁恺老师_哔哩哔哩_bilibili。
二叉树的建立查找遍历删除的实现
11-14
二叉树的建立查找遍历删除的程序的实现，同志们加油
二叉树c++源代码实现查找，删除，插入等
11-09
二叉树c++源代码实现查找，删除，插入等二叉树必须的操作。调试通过，函数中注释掉的为各模块的试验例子
C语言实现二叉树的创建、插入、删除、遍历等操作
12-14
C语言实现二叉树的创建、插入、删除、遍历（先序、中序、后续、深度优先、广度优先）、计算度为0,1,2的节点个数。 包括排序二叉树的实现
二叉树遍历（递归与迭代）
qingxili的专栏
03-15 601
二叉树遍历算法分为前序（PreOredr），中序（InOrder），后序（PostOrder）遍历。并且可以设计递归型或者迭代型算法。         本文二叉树定义为： [cpp] view plaincopyprint? struct BinaryTreeNode  {      int m_nValue;      BinaryTreeNode* m_pLeft
二叉查找树实现原理分析
weixin_34288121的博客
03-20 179
引言 二叉查找树是一种能将链表插入的灵活性和有序数组查找的高效性结合起来的一种重要的数据结构，它是我们后面学习红黑树和AVL树的基础，本文我们就先来看一下二叉查找树的实现原理。 二叉查找树的定义 二叉查找树最重要的一个特征就是：每个结点都含有一个Comparable的键及其相关联的值，该结点的键要大于左子树中所有结点的键，而小于右子树中所...
查找二叉树的操作
Ibigprogramer的博客
06-29 577
#include #include typedef int Elemtype; typedef struct TreeNode *SearchTree; typedef struct TreeNode *position; struct TreeNode { Elemtype Element; SearchTree Left; SearchTree Right; }; /*建立一颗空树*/
二叉树搜索操作 C++
yyq5033的博客
08-06 291
1. 递归、非递归插入 2. 中序遍历 3. 层次遍历 4. 查找 5. 删除  #include &lt;iostream&gt; #include &lt;queue&gt; using namespace std; struct Node{ int data; Node *parent; Node *left; Node *right; }; Node *root =...
二叉树的建立、节点查找以及节点删除C和C++实现
爱.NET
05-03 335
程序是建立一颗二叉排序树，查找节点找到了返回其父节点，失败的时候返回NULL，删除节点分为四种情况：1、左子树和右子树都为空；2、左子树为空，右子树不为空；3、左子树不为空，右子树为空；4、左子树和右子树都不为空。 C语言版本（利用结构体实现）： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int DataType;...
二叉树创建、遍历、查找--js
weixin_46147758的博客
08-01 183
二叉树数据结构–js function TreeNode(x) { this.val = x; this.left = null; this.right = null; } //使用构造函数去创建一个类 function BinarySearchTree() { // 用于创建节点的类 let Node = function (key) { this.key = key this.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值