二叉树的先序/中序/后序（递归、非递归）+层序遍历

版权声明：本文为博主原创文章，转载请说明。 https://blog.csdn.net/GoJawee/article/details/77979133

queue 的基本操作举例如下：

queue入队，如例：q.push(x); 将x 接到队列的末端。
queue出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问queue队首元素，如例：q.front()，即最早被压入队列的元素。
访问queue队尾元素，如例：q.back()，即最后被压入队列的元素。
判断queue队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

#include<iostream>
#include<stack>
#include<queue>

using namespace std;

typedef struct TreeNode
{
    int data;
    struct TreeNode* lchild;
    struct TreeNode* rchild;
}TreeNode;


void pretravel(TreeNode* T)
{
    if (T != NULL)
    {
        cout << T->data << " ";
        pretravel(T->lchild);
        pretravel(T->rchild);
    }
}

void intravel(TreeNode* T)
{
    if (T != NULL)
    {
        intravel(T->lchild);
        cout << T->data<<" ";
        intravel(T->rchild);
    }
}

void posttravel(TreeNode* T)
{
    if (T != NULL)
    {
        posttravel(T->lchild);
        posttravel(T->rchild);
        cout << T->data << " ";
    }
}

/****************************************************/

void preOrdtravel(TreeNode* T) //先序非递归
{
    if (!T) 
        return;

    stack<TreeNode*> s;
    s.push(T);
    TreeNode* t;
    while (!s.empty())
    {
        t = s.top();   //出栈并打印
        cout << t->data << " ";
        s.pop();

        if (t->rchild)
            s.push(t->rchild);
        if (t->lchild)
            s.push(t->lchild);
    }

}


void inOrdTravel(TreeNode* T)  //中序非递归
{
    if (!T)
        return;

    TreeNode* cur = T;
    stack<TreeNode*> S;

    while (!S.empty() || cur != NULL)
    {
        if (cur != NULL)
        {
            S.push(cur);
            cur = cur->lchild;
        }
        else
        {
            //出栈并打印
            cout << S.top()->data << " ";
            cur = S.top()->rchild;
            S.pop();
        }
    }
}

void postOrdtravel(TreeNode *T)  //后序非递归
{

    if (T == NULL) return;

    TreeNode *p = T;
    stack<TreeNode *> S;
    TreeNode *last = T; //last=NULL（错误），必须是T（正确）
    S.push(p);
    while (!S.empty())
    {
        p = S.top(); //获取栈顶
        if ((p->lchild == NULL && p->rchild == NULL) || (p->rchild == NULL && last == p->lchild) || (last == p->rchild))
        {//打印并出栈，更新last
            cout << p->data << " ";
            last = p;
            S.pop();
        }
        else
        {
            if (p->rchild)
                S.push(p->rchild);
            if (p->lchild)
                S.push(p->lchild);
        }

    }
}

void levelTraver(TreeNode* T)  //层次遍历
{
    if (!T)
        return;

    queue<TreeNode*> Q;

    TreeNode* cur = T;

    Q.push(cur);
    while (!Q.empty())
    {
        cout << Q.front()->data << " ";
        cur = Q.front();
        Q.pop();
        if (cur->lchild)
            Q.push(cur->lchild);
        if (cur->rchild)
            Q.push(cur->rchild);
    }
}

int main()
{
    TreeNode* s1 = new TreeNode;
    TreeNode* s2 = new TreeNode;
    TreeNode* s3 = new TreeNode;
    TreeNode* s4 = new TreeNode;
    TreeNode* s5 = new TreeNode;
    TreeNode* s6 = new TreeNode;
    TreeNode* s7 = new TreeNode;

    s1->data = 1;
    s1->lchild = s2;
    s1->rchild = s5;

    s2->data = 2;
    s2->lchild = NULL;
    s2->rchild = s3;

    s3->data = 3;
    s3->lchild = s4;
    s3->rchild = NULL;

    s4->data = 4;
    s4->lchild = NULL;
    s4->rchild = NULL;

    s5->data = 5;
    s5->lchild = s6;
    s5->rchild = NULL;

    s6->data = 6;
    s6->lchild = NULL;
    s6->rchild = s7;

    s7->data = 7;
    s7->lchild = NULL;
    s7->rchild = NULL;

//遍历
    cout << "先序遍历"<<endl;
    pretravel(s1);       cout << endl;
    preOrdtravel(s1);    cout << endl;

    cout << "中序遍历" << endl;
    intravel(s1);        cout << endl;
    inOrdTravel(s1);     cout << endl;

    cout << "后序遍历" << endl;
    posttravel(s1);      cout << endl;
    postOrdtravel(s1);   cout << endl;

    cout << "层序遍历" << endl;
    levelTraver(s1);

    return 0;

}