顺序存储结构
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。
完全二叉树和满二叉树中结点的序号可以唯一地反映出结点之间的逻辑关系。
一棵二叉树改造后成完全二叉树形态，需增加很多空结点，造成存储空间的浪费。
二叉树的顺序存储结构一般仅存储完全二叉树。
二叉链表
基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。
template<class T>
struct BiNode {
T data;
BiNode<T> *lchild, *rchild;
};具有n个结点的二叉链表中，有n+1个空指针。
二叉链表存储结构的类声明
template<class T>
class BiTree {
public:
BiTree();
~BiTree( );
void PreOrder(){PreOrder(root);}
void InOrder() {InOrder(root);}
void PostOrder() {PostOrder(root);}
void LevelOrder(){LeverOrder(root)};
private:
BiNode<T> *root;
BiNode<T> * Creat( );
void Release(BiNode<T> *root);
void PreOrder(BiNode<T> *root);
void InOrder(BiNode<T> *root);
void PostOrder(BiNode<T> *root);
void LevelOrder(BiNode<T> *root);
};前序遍历——递归算法
template<class T>
void BiTree::PreOrder(BiNode<T> *root)
{
if(root ==NULL)
return;
else{
cout<<root->data;
PreOrder(root->lchild);
PreOrder(root->rchild);
}
}前序遍历——非递归算法
二叉树前序遍历的非递归算法的关键：在前序遍历过某结点的整个左子树后，如何找到该结点的右子树的根指针。
解决办法：在访问完该结点后，将该结点的指针保存在栈中，以便以后能通过它找到该结点的右子树。
栈是实现递归的最常用的结构。
思想：遇到一个结点，就访问该结点，并把此结点推入栈中，然后遍历它的左子树； 遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。
前序遍历——非递归算法（伪代码）
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空
2.1 当root不空时循环
2.1.1 输出root->data;
2.1.2 将指针root的值保存到栈中；
2.1.3 继续遍历root的左子树（root=root->lchild）
2.2 如果栈s不空，则
2.2.1 将栈顶元素弹出至root（root=s.pop()）；
2.2.2 准备遍历root的右子树(root=root->rchild)；
template<class T>
void BiTree::PreOrder(BiNode<T> *root) {
SeqStack<BiNode<T> *> s;
while (root!=NULL | | !s.empty()) {
while (root!= NULL) {
cout<<root->data;
s.push（root）;
root=root->lchild;
}
if (!s.empty()) {
root=s.pop();
root=root->rchild;
}
}
}二叉树的建立
为了建立一棵二叉树，将二叉树中每个结点的空指针引出一个虚结点，其值为一特定值如“#”，以标识其为空，把这样处理后的二叉树称为原二叉树的扩展二叉树。
设二叉树中的结点均为一个字符。假设扩展二叉树的前序遍历序列由键盘输入，root为指向根结点的指针，二叉链表的建立过程是：
1、按扩展前序遍历序列输入结点的值
2、如果输入结点值为“#”,则建立一棵空的子树
3、否则，根结点申请空间，将输入值写入数据域中，
4、以相同方法的创建根结点的左子树
5、以相同的方法创建根结点的右子树
template<class T>
BiTree ::BiTree(){
root=creat()；
}
template<class T>
BiNode<T> * BiTree ::Creat(){
BiNode<T> *root;
char ch;
cin>>ch;
if(ch=='#')
root=NULL;
else{
root=new BiNode<T>;
root->data=ch;
root->lchild=creat();
root->rchild=creat();
}
return root
}template<class T>
BiTree<T>::BiTree( )
{
Creat(root);
}
template<class T>
void BiTree<T>::Creat(BiNode<T> * &root)
{
T ch;
cout<<"请输入创建一棵二叉树的结点数据"<<endl;
cin>>ch;
if(ch=="#")
root = NULL;
else{
root = new BiNode<T>;
root->data=ch;
Creat(root->lchild );
Creat(root->rchild);
}
}中序遍历——递归算法
template<class T>
void BiTree::InOrder(BiNode<T> *root)
{
if(root==NULL)
return;
else{
InOrder(root->lchild);
cout<<root->data;
InOrder(root->rchild);
}
}非递归中序遍历二叉树
思想：遇到一个结点，就把它推入栈中，并去遍历它的左子树，遍历完左子树后，从栈顶托出这个结点并访问之，然后按照它的右链接指示的地址再去遍历该结点的右子树。
中序遍历——非递归算法（伪代码）
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空
2.1 当root不空时循环
2.1.1 将指针root的值保存到栈中；
2.1.2 继续遍历root的左子树（root=root->lchild）
2.2 如果栈s不空，则
2.2.1 将栈顶元素弹出至root（root=s.pop()）；
2.2.2 输出root->data;
2.2.3 准备遍历root的右子树(root=root->rchild)；
template<class T>
void BiTree::InOrderwithoutD (BiNode<T> *root)
{
stack< BiNode<T> * > aStack;
while(!aStack.empty()||root){
while(root){
aStack.push(root);
root=root->lchild;
}
if(!aStack.empty()){
root=aStack.top();
aStack.pop();
cout<<root->data;
root=root->rchild;
}
}
} 后序遍历——递归算法
template<class T>
void BiTree::PostOrder(BiNode<T> *root)
{
if(root==NULL)
return;
else{
PostOrder(root->lchild);
PostOrder(root->rchild);
cout<<root->data;
}
}非递归后序遍历二叉树
思想: 遇到一个结点，把它推入栈中，遍历它的左子树，左子树遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树，遍历完右子树后才能从栈顶托出该结点并访问。
解决方案：需要给栈中的每个元素加上一个特征位，以便当从栈顶弹出一个结点时区别是从栈顶元素左边回来的(则要继续遍历右子树)，还是从右边回来的(该结点的左、右子树均已遍历) 。特征为Left表示已进入该结点的左子树，将从左边回来；特征为Right表示已进入该结点的右子树，将从右边回来。
算法分析
1、定义一个栈；从根节点出发开始遍历，p=root，如果，root==NULL, 不进行遍历；
2、无条件进行下面的工作
①如果指针不空，指针打上left标记，并将指针进栈，执行②;否则，执行③
②p=p->lchild,重复①
③栈顶元素出栈p
④查看P的标志，如果标志为right,进行下面的工作，否则，执行⑤
a)访问当前节点p
b)如果栈空 ，算法结束；
c)否则，栈顶元素出栈，转④
⑤修改p的标志，让p重新入栈，p=p->rchild,执行②
栈中的元素类型定义StackElement
enum Tags{Left,Right};
template<class T>
class StackElement
{
public:
BiTreeNode<T>* pointer;
Tags tag;
}; #include<stack>
Using namespace std;
template<class T>
void BiTree<T>::PostOrderWithoutRecusion(BiTreeNode<T>* root){
StackElement<T> element;
stack<StackElement<T>> aStack;
BiTreeNode<T>* pointer;
if(root==NULL)
return;
else
pointer=root;
while(true){
while(pointer!=NULL){
element.pointer=pointer;
element.tag=Left;
aStack.push(element);
pointer=pointer->lchild;
}
element=aStack.pop();
pointer=element.pointer;
while(element.tag==Right){
cout<<pointer->data;
if(aStack.empty())
return;
else{
element=aStack.pop();
pointer=element.pointer;
}
}
element.tag=Right;
aStack.push(element);
pointer=pointer->rchild();
}
}二叉树的非递归遍历总结
都是沿着左分支访问，直到左分支为空时，再依次对栈中节点的右分支进行处理。（遵循从左至右的遍历原则，体现深度优先搜索的思想）
前序遍历：每个节点只进栈一次，在进栈前访问节点。
中序遍历：每个节点进栈一次，在出栈时访问节点。
后序遍历：每个节点进栈两次，在第二次出栈时访问节点。
非递归的后序遍历算法2
需要用栈实现，根据后续遍历的要求及栈操作的特点（FILO），依次将 根结点、根结点的右儿子、根节点的左儿子入栈（不访问），当结点出栈时再进行访问。当栈顶出现叶子结点时，直接进行出栈操作，当刚出栈元素和栈顶元素之间关系是“儿子-双亲”关系时，进行出栈操作。
void tree::T_print(bnode *bt){
stack<bnode*> s;
bnode *cur， *pre=NULL;
if (root==NULL)
return;
s.push(bt);
while (!s.empty()){
cur=s.top();
if((cur->Lchild==NULL&&cur->Rchild==NULL)||(pre!=NULL&&(pre==cur->Lchild||pre==cur->Rchild)))
{
cout<<cur->data;
s.pop();
pre=cur;
}
else
{
if(cur->Rchild!=NULL)
s.push(cur->Rchild);
if(cur->Lchild!=NULL)
s.push(cur->Lchild);
}
}
}层序遍历
1.队列Q初始化；
2. 如果二叉树非空，将根指针入队；
3. 循环直到队列Q为空
3.1 q=队列Q的队头元素出队；
3.2 访问结点q的数据域；
3.3 若结点q存在左孩子，则将左孩子指针入队；
3.4 若结点q存在右孩子，则将右孩子指针入队；
#include<queue>
using namespace std;
template<class T>
void BiTree<T>::LevelOrder(BinaryTreeNode<T>* root){
queue<BiTreeNode<T>*> aQueue;
if(root)
aQueue.push(root);
while(!aQueue.empty())
{
root=aQueue.front();
aQueue.pop();
cout<<pointer->data;
if(root->lchild)
aQueue.push(root->lchild);
if(root->rchild)
aQueue.push(root->rchild);
}
}二叉树的析构
template<class T>
void BiTree<T>::Release(BiNode<T>* root){
if(root != NULL){
Release(root->lchild);
Release(root->rchild);
delete root;
}
}
template<class T>
BiTree<T>::~BiTree(void)
{
Release(root);
}三叉链表
在二叉链表的基础上增加了一个指向双亲的指针域。
三叉链表的实现
结点数据类型声明：
template<class T>
struct Node
{
T data;
Node<T> * lchild, *rchild,*parent;
};