• LC144/94/145 二叉树前序/中序/后序遍历 递归与非递归实现


    前序遍历

    递归写法

    class Solution {
    public:
        vector<int> preorderTraversal(TreeNode* root) {
            vector<int> res, leftRes, rightRes;
            if(root == nullptr)
                return res;
            res.push_back(root->val);
            leftRes = preorderTraversal(root->left);
            rightRes = preorderTraversal(root->right);
            if(leftRes.size() > 0)
            {
                for(auto val : leftRes)
                    res.push_back(val);
            }
            if(rightRes.size() > 0)
            {
                for(auto val : rightRes)
                    res.push_back(val);
            }
            return res;
        }
    };
    


    递归写法的时间复杂度,空间复杂度较为一般。

    非递归写法

    使用非递归写法时需要用到栈,这里采用了LC题解中一种不错的解法.
    思路:带有nullptr标记的节点直接访问节点值,没有标记则对节点本身添加标记并遍历子节点,该过程用栈实现

    class Solution {
    public:
        vector<int> preorderTraversal(TreeNode* root) {
            vector<int> res;
            if(root == nullptr)
                return res;
            stack<TreeNode*> nodes;
            nodes.push(root);
            while(nodes.size() > 0){
                TreeNode* nowNode = nodes.top();
                nodes.pop();
                if(nowNode != nullptr){
                    // 右
                    if(nowNode->right != nullptr)
                        nodes.push(nowNode->right);
                    // 左
                    if(nowNode->left != nullptr)
                        nodes.push(nowNode->left);
                    // 根
                    nodes.push(nowNode);
                    nodes.push(nullptr);
                }  
                else{
                    res.push_back(nodes.top()->val);
                    nodes.pop();
                }
            } 
            return res;
        }
    };
    

    这个题解的优点在于只需要交换 //右,//左,//根三部分的顺序即可实现先序/中序/后序遍历方式,非常方便.

    下图是一个遍历过程图示,可以更清晰地看到遍历过程。

    中序遍历

    递归写法

    class Solution {
    public:
        vector<int> inorderTraversal(TreeNode* root) {
            vector<int> res, leftRes, rightRes;
            if(root == nullptr)
                return res;
            leftRes = inorderTraversal(root->left);
            rightRes = inorderTraversal(root->right);
            if(!leftRes.empty()){
                for(auto val : leftRes)
                    res.push_back(val);
            }
            res.push_back(root->val);
            if(!rightRes.empty()){
                for(auto val : rightRes)
                    res.push_back(val);
            }
            return res;
        }
    };
    

    非递归写法

    参考前序遍历的非递归写法即可

    class Solution {
    public:
        vector<int> inorderTraversal(TreeNode* root) {
            vector<int> res;
            if(root == nullptr)
                return res;
            stack<TreeNode*> nodes;
            nodes.push(root);
            while(!nodes.empty()){
                TreeNode* nowNode = nodes.top();
                nodes.pop();
                if(nowNode != nullptr){
                    // 右
                    if(nowNode->right != nullptr)
                        nodes.push(nowNode->right);
                    // 根
                    nodes.push(nowNode);
                    nodes.push(nullptr);
                    // 左
                    if(nowNode->left != nullptr)
                        nodes.push(nowNode->left);
                }
                else{
                    res.push_back(nodes.top()->val);
                    nodes.pop();
                }
            }
            return res;
        }
    };
    

    后序遍历

    递归

    class Solution {
    public:
        vector<int> postorderTraversal(TreeNode* root) {
            vector<int> res, left, right;
            if(root == NULL)
                return res;
            left = postorderTraversal(root->left);
            right = postorderTraversal(root->right);
            for(auto iter = left.begin(); iter != left.end(); iter ++)
                res.push_back(*iter);
            for(auto iter = right.begin(); iter != right.end(); iter ++)
                res.push_back(*iter);
            res.push_back(root->val);
            return res;
        }
    };
    

    非递归

    class Solution {
    public:
        vector<int> postorderTraversal(TreeNode* root) {
            vector<int> res;
            if(root == nullptr)
                return res;
            stack<TreeNode*> nodes;
            nodes.push(root);
            while(!nodes.empty()){
                TreeNode* nowNode = nodes.top();
                nodes.pop();
                if(nowNode != nullptr){        
                    // 根
                    nodes.push(nowNode);
                    nodes.push(nullptr);
                    // 右
                    if(nowNode->right != nullptr)
                        nodes.push(nowNode->right);
                    // 左
                    if(nowNode->left != nullptr)
                        nodes.push(nowNode->left);
                }
                else{
                    res.push_back(nodes.top()->val);
                    nodes.pop();
                }
            }
            return res;
        }
    };
    
  • 相关阅读:
    AOV网和AOE网对比
    AOV网和AOE网对比
    Python类型总结
    Python数据结构
    Django之认证系统
    day22笔记
    数据库概念知识
    pymsql模块使用
    多表查询(子查询)
    多表查询(链接查询)
  • 原文地址:https://www.cnblogs.com/imagineincredible/p/13294153.html
Copyright © 2020-2023  润新知