算法28 30 二叉树非递归遍历（前中后）

目录

• 非递归
  • 思路
• 前序preorder
  • code
• 中序inorder
  • code
• 后序postorder
  • code
• 目前见过的最强的前中后遍历统一版迭代写法（只用移动左中右的顺序即可）：
  • 前序遍历：
  • 中序遍历：
  • 后序遍历：

非递归

• 在做层序遍历之前，一直认为递归最牛逼，非递归是 。然后用到BFS时递归没法用了，遂硬着头皮回去看，发现递归原理也是调用栈来储存。。。
• 其实多理解一下发现思路和递归差不多,但并不是一来就是按照顺序压栈，一般先压单边，然后弹出的时候再处理。

思路

不了解三种遍历方式可以先看看介绍

1.前序和中序差不多，先一直往左子树遍历到最底层，主要差别：前序是遍历时就将值放入容器，中序是在遍历到最后一层（空指针时返回），弹出向右遍历。
2.后序我的方法是反方向前序遍历,最后将容器中顺序反转（前序：中左右 》》反方向前序：中右左 》》反转：左右中

前序preorder

code

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        vector<int> v;
        if(root==nullptr) return v;
        while(root!=nullptr||!stk.empty()){
           if(root!=nullptr){
                v.push_back(root->val);
                stk.push(root);
                root=root->left;
           }
           else{
                root=stk.top()->right;

                stk.pop();  
               
           }
        }
        return v;
    }
};

中序inorder

code

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        vector<int> v;
        if(root==nullptr) return v;
        while(root||!stk.empty()){
           if(root){
                stk.push(root);
                root=root->left;
           }
           else{
               root=stk.top();
               stk.pop();
               v.push_back(root->val);
               root=root->right;
           }
        }
        return v;
    }
};

后序postorder

code

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        vector<int> v;
        if(root==nullptr) return v;
        while(root!=nullptr||!stk.empty()){
           if(root!=nullptr){
                v.push_back(root->val);
                stk.push(root);
                root=root->right;
           }
           else{
                root=stk.top();
                stk.pop();  
                root=root->left;
           }
        }
        reverse(v.begin(),v.end());
        return v;
    }
};

目前见过的最强的前中后遍历统一版迭代写法（只用移动左中右的顺序即可）：

前序遍历：

vector<int> preorderTraversal(TreeNode* root) {
        if(!root) return {};
        vector<int> result;
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()){
            TreeNode* node = stk.top();
            stk.pop();
            if(node){
                if(node -> right){
                    stk.push(node -> right);
                }
                if(node -> left){
                    stk.push(node -> left);
                } 
                stk.push(node);
                stk.push(nullptr);
            }else{
                result.push_back(stk.top()->val);
                stk.pop();
            }
        }
        return result;
    }

中序遍历：

vector<int> inorderTraversal(TreeNode* root) {
        if(!root) return {};
        vector<int> result;
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()){
            TreeNode* node = stk.top();
            stk.pop();
            if(node){
                if(node -> right){
                    stk.push(node -> right);
                }
                stk.push(node);
                stk.push(nullptr);
                if(node -> left){
                    stk.push(node -> left);
                } 
            }else{
                result.push_back(stk.top()->val);
                stk.pop();
            }
        }
        return result;
    }

后序遍历：

 vector<int> postorderTraversal(TreeNode* root) {
        if(!root) return {};
        vector<int> result;
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()){
            TreeNode* node = stk.top();
            stk.pop();
            if(node){
                stk.push(node);
                stk.push(nullptr);
                if(node -> right){
                    stk.push(node -> right);
                }
                if(node -> left){
                    stk.push(node -> left);
                } 
            }else{
                result.push_back(stk.top()->val);
                stk.pop();
            }
        }
        return result;
    }