树和二叉树

树：n（n≥0）个结点的有限集合。
当n＝0时，称为空树；
任意一棵非空树满足以下条件：
⑴ 有且仅有一个特定的称为根的结点；
⑵ 当n＞1时，除根结点之外的其余结点被分成m（m>0）个互不相交的有限集合T1,T2,… ,Tm，其中每个集合又是一棵树，并称为这个根结点的子树。
结点的度：结点所拥有的子树的个数。
树的度：树中各结点度的最大值。
叶子结点：度为0的结点，也称为终端结点。
分支结点：度不为0的结点，也称为非终端结点。
孩子、双亲：树中某结点子树的根结点称为这个结点的孩子结点，这个结点称为它孩子结点的双亲结点；
兄弟：具有同一个双亲的孩子结点互称为兄弟。
路径：如果树的结点序列n1, n2, …, nk有如下关系：结点ni是ni+1的双亲（1<=i<k），则把n1, n2, …, nk称为一条由n1至nk的路径；路径上经过的边的个数称为路径长度。
祖先、子孙：在树中，如果有一条路径从结点x到结点y，那么x就称为y的祖先，而y称为x的子孙。
结点所在层数：根结点的层数为1；对其余任何结点，若某结点在第k层，则其孩子结点在第k+1层。
树的深度：树中所有结点的最大层数，也称高度。
层序编号：将树中结点按照从上层到下层、同层从左到右的次序依次给他们编以从1开始的连续自然数。
有序树、无序树：如果一棵树中结点的各子树从左到右是有次序的，称这棵树为有序树；反之，称为无序树。
森林：m (m≥0)棵互不相交的树的集合。
同构：对两棵树，若通过对结点适当地重命名，就可以使这两棵树完全相等（结点对应相等，结点对应关系也相等），则称这两棵树同构。
前序遍历：树的前序遍历操作定义为：
若树为空，不进行遍历；否则
⑴ 访问根结点；
⑵ 按照从左到右的顺序前序遍历根结点的每一棵子树。
后序遍历：树的后序遍历操作定义为：
若树为空，则遍历结束；否则
⑴ 按照从左到右的顺序后序遍历根结点的每一棵子树；
⑵ 访问根结点。
层序遍历：树的层序遍历操作定义为：
从树的第一层（即根结点）开始，自上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。
树的存储结构
1.双亲表示法：
基本思想：
用一维数组来存储树的各个结点（一般按层序存储），
数组中的一个元素对应树中的一个结点，
每个结点记录两类信息：结点的数据信息以及该结点的双亲在数组中的下标。
顺序存储：本质上是静态指针
双亲表示法
双亲、孩子表示法
链式存储：
多重链表示法
孩子链表表示法
孩子兄弟表示法
二叉树
二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
斜树
1 .所有结点都只有左子树的二叉树称为左斜树；
2 .所有结点都只有右子树的二叉树称为右斜树；
3.左斜树和右斜树统称为斜树。
满二叉树
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。
完全二叉树
对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同。
完全二叉树的特点：

1. 叶子结点只能出现在最下两层，且最下层的叶子结点都集中在二叉树的左部；
2. 完全二叉树中如果有度为1的结点，只可能有一个，且该结点只有左孩子。
3. 深度为k的完全二叉树在k-1层上一定是满二叉树。
   二叉树基本操作

#include <iostream>

using namespace std;
template <class T>
struct node
{
    T data;
    node<T> *lchild,*rchild;
};
template <class T>
class bitree{
public:
    bitree(){root=creat();}
    ~bitree(){release(root);}
    void preorder(){preorder(root);}
    void inorder(){inorder(root);}
    void postorder(){postorder(root);}
    void levelorder();
    void qianorder(){qianorder(root);}
    void zhongorder(){zhongorder(root);}
    void PostOrder();
private:
    node<T> *creat();
    node<T> *root;
    void release(node<T> *bt);
    void preorder(node<T> *bt);
    void inorder(node<T> *bt);
    void postorder(node<T> *bt);
    void qianorder(node<T> *bt);
    void zhongorder(node<T> *bt);
};
template <typename T>
struct element
{
  node<T> *ptr;
  int flag;
};

