二叉树的一种C++实现

最新推荐文章于 2024-12-08 15:55:40 发布
原创 最新推荐文章于 2024-12-08 15:55:40 发布 · 933 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #null #recursion #tree #constructor #数据结构

 

树是一种非线性的数据结构，最常用到的是树和二叉树，其中又以二叉树更为实用。

 

下面是二叉树的一个C++实现：

/*btree.h*/

#ifndef __BINARY_TREE_H__
#define __BINARY_TREE_H__

#include <assert.h>
#include <crtdbg.h>
template<typename T>
class BTNode
{
public:
	T data;
	BTNode<T> *parent;
	BTNode<T> *left;
	BTNode<T> *right;
	BTNode(
		T data = T(),
		BTNode<T> *parent = NULL,
		BTNode<T> *left = NULL,
		BTNode<T> *right = NULL
		) : data(data), parent(parent), left(left), right(right) {}
};



template<typename T>
class BTree
{
public://constructors and copying controling functions
	BTree(BTNode<T> *initroot = NULL);
	BTree(const BTree<T>& other);
	virtual ~BTree();
	BTree<T>& operator=(const BTree<T>& other);
	void Clone(const BTree<T>& other);
	void Attach(BTNode<T> *p);//node cannot be any node in this tree. 
	void Destroy();// make empty


public://utilizations

	

	T&             GetNodeData(BTNode<T> *p);
	T              GetNodeData(const BTNode<T> *p) const;
	void           SetNodeData(BTNode<T> *p, const T &data);
	BTNode<T>*&    GetRoot();
	BTNode<T>*     GetRoot() const;
	BTNode<T>*&    GetParent(BTNode<T> *p);
	BTNode<T>*     GetParent(const BTNode<T> *p) const;
	BTNode<T>*&    GetLeftChild(BTNode<T> *p);
	BTNode<T>*     GetLeftChild(const BTNode<T> *p) const;
	BTNode<T>*&    GetRightChild(BTNode<T> *p);
	BTNode<T>*     GetRightChild(const BTNode<T> *p) const;
	BTNode<T>*&    GetLeftSibling(BTNode<T> *p);
	BTNode<T>*     GetLeftSiblig(const BTNode<T> *p) const;
	BTNode<T>*&    GetRightSibling(BTNode<T> *p);
	BTNode<T>*     GetRightSibling(const BTNode<T> *p) const;
	int             IsEmpty() const;

public://public interfaces for core operation
	typedef void(* funtype)(const T&); 
	void            PreOrderTraverse(funtype Visit) const;
	void            InOrderTraverse(funtype Visit) const;
	void            PostOrderTraverse(funtype Visit) const;
	unsigned int    GetNodesCount() const; // Get how many nodes
	unsigned int    GetLeafCount() const;
	unsigned int    GetDepth() const;
	

private://private function implementing real core operations, like tranversion and recursion operations

	

	BTNode<T>* CloneSubTree(BTNode<T> *p);//clone(deeply copy) the subtree from the node pointet by p.

	void DestroySubTree(BTNode<T> *p);

	void PreOrderTraverse(const BTNode<T> *p,funtype Visit) const;

	void InOrderTraverse(const BTNode<T> *p,funtype Visit) const;

	void PostOrderTraverse(const BTNode<T> *p,funtype Visit) const;

	void GetNodesCount(const BTNode<T> *p, unsigned int *unCount) const;

	void GetLeafCount(const BTNode<T> *p, unsigned int *unCount) const;

	unsigned int    GetDepth(const BTNode<T> *p) const;

protected:
	BTNode<T> *m_pNodeRoot;
};

/*------------------------------------------------------------------------
*constructor and copying controling functions
---------------------------------------------------------------------------*/
template<typename T>
inline BTree<T>::BTree(BTNode<T> *initroot) : m_pNodeRoot(initroot)
{
}

template<typename T>
inline BTree<T>::BTree(const BTree<T>& other) : m_pNodeRoot(NULL)
{
	if (NULL != other.m_pNodeRoot)
		m_pNodeRoot = CloneSubTree(other.m_pNodeRoot);
}

