代码随想录第十一天|递归遍历、迭代遍历、统一迭代、层序遍历

于 2024-08-28 10:31:29 发布
阅读量322 收藏 4
点赞数 9
文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vectorbullet/article/details/141625966
版权

递归遍历

思路：递归三要素：确定参数及返回值、终止条件、单层递归逻辑。前中后序的递归遍历只需要交换单层递归中的操作顺序即可。

144. 二叉树的前序遍历

题解：

class Solution {
public:
    void traversal(TreeNode* root, vector<int> &vec)
    {
        if (root == nullptr)
            return;
        vec.push_back(root->val);
        traversal(root->left, vec);
        traversal(root->right, vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

145. 二叉树的后序遍历

题解：

class Solution {
public:
    void traversal(TreeNode* root, vector<int> &vec)
    {
        if (root == nullptr)
            return;
        traversal(root->left, vec);
        traversal(root->right, vec);
        vec.push_back(root->val);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

94. 二叉树的中序遍历

题解：

class Solution {
public:
    void traversal(TreeNode *cur, vector<int> &vec)
    {
        if (cur == nullptr)
            return;
        traversal(cur->left, vec);
        vec.push_back(cur->val);
        traversal(cur->right, vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

589. N叉树的前序遍历

题解：

class Solution {
public:
    void traversal(Node* root, vector<int> &vec)
    {
        if (root == nullptr) return;
        vec.push_back(root->val);
        for (auto it : root->children)
            traversal(it, vec);
    }
    vector<int> preorder(Node* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

590,N 叉树的后序遍历

题解：

class Solution {
public:
    void traversal(Node* root, vector<int> &vec)
    {
        if (root == nullptr) return;
        for (auto it : root->children)
            traversal(it, vec);
        vec.push_back(root->val);
    }

    vector<int> postorder(Node* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

迭代遍历

思路：访问节点从根节点开始，前序遍历和后序遍历（左右中=reverse(中右左)）处理节点和访问节点是相同的，而中序遍历不同，比较特殊，由于是用栈模拟递归，要考虑栈先进后出的特性，注意元素的存入顺序。

144. 二叉树的前序遍历

题解：

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

145. 二叉树的后序遍历

题解：

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

94. 二叉树的中序遍历

题解：

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

统一迭代

思路：为了处理访问节点和处理节点不同的问题，我们把访问节点和处理节点都压入栈中，但在处理节点后多压入一个nullptr，打上标记，遇见标记才进行处理。

144. 二叉树的前序遍历

题解：

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

145. 二叉树的后序遍历

题解：

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

94. 二叉树的中序遍历

题解：

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

层序遍历

思路：一层一层遍历和queue先进先出的特性吻合，注意每层遍历时，栈内元素的数目会变换，我们需要提前记录每层元素的数目。

102. 二叉树的层序遍历

题解：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> subres;
            for(int i=0; i<size; ++i)
            {
                TreeNode* node = que.front();
                que.pop();
                subres.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(subres);
        }
        return res;
    }
};

107.二叉树的层次遍历II

题解：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> subres;
            for(int i = 0; i < size; ++i)
            {
                TreeNode* node = que.front();
                que.pop();
                subres.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(subres);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

199.二叉树的右视图

题解：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            res.push_back(que.back()->val);
            for (int i = 0; i < size; ++i)
            {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return res;
    }
};

637.二叉树的层平均值

题解：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> res;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            long long sum = 0;
            for (int i = 0; i < size; ++i)
            {
                TreeNode* node = que.front();
                que.pop();
                sum += (node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            double subres = (double) sum / size;
            res.push_back(subres);
        }
        return res;
    }
};

429.N叉树的层序遍历

题解：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<vector<Node*>> que;
        vector<vector<int>> res;
        if (root != nullptr) que.push(vector<Node*>{root});
        while(!que.empty())
        {
            int size = que.size();
            vector<int> subres;
            for (int i=0; i<size; ++i)
            {
                vector<Node*> children = que.front();
                for (int j=0; j<children.size(); ++j)
                {
                    subres.push_back(children[j]->val);
                    if (!(children[j]->children).empty()) que.push(children[j]->children);
                }
                que.pop();
            }
            res.push_back(subres);
        }
        return res;
    }
};

515.在每个树行中找最大值

题解：

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            int max = INT_MIN;
            for (int i=0; i<size; ++i)
            {
                TreeNode *node = que.front();
                max = max > (node->val) ? max : (node->val);
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(max);
        }
        return res;
    }
};

116.填充每个节点的下一个右侧节点指针

题解：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for (int i = 0; i < size; ++i)
            {
                Node* node = que.front();
                que.pop();
                node -> next = i == size - 1? nullptr : que.front();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

117.填充每个节点的下一个右侧节点指针II

题解：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for (int i = 0; i < size; ++i)
            {
                Node* node = que.front();
                que.pop();
                node -> next = i == size - 1? nullptr : que.front();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;      
    }
};

104.二叉树的最大深度

题解：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int res{0};
        if(root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            ++res;
            for (int i = 0; i < size; ++i)
            {
                TreeNode *node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return res;
    }
};

111.二叉树的最小深度

题解：

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth{0};
        if (root != nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            ++depth;
            for (int i = 0; i < size; ++i)
            {
                TreeNode* node = que.front();
                que.pop();
                if (!node->left && !node->right) return depth;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};
萌薪
关注
代码随想录算法训练营Day11 | 递归遍历，迭代遍历，统一迭代，层序遍历
little__penguin的博客
06-21 406
代码随想录Day14|递归遍历、迭代遍历、统一遍历
weixin_43399717的博客
05-24 331
后面在介绍图论的时候 还会介绍到。在深度优先遍历中：有三个顺序，前中后序遍历， 有同学总分不清这三个顺序，经常搞混，我这里教大家一个技巧。，只要大家记住 前中后序指的就是中间节点的位置就可以了。看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式。
代码随想录算法训练营第11天|递归遍历、迭代遍历、统一迭代、层序遍历
最新发布
summersnowzgq的博客
06-23 743
1.确定递归函数的参数和返回值：2.确定终止条件3.确定单层递归的逻辑针对前中后遍历，递归逻辑基本一致，只是递归的顺序不一致。
二叉树的遍历（含统一格式遍历）
Loser
05-20 473
//非递归前序遍历 void preorderTraversal(TreeNode *root, vector&lt;int&gt; &amp;path) { stack&lt;TreeNode *&gt; s; TreeNode *p = root; while(p != NULL || !s.empty()) { while(p != NULL)...
算法 二叉树1 || 递归遍历 迭代遍历 统一迭代
weixin_43896452的博客
03-29 191
算法
迭代实现二叉树的遍历（统一风格）
BaiHang111的博客
11-22 483
二叉树，遍历，迭代
二叉树的前、中、后序遍历统一写法
wxgaws的博客
12-15 231
参考 帮你对二叉树不再迷茫，彻底吃透前中后序递归法（递归三部曲）和迭代法（不统一写法与统一写法） 二叉树的前、中、后序遍历（递归与非递归） 算法 通过插入标志符，来标记需要输出哪个元素。 确定输出顺序。首次遍历结点A时，将A和其左右子结点按照遍历顺序插入到栈中，A结点后需要插入标志符。 输出结点元素。如果当前栈顶元素是标志符，说明A结点该输出了，输出A结点即可。 参考博文1中，用null作为标志符，这在要求输出空结点时不可行，标志符和空结点会发生冲突。要解决冲突，只需自定义标志即可。 前序遍历 pu
二叉树：理论基础 递归遍历 迭代遍历 统一迭代
m0_59425585的博客
11-27 850
迭代方法还需要多理解。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
代码随想录训练营第十四天 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
Sherry_Sky的博客
11-30 279
代码随想录训练营打卡Day14 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
代码随想录算法训练营第14天 | LeetCode144.二叉树的前序遍历，145.二叉树的后序遍历，94.二叉树的中序遍历 (递归加迭代法，以及统一迭代法)
weixin_46724054的博客
03-14 85
代码随想录算法训练营第14天 | LeetCode144.二叉树的前序遍历，145.二叉树的后序遍历，94.二叉树的中序遍历 (递归加迭代法，以及统一迭代法)
遍历二叉树的统一迭代法
m0_74989367的博客
05-13 606
普通迭代遍历方式无法同时解决和处理节点不一致的情况,前中后序的迭代法，那么如何实现统一的代码写法呢
二叉树的统一非递归遍历方式
m0_72940975的博客
03-08 87
二叉树前中后序的统一非递归遍历方式
二叉树统一迭代法解析
罟霖同学的站点
01-10 1072
二叉树的统一迭代法有两个要点：1.确定入栈顺序；2.放置占位符来区分是否要探索当前根节点的子树。
二叉树非递归遍历的统一写法（前序，中序，后续，层序）
qq_44194231的博客
08-20 198
前，中，后序遍历 这种写法是相反的，比如说前序，在代码里相应部分的顺序是右中左 前中后都可以用这个模板，改变一下顺序就可以了 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { vector<int> res; stack<TreeNode*> s; if(root!=nullptr) s.push(root); .
二叉树的非递归统一遍历形式
曾经当程序员的日子
03-27 634
核心思想是： 有交集的局部有序会导致全局有序！！！ void preorderTraversalNew(TreeNode *root, vectorint> &path) { stack pairTreeNode *, bool> > s; s.push(make_pair(root, false)); bool visited; while(!s
二叉树遍历统一写法（迭代法）
qq_52025040的博客
05-11 195
先序遍历 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { vector<int> res; stack<TreeNode*> st; if (root != nullptr) { st.push(root); } while (!st.empty()) {
二叉树的统一迭代法
weixin_44832243的博客
05-17 80
以中序遍历为例，使用栈的话，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值