一、二叉树定义
在计算机科学中,树是一种重要的非线性数据结构,直观地看,它是数据元素(在树中称为节点)按分支关系组织起来的结构。二叉树(Binary Tree)是每个节点最多有两个子树的有序树。通常子树被称作"左子树"(left subtree)和"右子树"(right subtree)。二叉树常被用于实现二叉查找树和二叉堆。值得注意的是,二叉树不是树的特殊情形。在图论中,二叉树是一个连通的无环图,并且每一个顶点的度不大于3。有根二叉树还要满足根节点的度不大于2。有了根节点后,每个顶点定义了唯一的根节点,和最多2个子节点。然而,没有足够的信息来区分左节点和右节点。
(1)二叉树的存储结构
二叉树常用链式存储。如下图;
最常用的是图a的二叉链表法。
(2)几种遍历
1.前序遍历(根左右)
递归定义;
1、访问根节点
2、前序遍历根节点的左子树
3、前序遍历根节点的右子树
2.中序遍历(左根右)
递归定义;
1、中序遍历根节点的左孩子
2、访问根节点
3、中序遍历根节点的右孩子
3.后序遍历(左右根)
递归定义;
1、后序遍历根节点的左子树
2、后序遍历根节点的右子树
3、访问根节点
4.层次遍历
对整棵二叉树按从上到下,对每一层按从左到右的顺序进行遍历。这里我们需要借助队列:先访问节点的孩子节点也应比后访问节点的孩子节点先访问。故这就类似于队列先进先出的性质,每访问一个节点时,它的孩子节点(如果存在)就随着入队。
(3)代码实现
下面的代码中我们提供了如下操作:
1、查找 find(),获取父节点 parent(),左孩子 lchild(),右孩子 rchild()。
2、各种遍历:前序、中序、后序、层次。
3、获取树的高度,节点总数。
代码说明
1、在代码中我们用到了STL中的栈和队列,因为具体的算法实现,需要用到它们。
如过看过栈的实现:顺序栈以及队列的实现:顺序队列,对栈和队列的常用操作应该不会陌生。
2、由于普通二叉树的插入、删除,并无规定操作。故把这些操作留到下一篇二叉搜索树中去实现。
代码有点长,有些代码被重复使用了,其中使用队列的层次遍历、查找父节点、左孩子、右孩子是重要的。
3、有些算法的实现确实比较复杂。
一些讲解附在代码后,可以针对解释再仔细看代码,并且针对各种遍历的非递归的实现也附在最后。
代码
类定义:
#include<iostream>
#include<iomanip>
#include<stack>
#include<queue>
using namespace std;
typedef int ElemType;
//二叉树节点
class BTNode //Binary Tree Node
{
public:
ElemType data;
BTNode* lchild; //左孩子
BTNode* rchild; //右孩子
BTNode(ElemType d, BTNode* left=NULL, BTNode* right=NULL)
:data(d), lchild(left), rchild(right){}
};
//二叉树
class BinaryTree
{
private:
//根节点指针
BTNode* Root;
//节点个数
int size;
public:
//构造函数
BinaryTree();
BTNode* buildTree();
//析构函数
~BinaryTree();
//求树的高度
int height();
//获取节点个数
int getSize()
{return size;}
void getHeight(BTNode*, int, int&);
//指定遍历方式
void traverse();
//前序遍历
void preOrderWithoutRecursion();
void preOrder();
void preorder(BTNode*);
//中序遍历
void inOrderWithoutRecursion();
void inOrder();
void inorder(BTNode*);
//后序遍历
void postOrderWithoutRecursion();
void postOrder();
void postorder(BTNode*);
//层次遍历
void levelOrder();
//判断树是否为空
bool empty()
{return Root == NULL;}
//获取根节点
BTNode* root()
{return Root;}
//查找指定节点
bool find(ElemType);
//获取父节点
BTNode* parent(ElemType);
//获取左孩子
BTNode* lchild(ElemType);
//获取右孩子
BTNode* rchild(ElemType);
};
类实现:
//构造函数
BinaryTree::BinaryTree()
{
size = 0;
cout << "输入根节点 ";
Root = buildTree();
}
BTNode* BinaryTree::buildTree()
{
ElemType data;
BTNode* p = NULL;
cin >> data;
//输入0结束
if (data == 0)
return p;
else
{
p = new BTNode(data);
size++;
if (!p)
{
cerr << "内存分配失败!" << endl;
exit(0);
}
else
{
cout << "请输入 " << data << " 节点的左孩子 ";
p->lchild = buildTree();
cout << "请输入 " << data << " 节点的右孩子 ";
p->rchild = buildTree();
}
}
return p;
}
//析构函数
BinaryTree::~BinaryTree()
{
queue<BTNode*> q;
q.push(Root);
BTNode* p = NULL;
while (!q.empty())
{
p = q.front();
q.pop();
//左孩子不为空,则左孩子入队
if (p->lchild)
q.push(p->lchild);
//右孩子不为空,则右孩子入队
if (p->rchild)
q.push(p->rchild);
//释放内存
delete p;
}
}
//求树的高度
int BinaryTree::height()
{
if (empty())
return 0;
int h = 0;
getHeight(Root, 0, h);
return h;
}
void BinaryTree::getHeight(BTNode* p, int level, int &h)
{
if (p)
{
if (level > h)
h = level;
getHeight(p->lchild, level + 1, h);
getHeight(p->rchild, level + 1, h);
}
}
//指定遍历方式
void BinaryTree::traverse()
{
int choice;
cout << "输入遍历方式:0(前序)、1(中序)、2(后序)、3(层次):";
cin >> choice;
while (choice < 0 || choice > 3)
{
cout << "输的不对!请重新输入: ";
cin >> choice;
}
switch(choice)
{
case 0:preOrder(); break;
case 1:inOrder(); break;
case 2:postOrder();break;
case 3:levelOrder(); break;
}
}
//前序遍历:根->左->右
void BinaryTree::preOrder()
{
BTNode* pnode = Root;
preorder(pnode);
cout << endl;
}
void BinaryTree::preorder(BTNode* p)
{
if (p)
{
cout << setw(4) << p->data;
preorder(p->lchild);
preorder(p->rchild);
}
}
//中序遍历:左->根->右
void BinaryTree::inOrder()
{
BTNode* pnode = Root;
inorder(pnode);
cout << endl;
}
void BinaryTree::inorder(BTNode* p)
{
if (p)
{
inorder(p->lchild);
cout << setw(4) << p->data;
inorder(p->rchild);
}
}
//后序遍历:左->右->根
void BinaryTree::postOrder()
{
BTNode* pnode = Root;
postorder(pnode);
cout << endl;
}
void BinaryTree::postorder(BTNode* p)
{
if (p)
{
postorder(p->lchild);
postorder(p->rchild);
cout << setw(4) << p->data;
}
}
//层次遍历
void BinaryTree::levelOrder()
{
//使用STL中的队列
queue<BTNode*> q;
//根节点入队
q.push(Root);
BTNode* p = NULL;
while (!q.empty())
{
p = q.front();
//打印
cout << setw(4) << p->data;
q.pop();
//左孩子不为空,则左孩子入队
if (p->lchild)
q.push(p->lchild);
//右孩子不为空,则右孩子入队
if (p->rchild)
q.push(p->rchild);
}
cout << endl;
}
//查找指定节点
bool BinaryTree::find(ElemType data)
{
if (!empty())
{
//按层次遍历查找
queue<BTNode*> q;
q.push(Root);
BTNode* p = NULL;
while (!q.empty())
{
p = q.front();
//比较
if(p->data==data)
return true;
q.pop();
if (p->lchild)
q.push(p->lchild);
if (p->rchild)
q.push(p->rchild);
}
}
//在树空和不存在该节点的情况下,都返回false
return false;
}
//获取父节点
BTNode* BinaryTree::parent(ElemType data)
{
if (!empty())
{
//根节点的父节点为空
if (Root->data == data)
return NULL;
stack<BTNode*> s;
BTNode* p = Root;
while (!s.empty() || p)
{
if (p)
{
if ((p->lchild && p->lchild->data == data) || (p->rchild && p->rchild->data == data))
return p;
s.push(p);
p = p->lchild;
}
else
{//左子树访问完后,访问右子树
p = s.top();
s.pop();
p = p->rchild;
}
}
}
return NULL;
}
//获取左孩子
BTNode* BinaryTree::lchild(ElemType data)
{
if (!empty())
{
//按层次遍历查找
queue<BTNode*> q;
q.push(Root);
BTNode* p = NULL;
while (!q.empty())
{
p = q.front();
//比较
if (p->data == data)
return p->lchild;
q.pop();
if (p->lchild)
q.push(p->lchild);
if (p->rchild)
q.push(p->rchild);
}
}
//在树空和不存在该节点的情况下,都返回NULL
return NULL;
}
//获取右孩子
BTNode* BinaryTree::rchild(ElemType data)
{
if (!empty())
{
//按层次遍历查找
queue<BTNode*> q;
q.push(Root);
BTNode* p = NULL;
while (!q.empty())
{
p = q.front();
//比较
if (p->data == data)
return p->rchild;
q.pop();
if (p->lchild)
q.push(p->lchild);
if (p->rchild)
q.push(p->rchild);
}
}
//在树空和不存在该节点的情况下,都返回NULL
return NULL;
}
主函数:
int main()
{
cout << "******二叉树******" << endl;
BinaryTree tree;
cout << "树的高度是 " << tree.height() << endl;
cout << "树中共有节点个数 " << tree.getSize() << endl;
tree.traverse();
ElemType data = 2;
cout << "对节点 " << data << " 进行查询" << endl;
cout << "存在于树中吗?";
tree.find(data) ? cout << "Yes!" <<endl: cout << "No!" << endl;
BTNode* p = NULL;
p = tree.parent(data);
p ? cout << "父节点是 " << p->data << endl : cout << data << "是根节点,故并无父节点" << endl;
p = tree.lchild(data);
p ? cout << "左孩子是 " << p->data << endl : cout << "无左孩子!" << endl;
p = tree.rchild(data);
p ? cout << "右孩子是 " << p->data << endl : cout << "无右孩子!" << endl;
system("pause");
return 0;
}
运行
一些算法的解释
上述方法的实现基本上是两两组合:一个对外调用,另一个才是具体实现。有些比较复杂,涉及到递归,要想彻底弄清算法原理,得明白递归过程。
1.构造函数
构造函数的这种建树写法值得注意:buildTree()可是递归的。
2.析构函数
按层次遍历的过程来释放节点空间,关于层次遍历过程的理解可先看层次遍历的解释。当然,也可按其它的遍历形式来释放空间。
3.求树高度
对外调用是int height(),具体实现是void getHeight(BTNode* p,int level,int& h)特别注意:第三个参数是引用类型。
一个示例图如下:
4.前、中、后序遍历的递归写法,比较简单,只要明白递归的过程,就很容易理解。难点在于它的非递归写法,若是能毫不费力地写出非递归形式,说明真的是对递归清楚掌握。
5.查找指定数据域的节点
查找时,按层次遍历的方式进行。若是有多个节点数据域符合,则查找最上层、最左边的。
6.获取父节点
本质上也是一种查找。仔细看代码,会发现它的查找过程其实是中序遍历的。结合下面的中序遍历的非递归写法,你会明白的。
7.获取指定数据域的孩子节点
它的查找用的也是层次遍历。当然不排除可用其它的遍历方法。
小结:对树的操作,基本上都是在遍历的基础上完成的。掌握各种遍历方式,也就是重中之重。
二、遍历算法的非递归实现
前序遍历非递归实现:
//前序遍历非递归算法
void BinaryTree::preOrderWithoutRecursion()
{
if (!empty())
{
stack<BTNode*> s;
BTNode* p = Root;
s.push(p);
while (!s.empty())
{
cout << setw(4) << p->data;
if (p->rchild)
s.push(p->rchild);
if (p->lchild)
p = p->lchild;
else
{//左子树访问完了,访问右子树
p = s.top();
s.pop();
}
}
cout << endl;
}
}
中序遍历非递归实现:
//中序遍历的非递归实现
void BinaryTree::inOrderWithoutRecursion()
{
if (!empty())
{
stack<BTNode*> s;
BTNode* p = Root;
while (!s.empty() || p)
{
if (p)
{//一直下降到最左边
s.push(p);
p = p->lchild;
}
else
{
p = s.top();
s.pop();
cout << setw(4) << p->data;
p = p->rchild;
}
}
cout << endl;
}
}
后序遍历非递归实现:
//后序遍历的非递归实现
void BinaryTree::postOrderWithoutRecursion()
{
if (!empty())
{
stack<BTNode*> s;
BTNode* p = Root;
while (p != NULL)//遍历到左边最下边
{
s.push(p);
p = p->lchild;
}
while (!s.empty())
{
BTNode* pLastVisit = p; //判断当前该访问左节点还是右节点
p = s.top();
s.pop();
if (p->rchild == NULL || p->rchild == pLastVisit)
cout << setw(4) << p->data;
else if (p->lchild == pLastVisit)
{
s.push(p);
p = p->rchild;
s.push(p);
while (p != NULL)
{
if (p->lchild != NULL)
{
s.push(p->lchild);
}
p = p->lchild;
}
}
}
cout << endl;
}
}
首先恭喜您,能够认真的阅读到这里,如果对部分理解不太明白,建议先将文章收藏起来,然后对不清楚的知识点进行查阅,然后在进行阅读,相应你会有更深的认知。如果您喜欢这篇文章,就点个赞或者【关注我】吧!!