template<typename T>
inline BTree<T>::~BTree()
{
	Destroy();
}

template<typename T>
inline void BTree<T>::Attach(BTNode<T> *p)
{
	ASSERT(p);
	if(m_pNodeRoot!=NULL)
	{
		Destroy();
	}
	m_pNodeRoot = p;
}

template<typename T>
inline BTree<T>& BTree<T>::operator=(const BTree<T> &p)
{
	if(this==&p)
	{
		return *this;
	}
	if(m_pNodeRoot!=NULL)
	{
		Destroy();
	}
	if (NULL != p.m_pNodeRoot)
		m_pNodeRoot = CloneSubTree(p.m_pNodeRoot);
	else
		m_pNodeRoot = NULL;
	return *this;
}

template<typename T>
inline void BTree<T>::Clone(const BTree<T> &p)
{
	/*if(this==&p)
	{
		return;
	}
	if(m_pNodeRoot!=NULL)
	{
		Destroy();
	}
	if (NULL != p.m_pNodeRoot)
		m_pNodeRoot = CloneSubTree(p.m_pNodeRoot);
	else
		m_pNodeRoot = NULL;*/
	operator=(p);
}


template<typename T>
inline void BTree<T>::Destroy()
{
	DestroySubTree(m_pNodeRoot);
	m_pNodeRoot = NULL;
}
/*------------------------------------------------------------------
*utilizations,e.g, gets and sets
---------------------------------------------------------------------*/

template<typename T>
inline BTNode<T>*& BTree<T>::GetLeftChild(BTNode<T> *p)
{
	ASSERT(p);
	return *(&(p->left));
}

template<typename T>
inline BTNode<T>* BTree<T>::GetLeftChild(const BTNode<T> *p) const
{
	ASSERT(p);
	return p->left;
}

template<typename T>
inline BTNode<T>*& BTree<T>::GetRightChild(BTNode<T> *p)
{
	ASSERT(p);
	return *(&(p->right));
}

template<typename T>
inline BTNode<T>* BTree<T>::GetRightChild(const BTNode<T> *p) const
{
	ASSERT(p);
	return p->right;
}

template<typename T>
inline BTNode<T>*& BTree<T>::GetLeftSibling(BTNode<T> *p)
{
	ASSERT(p);

	if (p->parent)
		return *(&(p->parent->left));
	else
		return *(&(p->parent)); // return NULL;
}

template<typename T>
inline BTNode<T>* BTree<T>::GetLeftSiblig(const BTNode<T> *p) const
{
	ASSERT(p);

	if (p->parent)
		return p->parent->left;
	else
		return p->parent;       // return NULL;
}

template<typename T>
inline BTNode<T>*& BTree<T>::GetRightSibling(BTNode<T> *p)
{
	ASSERT(p);

	if (p->parent)
		return *(&(p->parent->right));
	else
		return *(&(p->parent)); // return NULL;
}

template<typename T>
inline BTNode<T>* BTree<T>::GetRightSibling(const BTNode<T> *p) const
{
	ASSERT(p);

	if (p->parent)
		return p->parent->right;
	else
		return p->parent;       // return NULL;
}

template<typename T>
inline BTNode<T>*& BTree<T>::GetParent(BTNode<T> *p)
{
	ASSERT(p);
	return *(&(p->parent));
}

template<typename T>
inline BTNode<T>* BTree<T>::GetParent(const BTNode<T> *p) const
{
	ASSERT(p);
	return p->parent;
}

template<typename T>
inline T& BTree<T>::GetNodeData(BTNode<T> *p)
{
	ASSERT(p);
	return p->data;
}

template<typename T>
inline T BTree<T>::GetNodeData(const BTNode<T> *p) const
{
	ASSERT(p);
	return p->data;
}

template<typename T>
inline void BTree<T>::SetNodeData(BTNode<T> *p, const T &data)
{
	ASSERT(p);
	p->data = data;
}

