【leetcode】二叉树刷题记录（一）遍历问题

于 2024-09-03 23:00:33 发布
阅读量200 收藏 3
点赞数 2
文章标签： leetcode 算法 c++ 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73389646/article/details/141871659
版权

【leetcode】二叉树刷题记录（一）遍历问题

文章目录

前言

本文是基于leetcode二叉树例题的学习记录

144. 二叉树的前序遍历

链接
递归版本：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(!root)return ans;
        traversal(root);
        return ans;
    }
    void traversal(TreeNode* root)
    {
        if(!root)return ;
        ans.push_back(root->val);
        traversal(root->left);
        traversal(root->right);
    }
    vector<int> ans;
};

迭代版本：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(!root)return ans;
        traversal(root);
        return ans;
    }
    void traversal(TreeNode* root)
    {
        q.push(root);
        while(!q.empty())
        {
            TreeNode* cur = q.top();
            q.pop();
            ans.push_back(cur->val);
            // 用栈保存要反着来
            if(cur->right)q.push(cur->right);
            if(cur->left)q.push(cur->left);
        }
    }
    vector<int> ans;
    stack<TreeNode*> q;
};

统一迭代版本（不同遍历改动小）：
新学的，链接在这：链接

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

144. 二叉树的中序遍历

链接
递归版本：

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

迭代版本：

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

统一迭代版本（不同遍历改动小）：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

144. 二叉树的后序遍历

链接
递归版本：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(!root)return ans;
        traversal(root);
        return ans;
    }
    void traversal(TreeNode* root)
    {
        if(!root)return ;
        traversal(root->left);
        traversal(root->right);
        ans.push_back(root->val);
    }
    vector<int> ans;
};

迭代版本：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(!root)return ans;
        traversal(root);
        return ans;
    }
    void traversal(TreeNode* root)
    {
        q.push(root);
        while(!q.empty())
        {
            TreeNode* cur = q.top();
            q.pop();
            ans.push_back(cur->val);
            // 用栈保存要反着来
            if(cur->left)q.push(cur->left);
            if(cur->right)q.push(cur->right);
        }
        reverse(ans.begin(), ans.end());
    }
    vector<int> ans;
    stack<TreeNode*> q;
};

这里一开始也没想到，原来把中右左反转以下就是左右中，很巧~

统一迭代版本（不同遍历改动小）：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);

                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

144. 二叉树的层序遍历

链接
前中后用栈（先进后出），层序就用队列啦~（先进先出）

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

递归方式：
没用过，学习一下~
链接

