C++实现二叉树的递归与非递归前中后序遍历

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };

结构体如上。

递归前中后序：

TreeNode* Order(TreeNode* root){
         if(root==nullptr)
             return nullptr;
         //cout<<root->val<<endl; //前序    
         Order(root->left);
         //cout<<root->val<<endl; //中序
         Order(root->right);
         //cout<<root->val<<endl; //后序
         return root;
         }

非递归前序：

利用stack，先序的判断条件就是从上到下，从左到右

 

 

vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*>a;
        vector<int>r;
        while(root||!a.empty()){
            if(root!=NULL){
                r.push_back(root->val);
                a.push(root);
                root=root->left;
            }
            else{
                root=a.top();
                root=root->right;
                a.pop();
            }    
        }
        return r;
    }

非递归中序：

和先序比起来就是换一下顺序，中序的判断条件是左子树为空

 

vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*>a;
        vector<int>r;
        while(root||!a.empty()){
            if(root!=NULL){
                a.push(root);
                root=root->left;
            }
            else{
                root=a.top();
                r.push_back(root->val);
                root=root->right;
                a.pop();
            }    
        }
        return r;
    }

非递归后序：

 

要复杂一点，因为需要判断左右子树都为空，第一次判断左子树为空，出栈。然后再次进栈，判断右子树是否为空，两次出栈则判断左右子树都为空，pop，因为要判断出栈的节点是是不是第二次出栈，所以需要判断一个节点是不是首次出栈

这里的做法是新增一个结构体Tempnode，相当于给TreeNode增加一个first成员，也可以直接在TreeNode结构体里增加一个first成员，这里不赘述

 

struct Tempnode{
    bool first;
    TreeNode *link;
    Tempnode(): first(true), link(NULL){}
};
vector<int> posterorderTraversal(TreeNode* root) {
        stack<Tempnode*>a;
        vector<int>r;
        Tempnode *q;
        while(root||!a.empty()){
            if(root!=NULL){
                Tempnode *p=new Tempnode();
                p->link = root;
                a.push(p);
                root=root->left;
            }
            else{
                q=a.top();
                a.pop();
                if(q->first==true){
                    q->first=false;
                    a.push(q);//再次进栈
                    root=q->link->right;//转到右子树，如果右子树为空将第二次出栈
                }
                else{
                    r.push_back(q->link->val);
                }
            }
        }
        return r;
    }