template<typename T>
inline int BTree<T>::IsEmpty() const
{
	return NULL == m_pNodeRoot;
}

template<typename T>
inline BTNode<T>*& BTree<T>::GetRoot()
{
	return *(&(m_pNodeRoot));
}

template<typename T>
inline BTNode<T>* BTree<T>::GetRoot() const
{
	return m_pNodeRoot;
}


/*---------------------------------------------------------------------
*public interfaces for core operations
------------------------------------------------------------------------*/

template<typename T>
inline void BTree<T>::PreOrderTraverse(funtype Visit) const
{
	PreOrderTraverse(m_pNodeRoot, Visit);
}



template<typename T>
inline void BTree<T>::InOrderTraverse(funtype Visit) const
{
	InOrderTraverse(m_pNodeRoot, Visit);
}



template<typename T>
inline void BTree<T>::PostOrderTraverse(funtype Visit) const
{
	PostOrderTraverse(m_pNodeRoot, Visit);
}



template<typename T>
inline unsigned int BTree<T>::GetNodesCount() const
{
	unsigned int unCount;
	GetNodesCount(m_pNodeRoot, &unCount);
	return unCount;
}



template<typename T>
inline unsigned int BTree<T>::GetLeafCount() const
{
	unsigned int unCount = 0;
	GetLeafCount(m_pNodeRoot, &unCount);
	return unCount;
}



template<typename T>
inline unsigned int BTree<T>::GetDepth() const
{
	// Minus 1 here because I think the root node's depth should be 0.
	// So, don't do it if u think the root node's depth should be 1.
	return GetDepth(m_pNodeRoot) - 1;
}



/*------------------------------------------------------------------------------
*private functions: implementing recursion operations, tranversion operations and others.
---------------------------------------------------------------------------------*/

template<typename T>
inline BTNode<T>* BTree<T>::CloneSubTree(BTNode<T> *p)
{
	if (p)
	{
		BTNode<T> *pNewNode;
		try
		{
			pNewNode = new BTNode<T>;
		}
		catch(std::bad_alloc&)
		{
			return NULL;
		}
		pNewNode->data = p->data;
		pNewNode->parent = p->parent;
		pNewNode->left = CloneSubTree(p->left);
		pNewNode->right = CloneSubTree(p->right);
		return pNewNode;
	}
	else
		return NULL;
}

template<typename T>
inline void BTree<T>::DestroySubTree(BTNode<T> *p)
{
	if (p)
	{
		DestroySubTree(p->left);
		DestroySubTree(p->right);
		delete p;
	}
}

template<typename T>
inline void BTree<T>::PreOrderTraverse(const BTNode<T> *p,funtype Visit) const
{
	if (p)
	{
		Visit(p->data);
		PreOrderTraverse(p->left, Visit);
		PreOrderTraverse(p->right, Visit);
	}
}

template<typename T>
inline void BTree<T>::InOrderTraverse(const BTNode<T> *p,funtype Visit) const
{
	if (p)
	{
		InOrderTraverse(p->left, Visit);
		Visit(p->data);
		InOrderTraverse(p->right, Visit);
	}
}

template<typename T>
inline void BTree<T>::PostOrderTraverse(const BTNode<T> *p,funtype Visit) const
{
	if (p)
	{
		PostOrderTraverse(p->left, Visit);
		PostOrderTraverse(p->right, Visit);
		Visit(p->data);
	}
}


template<typename T>
inline void BTree<T>::GetNodesCount(
									const BTNode<T> *p,
									unsigned int *unCount
									) const
{
	ASSERT(unCount);

	unsigned int unLeftCount;
	unsigned int unRightCount;

	if (NULL == p)
		*unCount = 0;
	else if ((NULL == p->left) && (NULL == p->right))
		*unCount = 1;
	else
	{
		GetNodesCount(p->left, &unLeftCount);
		GetNodesCount(p->right, &unRightCount);
		*unCount = 1 + unLeftCount + unRightCount;
	}
}