//非递归后序遍历
template <class T>
void bitree<T> :: PostOrder( )
{
	node<T> *bt = root;
	element<T> S[100];                  //顺序栈，最多100个元素
	int top = -1;                       //顺序栈初始化
	while (bt != NULL || top != -1)      //两个条件都不成立才退出循环
	{
		while (bt != NULL)
		{
			top++;
			S[top].ptr = bt; S[top].flag = 1;      //bt连同标志flag入栈
			bt = bt->lchild;
		}
		while (top != -1 && S[top].flag == 2)
		{
			bt = S[top--].ptr;
			cout << bt->data;
		}
		if (top != -1) {
			S[top].flag = 2;
			bt = S[top].ptr->rchild;
		}
		else
			bt = NULL;
	}
}

//非递归中序遍历
template <class T>
void bitree<T>::zhongorder(node<T> *bt)
{
    node<T> *a[100];
    int top=-1;
    while(bt!=NULL||top!=-1)
    {
        while(bt!=NULL)
        {
            a[++top]=bt;
            bt=bt->lchild;
        }
        while(top!=-1)
        {
            bt=a[top--];
            cout<<bt->data;
            bt=bt->rchild;
        }
    }
}
//非递归前序遍历
template <class T>
void bitree<T>::qianorder(node<T> *bt)
{
    node<T> *a[100];
    int top=-1;
    while(bt!=NULL||top!=-1)
    {
        while(bt!=NULL)
        {
            cout<<bt->data;
            a[++top]=bt;
            bt=bt->lchild;
        }
        while(top!=-1)
        {
            bt=a[top--];
            bt=bt->rchild;
        }
    }
}
template <class T>
node<T> *bitree<T>::creat()
{
    node<T> *bt;
    char ch;
    cin>>ch;
    if(ch!='#')
    {
        bt=new node<T>;
        bt->data=ch;
        bt->lchild=creat();
        bt->rchild=creat();
    }else bt=NULL;
    return bt;
}
//析构
template <class T>
void bitree<T>::release(node<T> *bt)
{
    if(bt!=NULL)
    {
        release(bt->lchild);
        release(bt->rchild);
        delete bt;
    }
    else return;
}
//前序遍历
template <class T>
void bitree<T>::preorder(node<T> *bt)
{
    if(bt!=NULL)
    {
        cout<<bt->data;
        preorder(bt->lchild);
        preorder(bt->rchild);
    }
    else
        return;
}
//中序遍历
template <class T>
void bitree<T>::inorder(node<T> *bt)
{
    if(bt!=NULL)
    {
        inorder(bt->lchild);
        cout<<bt->data;
        inorder(bt->rchild);
    }
    else return;
}
//后序遍历
template <class T>
void bitree<T>::postorder(node<T> *bt)
{
    if(bt!=NULL)
    {
        postorder(bt->lchild);
        postorder(bt->rchild);
        cout<<bt->data;
    }
    else return;
}
template <class T>
void bitree<T>::levelorder()
{
    node<T> *q[100],*p=NULL;
    int front1=-1,rear=-1;
    if(root==NULL)return;
    q[++rear]=root;
    while(front1!=rear)
    {
        p=q[++front1];
        cout<<p->data<<" ";
        if(p->lchild!=NULL)q[++rear]=p->lchild;
        if(p->rchild!=NULL)q[++rear]=p->rchild;
    }
}
int main()
{
    char ch;
    do
    {
        bitree<char> t;
        t.preorder();
        cout<<endl;
        t.inorder();
        cout<<endl;
        t.postorder();
        cout<<endl;
        t.levelorder();
        cout<<endl;
        cin>>ch;
        t.qianorder();
        t.zhongorder();
        t.PostOrder();
    }while(ch=='Y');
    return 0;
}