zoukankan      html  css  js  c++  java
  • 算法28 30 二叉树非递归遍历(前中后)

    非递归

    • 在做层序遍历之前,一直认为递归最牛逼,非递归是 。然后用到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;
        }
    
  • 相关阅读:
    Java实现 蓝桥杯VIP 基础练习 回形取数
    Java实现 蓝桥杯VIP 基础练习 回形取数
    Java实现 蓝桥杯VIP 基础练习 回形取数
    Java实现 蓝桥杯VIP 基础练习 回形取数
    Java实现 蓝桥杯VIP 基础练习 报时助手
    Java实现 蓝桥杯VIP 基础练习 报时助手
    Java实现 蓝桥杯VIP 基础练习 报时助手
    Java实现 蓝桥杯VIP 基础练习 报时助手
    Java实现 蓝桥杯VIP 基础练习 报时助手
    block的是发送信号的线程,又不是处理槽函数的线程
  • 原文地址:https://www.cnblogs.com/impw/p/15647556.html
Copyright © 2011-2022 走看看