template<typename T>
inline void BTree<T>::GetLeafCount(
								   const BTNode<T> *p,
								   unsigned int *unCount
								   ) const
{
	ASSERT(unCount);

	if (p)
	{
		// if the node's left & right children are both NULL, it must be a leaf
		if ((NULL == p->left) && (NULL == p->right))
			++(*unCount);
		GetLeafCount(p->left, unCount);
		GetLeafCount(p->right, unCount);
	}
}


template<typename T>
inline unsigned int BTree<T>::GetDepth(const BTNode<T> *p) const
{
	unsigned int unDepthLeft;
	unsigned int unDepthRight;

	if (p)
	{
		unDepthLeft = GetDepth(p->left);
		unDepthRight = GetDepth(p->right);
		return 1 +  // if don't plus 1 here, the tree's depth will be always 0
			(unDepthLeft > unDepthRight ? unDepthLeft : unDepthRight);
	}
	else
		return 0;
}


#endif  // __BINARY_TREE_H__


 

C++实现二叉树三种遍历方法
qq_40624616的博客
03-14 8813
文章目录前序遍历--递归中序遍历--递归后序遍历--递归 前序遍历–递归 文中的二叉树结构如下： struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode* le
二分查找法及判断一个数组中是否有两个元素之和为指定值
扬风踏浪
11-14 5364
请给出一个运行时间为O(nlgn)的算法，使之能在给定一个由n个整数构成的集合里快速判断是否存在两个元素，其和等于某一指定值key。   方法一：  思路： 1.对数组进行归并排序或快速排序，运行时间为O(nlgn)； 2.对已经排序的的数组进行遍历，并在遍历当前元素x时，在其后的序列里用binary search查找是否存在key-x,。binary search 运行时间为O(lgn
二叉树的定义与C++实现
琅嬛福地
08-01 2256
树，是有限节点的集合。生活中的树是树根在下面，数据结构中的树的根在顶部，如下图： 公司的人员组织架构，董事长，总经理，副总。。。，这种模型可以用二叉树表示，还有一些压缩算法也用到了树结构。 树的几个概念 （1）度：有几个直接的孩子，例如，A的度是3，它有BCD三个孩子，B的度是2，它有EF两个孩子，度为0的节点也就是叶子节点（终端节点） （2）祖先：E的祖先是B,A , 从当前节点一直往上找 （3）叶子节点：下面的一层称为叶子节点，也可以称为终端节点。 （...
c++ 二叉树
www_dong的博客
11-17 1319
（Binary Tree）是一种树形结构，每个节点最多有两个子节点。
C++实现树 - 02 二叉树
Newin2020的博客
05-04 6604
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
二叉树的基本操作(C++实现)
qq_52109814的博客
08-09 3万+
基本概念 二叉树由结点的有限集合构成。 这个有限集合要么是空集，要么是一个根节点及两棵互不相交、分别称为这个跟的左子树和右子树的二叉树组成的集合。 二叉树的特点 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。 左子树和右子树是有顺序的，次序不能随意颠倒。 及时树中某结点只有一颗子树，也要区分它是左子树还是右子树。 二叉树的五种基本形态 空二叉树 只有一个根节点 根节点只有左子树 根节点只有右子树 根节点既有左子树，又有右子树 相关概念 边（edge）：两个结点（node）的有序对（ord
二叉树的C++实现
最新发布
m0_64696646的博客
12-08 1342
二叉树的C++实现
C++实现二叉树及相关操作
qq_60012598的博客
04-09 702
二叉树的定义：是一种树形结构，特点是每个节点最多有两棵子树并且有左右之分二叉树的五种形态：空树，只有一个根，一个根和一个左子树，一个根和一个右子树，根和左右子树二叉树的特性：1.第i层最多有2的（i-1）次方个节点2.深度为h的二叉树最多有2的（h-1）次方个节点3.对一个完全二叉树进行顺序编号，对于编号为i的结点，i=1，为根；i%2=0说明 有该结点的父节点有一个左子树，i%2>0说明有左右子树。
C++实现二叉树的三种遍历方式
qq_45893652的博客
04-03 1427
#C++实现二叉树的三种遍历方式 这里的话，关于二叉树的遍历有许多优化的算法，还有各种适应环境，这里对于刚学习的人正适合，主要要介绍的是二叉树最常见的三种遍历。 先定义一个二叉树的结构体 #include<cstdlib> #include<iostream> using namespace std; typedef struct BiTNode{ char data;...
数据结构 - 二叉树（C++）
热门推荐
了解➔熟悉➔掌握➔精通
02-26 5万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 二叉树的定义 二叉树（BinaryTree）是n（n&gt;=0）个结点的有限集，它或者是空集（n=0），或者由一个根结点及两棵互不相交的、分别称为这个根的左子树和右子树的二叉树组成。 二叉树的性质 性质1　二叉树第i层上的...
二叉树前序遍历三种方式（c++ 实现）
h799710的博客
10-27 4559
一.递归 递归很简单，只要在调用子节点前对当前节点进行操作即可 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode *l
二叉树-基于C++实现的平衡二叉树.zip
04-26
在计算机科学中，二叉树是一种特殊的树结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树被广泛应用于数据存储、搜索算法、排序算法等多个领域。本压缩包文件“二叉树-基于C++实现的平衡...
二叉树-基于C++实现的二叉树操作.zip
04-26
二叉树是一种特殊的树结构，每个节点最多只有两个子节点，通常分为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于数据结构和算法设计中，如搜索、排序、文件系统等。C++作为一种强大的编程语言，提供了...
二叉树-基于C++实现的平衡二叉树的旋转.zip
04-26
在计算机科学中，二叉树是一种特殊的树结构，其中每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树被广泛应用于数据存储、搜索算法、排序算法等多个领域。本压缩包文件“二叉树_基于C++实现的平衡...
二叉树-基于C++实现的二叉搜索树.zip
04-26
总之，二叉搜索树是一种重要的数据结构，它在C++中的实现涉及到节点结构的设计和插入、查找、删除等操作的实现。理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模...
队列的两种C++实现
扬风踏浪
07-28 1万+
像栈一样，队列（queue）也是表。然而，使用队列时插入在一端进行而删除则在另一端进行，也就是先进先出（FIFO）。队列的基本操作是EnQueue（入队），它是在表的末端（叫做队尾（rear））插入一个元素；还有DeQueue（出队），它是删除（或返回）在表的开头（叫做队头（fr
判断链表是否有环及两链表是否相交
扬风踏浪
07-27 6931
单向链表是最常用的数据结构之一，因此总结其常见的问题及其解决方案是很有意义的。 问题1：如何判断一个单向链表是否有环？如果有，如何找到其入口节点的指针？               算法思想：用两个指针p1,p2同时指向链表的头部，p1一次移动一步，p2一次移动两步，如果最终p1
双向链表的一个C++实现
扬风踏浪
07-27 5664
下面是双向链表的一个C++实现，参考了《数据结构与算法分析C语言版》及不少牛人的分析总结，在此一并感谢了。在VC2005上经反复验证试验，结果非常不错。但可能还有不少bug，如果发现bug, 请告诉我一下。  注意：单链表及双向及循环链表均不适用表头（即哑节点，dummy nod
循环链表的一个C++实现
扬风踏浪
07-27 5038
下面是循环链表的一个C++实现，参考了《数据结构与算法分析C语言版》及不少牛人的分析总结，在此一并感谢了。在VC2005上经反复验证试验，结果非常不错。这是一个比较简易的实现，让其继承自单链表，并提供了一个专为解决约瑟夫问题的函数（RemoveAt）。以后将会开发一个更一般性的版
线索二叉树概念与C++实现解析
"这篇文档是关于数据结构课程中线索二叉树的概念及其C++实现的上课笔记，包含2020年5月12日的课程内容。文档提供了三种二叉树序列化的问题示例，并详细解释了线索二叉树的动机、存储结构以及C++实现线索二叉树的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值