二叉树的创建与相关操作
1、二叉树:是每个节点最多有两个子树的树结构。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。
如图:
2、二叉树的每个结点至多只有二棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒。
3、二叉树的第i层至多有2^(i-1)个结点;深度为k的二叉树至多有2^k-1个结点;对任何一棵二叉树T,如果其终端结点数为n0,度为2的结点数为n2,则n0=n2+1。
4、一棵深度为k,且有2^k-1个节点称之为满二叉树(如上图);深度为k,有n个节点的二叉树,当且仅当其每一个节点都与深度为k的满二叉树中,序号为1至n的节点对应时,称之为完全二叉树。
如下图:
一、创建二叉树
假设我们要创建一个二叉树:
对应数组为:char array[] = "abc##d##ef##g";
这是因为以下程序中设置无效值为‘#’,在递归的过程中,遇到无效值则置为NULL。
代码如下:
// 根+左子树+右子树
PNode _CreateBinTree(const T* array, size_t size, size_t& index, const T& invalid)
{
if (NULL == array)
return 0;
PNode root = NULL;
if (index < size && array[index] != invalid)
{
root = new Node(array[index]);
root->_left = _CreateBinTree( array, size, ++index, invalid);
root->_right = _CreateBinTree( array, size, ++index, invalid);
}
return root;
}
二、前中后遍历二叉树
前序遍历:首先访问根,再遍历左子树,最后遍历右子树
// 根--->根的左子树---->根的右子树
void _PreOrder(PNode& pRoot)
{
if (pRoot == NULL)
return;
cout << pRoot->_data << " ";
_PreOrder(pRoot->_left);
_PreOrder(pRoot->_right);
}
中序遍历:首先遍历左子树,再访问根,最后遍历右子树。
// 左子树--->根节点--->右子树
void _InOrder(PNode pRoot)
{
//pNode pCur = pRoot;
if (pRoot == NULL)
return;
_InOrder(pRoot->_left);
cout << pRoot->_data << " ";
_InOrder(pRoot->_right);
}
后序遍历:首先遍历左子树,再遍历右子树,最后访问根。
// 左子树--->右子树--->根节点
void _PostOrder(PNode pRoot)
{
if (pRoot == NULL)
return;
_PostOrder(pRoot->_left);
_PostOrder(pRoot->_right);
cout << pRoot->_data << " ";
}
三、层序遍历二叉树
按照层次访问,访问根,访问子女,再访问子女的子女。
这里递归很难实现,我们利用了队列的特性,创建一个队列,先将根节点入队,将队头的数据打印并出队,再看左右节点,如果左节点不为空,将左节点入队,如果右节点不为空,将右节点入队。
代码如下:
void _LeverOrder(PNode pRoot)
{
if (NULL == pRoot)
return;
queue<PNode> q;
q.push(pRoot);
while (!q.empty())
{
PNode front = q.front();
cout << front->_data << " ";
q.pop();
if (front->_left)
q.push(front->_left);
if (front->_right)
q.push(front->_right);
}
}
四、求二叉树的高度
先求出左子树的高度,和右子树比较。
size_t _Height(PNode pRoot)
{
if (NULL == pRoot)
return 0;
return 1+(_Height(pRoot->_left) > _Height(pRoot->_right)?_Height(pRoot->_left): _Height(pRoot->_right));
}
五、求二叉树中节点的个数
size_t _Size(PNode pRoot)
{
if (NULL == pRoot)
return 0;
return _Size(pRoot->_left) + _Size(pRoot->_right) + 1;
}
六、求叶子节点的个数
size_t _GetLeafCount(PNode pRoot)
{
if (NULL == pRoot)
return 0;
if (pRoot->_left == NULL&&pRoot->_right == NULL)
return 1;
return _GetLeafCount(pRoot->_left) + _GetLeafCount(pRoot->_right);
}
七、求二叉树中第k层节点的个数
size_t _GetKLevelCount(PNode pRoot, int K)
{
if (NULL == pRoot || K < 1)
return 0;
if (K == 1)
return 1;
int leftLevel = _GetKLevelCount(pRoot->_left, K - 1);
int rightLevel = _GetKLevelCount(pRoot->_right, K - 1);
return leftLevel + rightLevel;
}
八、求一个节点的双亲节点,及左、右孩子节点。
PNode _Parent(PNode pRoot, PNode pNode)
{
if (pNode == pRoot->_left || pNode == pRoot->_right)
return pRoot;
if (pRoot->_left)
{
_Parent(pRoot->_left, pNode);
}
if (pRoot->_right)
{
_Parent(pRoot->_right, pNode);
}
return pRoot;
}
PNode LeftChild(PNode pNode)
{
if (NULL == pNode)
return NULL;
return pNode->_left;
}
PNode RightChild(PNode pNode)
{
if (NULL == pNode)
return NULL;
return pNode->_right;
}
还有一些辅助函数,比如寻找某一元素所在节点。
整体代码如下:
#include<iostream>
using namespace std;
#include<queue>
#include<string.h>
template<class T>
struct TreeNode
{
T _data;
TreeNode *_left;
TreeNode *_right;
TreeNode(const T& data)
:_data(data)
, _left(NULL)
, _right(NULL)
{}
};
template<class T>
class BinTree
{
typedef TreeNode<T> Node;
typedef TreeNode<T> *PNode;
public:
BinTree()
: _pRoot(NULL)
{}
BinTree(const T* array, size_t size, const T& invalid)
{
size_t index = 0;
_pRoot = _CreateBinTree(array, size, index, invalid);
}
BinTree(const BinTree& bt)
{
_pRoot = _CopyBinTree(bt._pRoot);
}
BinTree& operator=(const BinTree& bt)
{
if (this == bt)
return;
_DestroyBinTree(_pRoot);
_pRoot = new Node(bt->_data);
_pRoot->_left = bt->_left;
_pRoot->_right = bt->_right;
}
~BinTree()
{
_DestroyBinTree(_pRoot);
}
void PreOrder()
{
_PreOrder(_pRoot);
cout << endl;
}
void InOrder()
{
_InOrder(_pRoot);
cout << endl;
}
void PostOrder()
{
_PostOrder(_pRoot);
cout << endl;
}
void LevelOrder()
{
_LeverOrder(_pRoot);
cout << endl;
}
size_t Size()
{
return _Size(_pRoot);
}
size_t GetLeafCount()
{
return _GetLeafCount(_pRoot);
}
// 获取第K层结点的个数
size_t GetKLevelCount(size_t K)
{
return _GetKLevelCount(_pRoot, K);
}
size_t Height()
{
return _Height(_pRoot);
}
PNode Find(const T& data)
{
return _Find(_pRoot, data);
}
PNode Parent(PNode pNode)
{
return _Parent(_pRoot, pNode);
}
PNode LeftChild(PNode pNode)
{
if (NULL == pNode)
return NULL;
return pNode->_left;
}
PNode RightChild(PNode pNode)
{
if (NULL == pNode)
return NULL;
return pNode->_right;
}
private:
// 根+左子树+右子树
PNode _CreateBinTree(const T* array, size_t size, size_t& index, const T& invalid)
{
if (NULL == array)
return 0;
PNode root = NULL;
if (index < size && array[index] != invalid)
{
root = new Node(array[index]);
root->_left = _CreateBinTree( array, size, ++index, invalid);
root->_right = _CreateBinTree( array, size, ++index, invalid);
}
return root;
}
PNode _CopyBinTree(PNode pRoot)
{
if (this == pRoot)
return;
if (pRoot)
{
_pRoot = new Node(pRoot->_data);
_pRoot->_left = _CopyBinTree(pRoot->_left);
_pRoot->_right = _CopyBinTree(pRoot->_right);
}
return *this;
}
void _DestroyBinTree(PNode pRoot)
{
if (NULL == pRoot)
return;
if (pRoot)
{
_Destroy(pRoot->_left);
_Destroy(pRoot->_right);
delete pRoot;
pRoot = NULL;
}
}
// 根--->根的左子树---->根的右子树
void _PreOrder(PNode& pRoot)
{
if (pRoot == NULL)
return;
cout << pRoot->_data << " ";
_PreOrder(pRoot->_left);
_PreOrder(pRoot->_right);
}
// 左子树--->根节点--->右子树
void _InOrder(PNode pRoot)
{
//pNode pCur = pRoot;
if (pRoot == NULL)
return;
_InOrder(pRoot->_left);
cout << pRoot->_data << " ";
_InOrder(pRoot->_right);
}
// 左子树--->右子树--->根节点
void _PostOrder(PNode pRoot)
{
if (pRoot == NULL)
return;
_PostOrder(pRoot->_left);
_PostOrder(pRoot->_right);
cout << pRoot->_data << " ";
}
//层次遍历
void _LeverOrder(PNode pRoot)
{
if (NULL == pRoot)
return;
queue<PNode> q;
q.push(pRoot);
while (!q.empty())
{
PNode front = q.front();
cout << front->_data << " ";
q.pop();
if (front->_left)
q.push(front->_left);
if (front->_right)
q.push(front->_right);
}
}
size_t _Size(PNode pRoot)
{
if (NULL == pRoot)
return 0;
return _Size(pRoot->_left) + _Size(pRoot->_right) + 1;
}
size_t _GetLeafCount(PNode pRoot)
{
if (NULL == pRoot)
return 0;
if (pRoot->_left == NULL&&pRoot->_right == NULL)
return 1;
return _GetLeafCount(pRoot->_left) + _GetLeafCount(pRoot->_right);
}
size_t _Height(PNode pRoot)
{
if (NULL == pRoot)
return 0;
return 1+(_Height(pRoot->_left) > _Height(pRoot->_right)?_Height(pRoot->_left): _Height(pRoot->_right));
}
PNode _Find(PNode pRoot, const T& data)
{
if (data == pRoot->_data)
return pRoot;
if (pRoot->_left)
{
_Find(pRoot->_left, data);
}
if (pRoot->_right)
{
_Find(pRoot->_right, data);
}
}
PNode _Parent(PNode pRoot, PNode pNode)
{
if (pNode == pRoot->_left || pNode == pRoot->_right)
return pRoot;
if (pRoot->_left)
{
_Parent(pRoot->_left, pNode);
}
if (pRoot->_right)
{
_Parent(pRoot->_right, pNode);
}
return pRoot;
}
size_t _GetKLevelCount(PNode pRoot, int K)
{
if (NULL == pRoot || K < 1)
return 0;
if (K == 1)
return 1;
int leftLevel = _GetKLevelCount(pRoot->_left, K - 1);
int rightLevel = _GetKLevelCount(pRoot->_right, K - 1);
return leftLevel + rightLevel;
}
private:
PNode _pRoot;
};
测试,传文章开头所示的数组,如下:
int main()
{
char array[] = "abc##d##ef##g";
BinTree<char> bt(array,strlen(array),'#');
cout << bt.GetKLevelCount(2) << endl;
cout << bt.GetLeafCount() << endl;
cout << bt.Height() << endl;
bt.PreOrder();
bt.InOrder();
bt.PostOrder();
bt.LevelOrder();
cout << bt.LeftChild(bt.Find('a'))->_data << endl;
cout << bt.RightChild(bt.Find('a'))->_data << endl;
cout << bt.Parent(bt.Find('b'))->_data << endl;
cout << bt.Size() << endl;
system("pause");
return 0;
}
结果如下:
我们来比对看一下结果,正确。