前序中序、中序后序确定二叉树，广度优先遍历、前序、中序、后序的递归、非递归遍历

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

class Node {
    friend class BinaryTree;
    char data;
    Node *leftChild;
    Node *rightChild;
public:
    explicit Node(char _data='0',Node*_leftChild=nullptr,Node*_rightChild=nullptr):data(_data),leftChild(_leftChild),rightChild(_rightChild){}
};

class BinaryTree {
    Node *root;
    stack<Node*>stack;
    queue<Node*>queue;
public:
    explicit BinaryTree(Node*_root= nullptr):root(_root){}

    Node* PIFind(char *pre,int preFirst,char*in,int inFirst,int length){
        for (int i = 0; i < length; ++i) {
            if (in[inFirst+i]==pre[preFirst]){
                Node *node= new Node();
                node->data=pre[preFirst];
                node->leftChild= PIFind(pre,preFirst+1,in,inFirst,i);
                node->rightChild= PIFind(pre,preFirst+i+1,in,inFirst+i+1,length-i-1);
                return node;
            }
        }
        return nullptr;
    }

    Node* IPFind(char *in,int inFirst,char*post,int postFirst,int length){
        for (int i = 0; i < length; ++i) {
            if (in[inFirst+i]==post[postFirst+length-1]){
                Node*node=new Node();
                node->data=post[postFirst+length-1];
                node->leftChild= IPFind(in,inFirst,post,postFirst,i);
                node->rightChild= IPFind(in,inFirst+i+1,post,postFirst+i,length-i-1);
                return node;
            }
        }
        return nullptr;
    }

    void BreadthFirstSearch(){
        Node*mark=new Node();
        int cnt=0;
        while (!queue.empty())
            queue.pop();
        queue.push(mark);
        queue.push(root);
        while (queue.front()!=queue.back()){
            if (queue.front()==mark){
                queue.push(mark);
                queue.pop();
                cnt++;
            } else{
                cout<<queue.front()->data<<' ';
                if (queue.front()->leftChild)
                    queue.push(queue.front()->leftChild);
                if (queue.front()->rightChild)
                    queue.push(queue.front()->rightChild);
                queue.pop();
            }
        }
        cout<<endl<<cnt<<" layers"<<endl;
    }

    void PreOrderSearch(Node*p){
        if (p){
            cout<<p->data<<' ';
            PreOrderSearch(p->leftChild);
            PreOrderSearch(p->rightChild);
        }
    }

    void InOrderSearch(Node*p){
        if (p){
            InOrderSearch(p->leftChild);
            cout<<p->data<<' ';
            InOrderSearch(p->rightChild);
        }
    }

    void PostOrderSearch(Node*p){
        if (p){
            PostOrderSearch(p->leftChild);
            PostOrderSearch(p->rightChild);
            cout<<p->data<<' ';
        }
    }

    void PreSearch(){
        Node*p=root;
        while (!stack.empty()||p){
            if (p){
                stack.push(p);
                cout<<p->data<<' ';
                p=p->leftChild;
            } else {
                p=stack.top()->rightChild;
                stack.pop();
            }
        }
    }

    void InSearch(){
        Node*p=root;
        while (!stack.empty()||p){
            if (p){
                stack.push(p);
                p=p->leftChild;
            } else {
                cout<<stack.top()->data<<' ';
                p=stack.top()->rightChild;
                stack.pop();
            }
        }
    }

    void PostSearch(){
        Node *p= root,*q= nullptr;
        while (!stack.empty()||p){
            if (p){
                stack.push(p);
                p=p->leftChild;
            } else if (stack.top()->rightChild&&stack.top()->rightChild!=q){
                p=stack.top()->rightChild;
            } else{
                cout<<stack.top()->data<<' ';
                q=stack.top();
                stack.pop();
            }
        }
    }

};

int main() {
    Node*e=new Node('E');
    Node*d=new Node('D');
    Node*c=new Node('C');
    Node*b=new Node('B',d,e);
    Node*a=new Node('A',b,c);
    BinaryTree*binaryTree=new BinaryTree(a);
    binaryTree->BreadthFirstSearch();
    cout<<endl;
    binaryTree->PreOrderSearch(a);
    cout<<endl;
    binaryTree->InOrderSearch(a);
    cout<<endl;
    binaryTree->PostOrderSearch(a);
    cout<<endl;
    binaryTree->PreSearch();
    cout<<endl;
    binaryTree->InSearch();
    cout<<endl;
    binaryTree->PostSearch();
    cout<<endl;
    BinaryTree*binaryTree1=new BinaryTree(binaryTree->PIFind("ABDGCEF",0,"DGBAECF",0,7));
    BinaryTree*binaryTree2=new BinaryTree(binaryTree->IPFind("DGBAECF",0,"GDBEFCA",0,7));
    binaryTree1->BreadthFirstSearch();
    binaryTree2->BreadthFirstSearch();
    return 0;
}