class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

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

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) 
        {
            int size = que.size();
            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);
                if (i == size - 1) result.push_back(node->val);
            }
        }
        return result;
    }
};

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

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        if (!root) {
            return {};
        }

        vector<vector<int>> ans;
        queue<Node*> q;
        q.push(root);

        while (!q.empty()) 
        {
            int cnt = q.size();
            vector<int> level;
            for (int i = 0; i < cnt; ++i) 
            {
                Node* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                for (Node* child: cur->children)
                    q.push(child);
            }
            ans.push_back(move(level));
        }
        return ans;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;
    }
};

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        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) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        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) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) {
                    return depth;
                }
            }
        }
        return depth;
    }
};
FC皇家慕尼黑
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode答案-leetcode:刷题记录
06-30
leetcode刷题记录 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。 给定二叉树: [3,9,20,null,null,...
leetcode:leetcode刷题记录与总结
04-11
《LeetCode刷题记录与总结》 LeetCode，一个广受欢迎的在线编程挑战平台，汇聚了各类算法题目，是程序员提升编程技能、准备面试的重要工具。这篇文档将围绕我在LeetCode上的刷题经历，分享一些关键知识点和学习心得...
javalruleetcode-Leetcode:Leetcode的刷题记录-Java实现
06-29
在这个名为"javalruleetcode-Leetcode"的项目中，作者专注于使用Java语言解决LeetCode中的问题，并记录下易于理解和最优的解决方案。对于学习和提升Java编程技巧，以及准备面试的人来说，这是一个非常有价值的资源。...
LeetCode_java_leetcode_刷题_
09-30
本资料包聚焦于Java语言，整理了150多道LeetCode上的热门问题，是Java开发者进行刷题训练的理想资源。 LeetCode中的题目涵盖了数据结构、算法、设计模式等多个方面，每道题目都分为Easy、Medium、Hard三个难度级别...
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 451
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
Leetcode 1207. Unique Number of Occurrences
小白菜又菜
09-01 201
【代码】Leetcode 1207. Unique Number of Occurrences。
位运算专题——常见位运算&位图的使用&力扣实战应用
最新发布
2401_83595513的博客
09-02 714
位运算专题
力扣（无重叠区间）
yyssas的博客
08-29 7737
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
155. 最小栈【 力扣(LeetCode) 】
yyh520025的博客
09-02 293
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4556
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
leetcode3 无重复字符的最长子串
weixin_44554979的博客
08-30 420
除了每次有重复的要更新 ，如果abc这种，本身就不会重复，那maxLength就永远不会更新了。比如 abccfga, 最后的a其实是没有重复的，因为在处理cc重复的时候abc都已经舍弃了。left跳转位置对了，但是left之前的在map里面的也应该清空啊。对于 abcc,应该直接加3，所以需要记录位置。left不应该是+1，对于abca，是+1。
leetcode_128_最长连续序列解析
shulu的专栏
08-29 1300
如何确定一个数是连续序列的起点？如何跟踪和更新最长序列的长度？如何高效地扩展连续序列？
力扣: 合并两个有序链表
长安初雪的博客
09-02 483
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
力扣1.两数之和（哈希表）
2401_83010439的博客
08-30 535
如果学了几个月算法力扣第一题还用暴力解法就要反思一下了。
leetcode 41.缺失的第一个正数
m0_73917165的博客
08-30 688
思路：首先就是O(n)时间复杂度，O(n)空间复杂度的，其实很简单，我们只需要定义一个哈希表，遍历一遍数组的时候计数数组中的元素就行；如果一个数本身就是负数，我们就把这个负数变成>=N+1的数，这样就不影响我们标记数组位置了。这个时候，当我们标记完之后出现正数的坐标+1就是答案了。那么如果这个数组中的数全都不是在[1,N]内的数，那么我们就会看到最小正整数就应该是1.那么这个区间就自然而然地推理出来在这个范围之内了。我们可以这样想：如果[1,N]的数全在这个数组当中，那么最小的正整数就应该是N+1；
Leetcode 22. 括号生成 回溯 C++实现
半跨考本科生的代码日常
08-28 691
代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且。
leetcode 27. Remove Element
ahahayaa的博客
09-02 1062
但与此同时随着被覆盖的数值本身也占了一个位置 顺序检查的指针只会停留在和目标值不同的位置上 如果发现相同则直接跳过 这时候配合执行的指针还在原地 也就产生了速度快慢的差异。一个指针顺序检查是不是符合数值条件 发现不符合另一个指针直接配合执行覆盖操作。slow指针每一次向前移动 都伴随着合法元素的归位 掌握着新数组的元素顺序。但是使用双指针解法就好像 两个人分工 一个人清点 另一个人执行。所以一个跑得快的负责检查的指针叫fast指针。另一个配合执行的指针叫slow指针。数组移除元素是一个很常见的场景。
力扣第二阶段Days34
m0_51666362的博客
08-29 356
注意不仅要更新left 也要对window中left索引上元素进行清除。的子串，返回这些子串的起始索引。不考虑答案输出的顺序。指由相同字母重排列形成的字符串（包括相同的字符串）。时隔数月，再次刷起力扣。
【NO.17】LeetCode经典150题-13. 罗马数字转整数
wang_luwei的博客
09-02 550
罗马数字转整数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值