力扣题---二叉树前、中、后序遍历

最新推荐文章于 2024-11-09 05:20:46 发布

S5242

最新推荐文章于 2024-11-09 05:20:46 发布

阅读量132

点赞数 1

分类专栏：题文章标签： leetcode 深度优先算法

本文链接：https://blog.csdn.net/S5242/article/details/123379297

版权

题专栏收录该内容

9 篇文章 0 订阅

订阅专栏

前序遍历–力扣144

前序先访问节点自己，再访问节点的左树，最后访问节点的右树。

class Solution {
public:
    // vector<int> preorderTraversal(TreeNode* root) {
    //     if(root!=nullptr){
    //         ret.push_back(root->val);
    //         preorderTraversal(root->left);
    //         preorderTraversal(root->right);
    //     }
    //     return  ret;
    // }

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

中序遍历–力扣94

中序先访该问节点的左树，再访该问节点自己，最后访问节点的右树。

class Solution {
public:
    // vector<int> inorderTraversal(TreeNode* root) {
    //     if(!root)
    //         return  ret;
    //     inorderTraversal(root->left);
    //     ret.push_back(root->val);
    //     inorderTraversal(root->right);
    //     return  ret;
    // }

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

后续遍历–力扣145

后续则是先访问该节点的右节点，在访问该节点的左节点，最后访问该节点本身。
后续非递归实现稍微复杂，需多加一个结点指针用来判断右树是否已被访问过，否则就会陷入死循环。

class Solution {
public:
    // vector<int> postorderTraversal(TreeNode* root) {
    //     if(!root)
    //         return  ret;
    //     postorderTraversal(root->left);
    //     postorderTraversal(root->right);
    //     ret.push_back(root->val);
    //     return  ret;
    // }
 vector<int> postorderTraversal(TreeNode* root) {
        if(!root)  return  ret;
        TreeNode* flag=nullptr;
        TreeNode*  p=root;
        while(!stk.empty() || p!=nullptr){        
            if(p){
                stk.push(p);
                p=p->left;
            }
            else{   
                p=stk.top();
                if(p->right && flag!=p->right){//右树存在且右树没访问过 则下一轮入栈 
                    p=p->right;  
                }
                else{
                    ret.push_back(p->val);
                    stk.pop();
                    flag=p;
                    p=nullptr;
                }          
            }
        }
    return  ret;
}
private:
    stack<TreeNode*> stk; 
    vector<int>  ret;
};