C++ 手动创建二叉树，并实现前序、中序、后序、层次遍历

二叉树的创建是个麻烦事，我的思路是：首先将一个普通的二叉树转化为满二叉树，其中的空节点用一些标识数据来代替，如此一来，就可以用数组索引来描述数据在二叉树的什么位置了。

比如，数组[2,4,3,1,5,-1,-1] 就可以表示一个三层的二叉树，具体长这样：

对于四种遍历方法，前序、中序、后序、层次遍历方法，给出了递归和迭代两种方式

具体代码如下：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
/*实现普通二叉树的创建，以及四种遍历方法*/
template 
class Node {
    public:
    T val = 0;
    Node* lchild = nullptr;
    Node* rchild = nullptr;
    Node(T& a): val(a){}
};

template 
class BinTree {
public:
    Node* root = nullptr;
    BinTree(vector& value, int n);
    void creatTree(Node*& p, vector& value, int n, const int len);
    void preOrder1(Node* p);  //递归
    void preOrder2();   //迭代
    void inOrder1(Node* p);  //递归
    void inOrder2();    //迭代
    void postOrder1(Node* p);  //递归
    void postOrder2();   //迭代
    void levelOrder();
    void visit(Node* p);
};

template 
BinTree::BinTree(vector& value, int n) {
    if ( value.size() != pow(2, n)-1 ) {//树的高度与元素个数不匹配
        cout << " elements not match to level " << endl;
        return;
    }
    creatTree(root, value, 0, pow(2, n)-1 );
}

template 
void BinTree::creatTree(Node*& p, vector& value, int n, const int len) {
    if ( n < len && value[n] != -1 ) {
        p = new Node (value[n]);
        creatTree(p->lchild, value, 2*n+1, len);    //创建左子树
        creatTree(p->rchild, value, 2*(n+1), len);  //创建you子树
    }
}

template 
void BinTree::visit(Node* p) {
    cout << p->val << " ";
}

template 
void BinTree::preOrder1(Node* p) {
    if (p) {
        visit(p);
        preOrder1(p->lchild);
        preOrder1(p->rchild);
    }
}

template 
void BinTree::inOrder1(Node* p) {
    if (p) {
        inOrder1(p->lchild);
        visit(p);
        inOrder1(p->rchild);
    }
}

template 
void BinTree::postOrder1(Node* p) {
    if (p) {
        postOrder1(p->lchild);
        postOrder1(p->rchild);
        visit(p);
    }
}

template 
void BinTree::preOrder2() {
    stack*> st;
    Node* p = this->root;
    st.push(p->rchild);
    visit(p);
    while ( !st.empty() ) {
        if ( p->lchild )
            p = p->lchild;
        else {
            p = st.top();
            st.pop();
        }
        visit(p);
        if ( p->rchild )
            st.push(p->rchild);
    }

}

template 
void BinTree::inOrder2() {
    stack*> st;
    Node* p = this->root;
    while ( p || !st.empty() ) {
        if (p) {
            st.push(p);
            p = p->lchild;
        }
        else {
            p = st.top();
            st.pop();
            visit(p);
            p = p->rchild;
        }
    }
}

template 
void BinTree::postOrder2() {
    //太难了，cpu快想炸了，摆了
}

template 
void BinTree::levelOrder() {
    queue*> Q;
    Node* p = this->root;
    Q.push(p);
    while ( !Q.empty() ) {
        p = Q.front();
        Q.pop();
        visit(p);
        if ( p->lchild )
            Q.push(p->lchild);
        if ( p->rchild )
            Q.push(p->rchild);
    }
}

void sets(int* n) {
    n = new int (3);
}


int main() {
    vector a = {2,4,3,1,5,-1,-1};
    a.shrink_to_fit();
    BinTree *b = new BinTree (a, 3);

    cout << b->root->val << " ";
    cout << b->root->lchild->val << " ";
    cout << b->root->rchild->val << " ";
    cout << b->root->lchild->lchild->val << " ";
    cout << b->root->lchild->rchild->val << endl;

    cout << "前序遍历(递归): ";
    b->preOrder1(b->root);
    cout << "\n中序遍历(递归): ";
    b->inOrder1(b->root);
    cout << "\n后序遍历(递归): ";
    b->postOrder1(b->root);

    cout << "\n前序遍历(迭代): ";
    b->preOrder2();
    cout << "\n中序遍历(迭代): ";
    b->inOrder2();

    cout << "\n层次遍历: ";
    b->levelOrder();
    cout << endl;
var code = "93e77dd0-c6ba-4c8a-bc02-31555a7fa65d"
}