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;

}