数据结构--二叉树

二叉树前序、中序、后续的递归遍历与层序遍历 

/*二叉树递归遍历*/
# include <malloc.h>
# include <iostream>
# include <queue>
using namespace std;
typedef struct bitnode
{
    char data;
    struct bitnode* lchild, * rchild;
}bitnode,*bitree;
char creatbitree(bitree & t)
{
    //按照先序次序构造二叉树，#字符表示空树
    char ch;
    cin >> ch;
    if (ch == '#')
        t =NULL;
    else
    {
        if (!(t = (bitnode*)malloc(sizeof(bitnode)))) return 0;
        t->data = ch;
        creatbitree(t->lchild);
        creatbitree(t->rchild);
    }

}
void preordertraverse(bitree t)
{
    if (t)
    {
        cout << t->data << " ";
        preordertraverse(t->lchild);
        preordertraverse(t->rchild);
    }
}
void inordertraverse(bitree t)
{
    if (t)
    {
        inordertraverse(t->lchild);
        cout << t->data << " ";
        inordertraverse(t->rchild);
    }
}
void postordertraverse(bitree t)
{
    if (t)
    {
        postordertraverse(t->lchild);        
        postordertraverse(t->rchild);
        cout << t->data << " ";
    }
}
void layerordertraverse(bitree t)
{
    bitree p;
    queue<bitree>q;
    if (t != NULL)
    {
        q.push(t);
        while (!q.empty())
        {
            p = q.front();
            q.pop();
            cout << p->data << " ";
            if (p->lchild)
                q.push(p->lchild);
            if (p->rchild)
                q.push(p->rchild);
        }
    }
}
int main()
{
    bitree t;
    creatbitree(t);
    cout << "先序遍历顺序为：";
    preordertraverse(t);
    cout <<endl<< "中序遍历顺序为：";
    inordertraverse(t);
    cout << endl << "后序遍历顺序为：";
    postordertraverse(t);
    cout << endl << "层序遍历顺序为：";
    layerordertraverse(t);
}

 例如这个简单的二叉树：

输出结果为

二叉树的前序、中序、后后序的非递归遍历

# include <malloc.h>
# include <iostream>
# include <queue>
# include <stack>
using namespace std;
typedef struct bitnode
{
    char data;
    struct bitnode* lchild, * rchild;
}bitnode, * bitree;
void creatbitree(bitree& t)
{
    //按照先序次序构造二叉树，#字符表示空树
    char ch;
    cin >> ch;
    if (ch == '#')
        t = NULL;
    else
    {
        if (!(t = (bitnode*)malloc(sizeof(bitnode)))) return ;
        t->data = ch;
        creatbitree(t->lchild);
        creatbitree(t->rchild);
    }
    return ;
}
void preordertraverse_1(bitree t)
{
    if (t == NULL)
        return;
    bitree p = t;
    stack<bitree> s;
    while (!s.empty() || p) //根不为空或者栈不为空
    {
        //边遍历边打印，并存入栈中，以后需要借助这些根节点进入右子树
        while (p)
        {
            cout << p->data<<" ";
            s.push(p);
            p = p->lchild;
        }
        //当p为空时，说明根和左子树都遍历完了，该进入右子树了
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
    cout << endl;
}
void preordertraverse_2(bitree t)
{
    if (t == NULL)
        return;
    bitree p = t;
    stack<bitree> s;
    while (!s.empty() || p)
    {
        if (p)
        {
            cout << p->data<<" ";
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
    cout << endl;
}
void inordertraverse_1(bitree t)
{
    //空树
    if (t == NULL)
        return;
    //树非空
    bitree p = t;
    stack<bitree> s;
    while (!s.empty() || p)
    {
        //一直遍历到左子树最下边，边遍历边保存根节点到栈中
        while (p)
        {
            s.push(p);
            p = p->lchild;
        }
        //当p为空时，说明已经到达左子树最下边，这时需要出栈了
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            cout << p->data<<" ";
            //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
            p = p->rchild;
        }
    }
    cout << endl;
}
void inordertraverse_2(bitree t)
{
    //空树
    if (t == NULL)
        return;
    //树非空
    bitree p = t;
    stack<bitree> s;
    while (!s.empty() || p)
    {
        if (p)
        {
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            s.pop();
            cout << p->data<<" ";
            p = p->rchild;
        }
    }
    cout << endl;
}
void postordertraverse_1(bitree t)
{
    if (t == NULL)
        return;
    stack<bitree> s;
    //pCur:当前访问节点，pLastVisit:上次访问节点
    bitree  pCur,  pLastVisit;
    pCur = t;
    pLastVisit = NULL;
    //先把pCur移动到左子树最下边
    while (pCur)
    {
        s.push(pCur);
        pCur = pCur->lchild;
    }
    while (!s.empty())
    {
        //走到这里，pCur都是空，并已经遍历到左子树底端(看成扩充二叉树，则空，亦是某棵树的左孩子)
        pCur = s.top();
        s.pop();
        //一个根节点被访问的前提是：无右子树或右子树已被访问过
        if (pCur->rchild == NULL || pCur->rchild == pLastVisit)
        {
            cout << pCur->data<<" ";
            //修改最近被访问的节点
            pLastVisit = pCur;
        }
        /*这里的else语句可换成带条件的else if:
        else if (pCur->lchild == pLastVisit)//若左子树刚被访问过，则需先进入右子树(根节点需再次入栈)
        因为：上面的条件没通过就一定是下面的条件满足。仔细想想！
        */
        else
        {
            //根节点再次入栈
            s.push(pCur);
            //进入右子树，且可肯定右子树一定不为空
            pCur = pCur->rchild;
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->lchild;
            }
        }
    }
    cout << endl;
}
void postordertraverse_2(bitree t)
{
    if (t == NULL)
        return;
    stack<bitree> s1;
    stack<bitree> s2;
    bitree p = t;

    while (p || !s1.empty())
    {
        while (p)        //一直向右并将沿途节点访问（压入S2）后压入堆栈S1 
        {
            s2.push(p);
            s1.push(p);
            p = p->rchild;
        }
        if (!s1.empty())
        {
            p = s1.top();
            s1.pop();    //节点弹出堆栈
            p = p->lchild;  //转向左子树
        }
    }
    while (!s2.empty())    //访问（打印）S2中元素
    {
        p = s2.top();
        s2.pop();
        cout<<p->data<<" ";
    }
    cout << endl;
}

int main()
{
    bitree t;
    creatbitree(t);
    cout << "先序遍历顺序为："<<endl;
    preordertraverse_1(t);
    preordertraverse_2(t);
    cout << endl << "中序遍历顺序为：" << endl;
    inordertraverse_1(t);
    inordertraverse_2(t);
    cout << endl << "后序遍历顺序为：" << endl;
    postordertraverse_1(t);
    postordertraverse_2(t);
}

运行结果