二叉树的遍历(先序、中序、后序、层序)递归与非递归实现

写了一天的代码，留个纪念吧。。。

二叉树后序遍历非递归实现，这哥们讲的真不错，附上链接：
https://www.bilibili.com/video/av23885544?from=search&seid=6629169072442500924

#include <iostream>
#include <stack>
#include <queue>
using namespace std;
typedef struct binaryNode{
    char data;
    binaryNode *lchild,*rchild;

} binaryNode, *binaryTree;

void createBinaryTree(binaryTree &T)
{
    //先序遍历生成二叉树
    char data;
    cin>>data;
    if (data == '#')
    {
        T = NULL;
    }
    else
    {
        T = new binaryNode();
        //此时main函数中的tree变成了T,从此以后T的地址就没有被改变过了，也就是tree没有被改变了，改变的是T的孩子的值，而不是T，也就是tree指针始终是根节点的指针。
        //另外，每次孩子节点的指针都会变成根节点的指针，所有也需要通过指针引用的方式。

//        cout<<T<<endl;
        T->data = data;
        createBinaryTree(T->lchild);
        createBinaryTree(T->rchild);
    }
}
void Visit (binaryTree T)
{
    cout<<T->data<<endl;
}
//先序遍历
void preOrder (binaryTree T)
{
    if (T != NULL)
    {
        Visit(T);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

//中序遍历
void midOrder (binaryTree T)
{
    if(T!=NULL)
    {
        midOrder(T->lchild);
        Visit(T);
        midOrder(T->rchild);
    }
}

//后序遍历
void lastOrder (binaryTree T)
{
    if(T!=NULL)
    {
        lastOrder(T->lchild);
        lastOrder(T->rchild);
        Visit(T);
    }
}





//后序遍历，非递归
//定义带有标志位的结构体
typedef struct bitNodePos{
    binaryTree biTree;
    char tag;
}binaryNodePos, *binaryTreePos;

void lastOrder2(binaryTree T)
{
    stack<binaryTreePos> stack;
    binaryTree p = T;
    binaryTreePos BT;

    while (p!=NULL || !stack.empty()) {
        //遍历左子树
        while (p != NULL) {
            BT = new binaryNodePos();
            BT->biTree = p;
            BT->tag = 'L';
            stack.push(BT);
            p = p->lchild;
        }


        while (!stack.empty())
        {
            BT = stack.top();
            if (BT->tag == 'R')
            {
                cout<<BT->biTree->data<<endl;
                stack.pop();
            }
            else
            {
                BT->tag = 'R';
                p = BT->biTree;
                p = p->rchild;
                break;
            }
        }


    }

}


//非递归先序遍历

void preOrder2(binaryTree T)
{
    stack<binaryTree> stack;
    binaryTree p = T;
    while (p!=NULL || !stack.empty())
    {
        if (p!=NULL)
        {
            stack.push(p);
            cout<<p->data<<endl;
            p = p->lchild;
        }
        else
        {
            //出栈
            p =  stack.top();
            stack.pop();
            p = p->rchild;
        }

    }
}

//非递归中序遍历
void midOrder2(binaryTree T)
{
    stack<binaryTree> stack;
    binaryTree p = T;

    while (p!=NULL || !stack.empty())
    {
        if(p != NULL)
        {
            stack.push(p);
            p = p->lchild;
        }
        else
        {
            p = stack.top();
            stack.pop();
            cout<<p->data<<endl;
            p = p->rchild;
        }

    }
}

//层序遍历

void levelOrder(binaryTree T)
{
    binaryTree p = T;
    queue<binaryTree> queue;
    if (p!=NULL)
    {
        queue.push(p);
    }
    while (!queue.empty())
    {
        p = queue.front();
        cout<<p->data<<endl;
        queue.pop();
        if (p->lchild != NULL)
        {
            queue.push(p->lchild);
        }
        if(p->rchild != NULL)
        {
            queue.push(p->rchild);
        }
    }
}
int main()
{
    binaryTree tree;
//    cout<<tree<<endl;
    createBinaryTree(tree);
//    cout<<tree<<endl;
//    cout<<beifei<<endl;
//    cout<<tree<<endl;
    cout<<"最后一个节点地址"<<tree<<endl;
    cout<<"***先序遍历***"<<endl;
    preOrder(tree);
    cout<<"***中序遍历***"<<endl;
    midOrder(tree);

    cout<<"***后序遍历***"<<endl;
    lastOrder(tree);

    cout<<"***非递归后序遍历***"<<endl;
    lastOrder2(tree);

    cout<<"***非递归先序遍历***"<<endl;
    preOrder2(tree);

    cout<<"***非递归中序遍历***"<<endl;
    midOrder2(tree);

    cout<<"***层序遍历结果：***"<<endl;
    levelOrder(tree);

    return 0;
}


//测试实例


//a
//b
//d
//#
//#
//#
//c
//#
//#



//a
//b
//d
//#
//h
//#
//#
//e
//f
//#
//#
//#
//c
//#
//#

运行结果：