根据数组建立完全二叉树， 前序、中序、后序、深度优先遍历、广度优先遍历(层次遍历)的递归和非递归代码

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

using namespace std;

/* 
二叉树前序、中序、后序遍历非递归写法的透彻解析
https://blog.csdn.net/zhangxiangDavaid/article/details/37115355

二叉树的建立和前序、中序、后序、深度优先遍历、广度优先遍历(层次遍历)
*/
 
struct TreeNode{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr){
    }
};

// 根据数组建立完全二叉树 
TreeNode* CreateNode(vector<int> num, int start, int len){
    if(start>=len)
        return nullptr;
    TreeNode* root = new TreeNode(num[start]);
    root->left = CreateNode(num, start*2+1, len);
    root->right = CreateNode(num, start*2+2, len);
    return root;
} 

// 递归前序遍历 
void ProOrderTraverse(TreeNode* root){
    if(root==nullptr)
        return;
    
    cout<< root->val << " ";
    ProOrderTraverse(root->left);
    ProOrderTraverse(root->right);
}

// 非递归前序遍历
vector<int> ProOrder(TreeNode* root){
    vector<int> res;
    if(root==nullptr)
        return res;
    stack<TreeNode*> s;
    TreeNode* p = root;
    while(p!=nullptr || !s.empty()){
        while(p!=nullptr){
            s.push(p);
            res.push_back(p->val);
            p = p->left;  // 执行到访问到最下面的左子树        
        }
        if(!s.empty()){  //这个if不会循环 只会执行一次 
            p = s.top();
            s.pop();
            p = p->right;
        }
    }
    return res;
} 

// 递归中序遍历 
void MidOrderTraverse(TreeNode* root){
    if(root==nullptr)
        return;
    MidOrderTraverse(root->left);
    cout<< root->val << " ";
    MidOrderTraverse(root->right);    
}

//非递归中序遍历 
vector<int> MidOrder(TreeNode* root){
    vector<int> res;
    if(root==nullptr)
        return res;
    stack<TreeNode*> s;
    TreeNode* p = root;
    while(p!=nullptr || !s.empty()){
        while(p!=nullptr){
            s.push(p);
            p = p->left;
        }
        if(!s.empty()){
            p = s.top();
            s.pop();
            res.push_back(p->val);
            p = p->right;
        }
    }
}

// 递归后序遍历 
void PostOrderTraverse(TreeNode* root){
    if(root==nullptr)
        return;
    PostOrderTraverse(root->left);
    PostOrderTraverse(root->right);    
    cout<< root->val << " ";
}

// 非递归后序遍历
vector<int> PostOrder(TreeNode* root){
    vector<int> res;
    if(root==nullptr)
        return res;
    
    stack<TreeNode*> s;
    TreeNode* pCur = root;
    TreeNode* pLast = nullptr;
    
    while(pCur){
        s.push(pCur);
        pCur = pCur->left;    
    }
    
    while(!s.empty()){
        pCur = s.top();
        s.pop();
        
        if(pCur->left==nullptr || pCur->right==pLast){
            res.push_back(pCur->val);
            pLast = pCur;            
        }
        else{
            s.push(pCur);
            pCur = pCur->right;
            while(pCur){
                s.push(pCur);
                pCur = pCur->left;
            }
        }        
    }
    return res;        
} 

// 非递归深度优先遍历二叉树 
vector<int> dfs(TreeNode* root){
    vector<int> res;
    if(root==nullptr)
        return res;
        
    stack<TreeNode*> s;
    s.push(root);
    while(!s.empty()){
        TreeNode* pNode = s.top();
        s.pop();
        res.push_back(pNode->val);
        if(pNode->right)
            s.push(pNode->right);
        if(pNode->left)
            s.push(pNode->left);        
    }
    return res;    
}

// 非递归广度优先遍历（层次遍历）
vector<int> bfs(TreeNode* root){
    vector<int> res;
    if(root==nullptr)
        return res;
    queue<TreeNode*> Q;
    Q.push(root);
    while(!Q.empty()){
        TreeNode* pNode = Q.front();
        Q.pop();
        res.push_back(pNode->val);
        if(pNode->left)
            Q.push(pNode->left);
        if(pNode->right)
            Q.push(pNode->right);
    }
    return res;
} 

int main(int argc, char** argv) {
    vector<int> num{1, 2, 3, 4, 5, 6, 7, 8, 9};
    TreeNode* root = CreateNode(num, 0, 9);
    cout<<"递归前序遍历："<<endl;
    ProOrderTraverse(root);
    cout<<endl;
    cout<<"递归中序遍历："<<endl;
    MidOrderTraverse(root);
    cout<<endl;
    cout<<"递归后序遍历："<<endl; 
    PostOrderTraverse(root);
    cout<<endl; 
    
    vector<int> ap = ProOrder(root);
    vector<int> am = MidOrder(root);     
    vector<int> a= PostOrder(root);
    vector<int> adfs = dfs(root);
    vector<int> abfs = bfs(root);
    
    vector<int>::iterator it1;
    vector<int>::iterator it2;
    vector<int>::iterator it3;
    vector<int>::iterator it4;
    vector<int>::iterator it5;
    
    cout<<"非递归前序遍历："<<endl; 
    for(it1=ap.begin(); it1!=ap.end(); it1++)
        cout<<*it1 <<" ";
    cout<<endl;
    
    cout<<"非递归中序遍历："<<endl;
    for(it2=am.begin(); it2!=am.end(); it2++)
        cout<<*it2 <<" ";
    cout<<endl;
    
    cout<<"非递归后序遍历："<<endl; 
    for(it3=a.begin(); it3!=a.end(); it3++)
        cout<<*it3 <<" ";
    cout<<endl;    
    
    cout<<"二叉树的深度优先遍历："<<endl;
    for(it4=adfs.begin(); it4!=adfs.end(); it4++)
        cout<<*it4<<" ";
    cout<<endl;
    
    cout<<"二叉树的广度优先遍历（层次遍历）："<<endl;
    for(it5=abfs.begin(); it5!=abfs.end(); it5++)
        cout<<*it5<<" ";
    cout<<endl; 
    return 0;
}