二叉树是程序应用得比较多的一种结构。它可以反映物体之间的层次结构，还能通过孩子和双亲反映两物体之间某些特殊关系；排序二叉树还能帮助我们进行排序，并因此而提供快速的查找；二叉树基础上的伸展树能不断地优化我们系统的结构。并查集能很好地让我们进行分类；小根堆能帮助我们快速找到值最小的结点，它是优先队列的雏形。所有的这些都是以二叉树为基础的。
我实现的二叉树的基本功能包括前中后序的递归和非递归访问，求结点个数和叶子结点个数，还有求树高。这些是用C++类实现的。
BTree.h文件(类声明文件)
#ifndef BTREE_H
#define BTREE_H
struct BTreeNode
{
int data;
BTreeNode *lChild,*rChild;
};
class BTree
{public:
void setRoot(BTreeNode* r){ root=r;}
BTreeNode* getRoot(){ return root;}
//中序遍历(递归)
void inOrder();
//中序遍历(非递归)
void NotReInOrder();
BTreeNode* createBTree();
//前序遍历(递归)
void preOrder();
//前序遍历(非递归)
void NotRePreOrder();
//后序遍历(递归)
void postOrder();
//后序遍历(非递归)
void NotRePostOrder();
//求结点个数
int BTreeSize();
//求叶子结点个数
int BTreeLeaves();
//求树高
int BTreeHeight();
//层次法求树高
int layerHeight();
protected:
//中序遍历
void inOrder(BTreeNode*);
//前序遍历
void preOrder(BTreeNode*);
//后序遍历
void postOrder(BTreeNode*);
//结点个数
int BTreeSize(BTreeNode*);
//叶子结点
int BTreeLeaves(BTreeNode*);
//树高
int BTreeHeight(BTreeNode*);
private:
BTreeNode* root;
};
#endif
BTree.cpp(类的实现文件)
#include <iostream>
#include <stack>
#include <queue>
#include "BTree.h"
using namespace std;
//建立二叉树的算法
BTreeNode* BTree::createBTree()
{
BTreeNode* current=0;
int val=0;
cin>>val;
//-1的个数比数值的个数多1
if(val==-1)
return NULL;
else
{
current=new BTreeNode;
current->data=val;
current->lChild=createBTree();
current->rChild=createBTree();
return current;
}
}
//利用重载的方法
void BTree::inOrder()
{
inOrder(root);
cout<<endl;
}
//中序访问二叉树(递归)
void BTree::inOrder(BTreeNode* r)
{
if(r!=0) //是if，而不是while
{
inOrder(r->lChild); //递归访问
cout<<r->data<<" ";
inOrder(r->rChild); //递归访问
}
}
//中序遍历(非递归)
void BTree::NotReInOrder()
{
stack<BTreeNode*> s;
BTreeNode* r=getRoot();
while(!s.empty()||r!=0)
{
while(r!=0)
{
s.push(r);
r=r->lChild;
}
if(!s.empty())
{
r=s.top();
s.pop();
cout<<r->data<<" ";
r=r->rChild;
}
}
}
//重载形式
void BTree::preOrder()
{
preOrder(root);
cout<<endl;
}
//前序递归访问二叉树(递归)
void BTree::preOrder(BTreeNode* r)
{
if(r!=0) //是if，而不是while
{
cout<<r->data<<" ";
preOrder(r->lChild); //递归访问
preOrder(r->rChild); //递归访问
}
}
//前序遍历(非递归)
void BTree::NotRePreOrder()
{
stack<BTreeNode*> s;
BTreeNode* r=getRoot();
s.push(r);
while(!s.empty())
{
r=s.top();
s.pop();
cout<<r->data<<" ";
if(r->rChild!=0)
s.push(r->rChild);
if(r->lChild!=0)
s.push(r->lChild);
}
}
//重载形式
void BTree::postOrder()
{
postOrder(root);
cout<<endl;
}
//后序遍历(递归)
void BTree::postOrder(BTreeNode* r)
{
if(r!=0) //是if，而不是while
{
postOrder(r->lChild); //递归访问
postOrder(r->rChild); //递归访问
cout<<r->data<<" ";
}
}
//后序非递归访问要定义新的结构体类型
struct Node
{
BTreeNode* tp;
bool flag;
};
//后序遍历(非递归)
void BTree::NotRePostOrder()
{
Node node; //定义Node结构体的一个结点
stack<Node> s;
BTreeNode* r=getRoot();
while(!s.empty()||r!=0)
{
while(r!=0)
{
node.tp=r;
node.flag=0;
s.push(node);
r=r->lChild;
}
if(!s.empty())
{
node=s.top();
s.pop();
r=node.tp; //将栈顶的BTreeNode*部分赋给r
if(node.flag==1)
{
cout<<r->data<<" ";
r=0; //表示已经访问了该结点
}
else
{
node.flag=1;
s.push(node);
r=r->rChild;
}
}
}
}
//重载形式
int BTree::BTreeSize()
{
return BTreeSize(root);
}
//求二叉树结点个数的函数
int BTree::BTreeSize(BTreeNode* r)
{
//二叉树的结点个数为左右子树的高度之和再+1
if(r==0) return 0;
else
return 1+BTreeSize(r->lChild)+BTreeSize(r->rChild);
}
//重载形式
int BTree::BTreeLeaves()
{
return BTreeLeaves(root);
}
//求二叉树叶子结点个数的函数
int BTree::BTreeLeaves(BTreeNode* r)
{
//当为空时，返回0；当找到叶子时返回1
if(r==0) return 0;
else
if(r->lChild==0&&r->rChild==0)
return 1;
else
return BTreeLeaves(r->lChild)+BTreeLeaves(r->rChild);
}
//重载形式
int BTree::BTreeHeight()
{
return BTreeHeight(root);
}
//求二叉树高度的函数
int BTree::BTreeHeight(BTreeNode* r)
{
if(r==0) return 0;
else
{
//二叉树的高度为左右子树的最大者+1
int lHei=BTreeHeight(r->lChild);
int rHei=BTreeHeight(r->rChild);
return (lHei>rHei) ? lHei+1:rHei+1;
}
}
//层次遍历求树高需要利用的新结构
struct LayerBTreeNode
{
BTreeNode* ptr;
int height;
};
//层次遍历求高度
int BTree::layerHeight()
{
queue<LayerBTreeNode> que;
LayerBTreeNode temp,lTemp,rTemp; //牺牲空间来获得算法的清晰度
BTreeNode* r=getRoot();
int hei=1;
temp.ptr=r;
temp.height=1;
que.push(temp); //先将根对应的LayerBTreeNode对象进队
//不为空时
while(!que.empty())
{
//BTreeNode* btreePtr=0;
temp=que.front(); //取出队首元素
que.pop();
r=temp.ptr;
//用当前的高度跟取出的队首进行比较
if(hei<temp.height)
hei=temp.height;
if(r->lChild!=0||r->rChild!=0)
{
//如果它的左右子树不为空，则进队列
if(r->lChild!=0)
{
lTemp.ptr=r->lChild;
lTemp.height=temp.height+1; //在原来高度基础上加1,再入队列
que.push(lTemp);
}
if(r->rChild!=0)
{
rTemp.ptr=r->rChild;
rTemp.height=temp.height+1;
que.push(rTemp);
}
}
}
return hei;
}