leetcode算法面试题：二叉树相关问题汇总（层序遍历、后序遍历、前序遍历、右视图、中序遍历、最大深度、最小深度、展开为链表、最大路径和、二叉搜索树）

最新推荐文章于 2025-01-16 16:31:47 发布
最新推荐文章于 2025-01-16 16:31:47 发布
阅读量64 收藏
点赞数 1
分类专栏： 算法面试精选汇编 文章标签： 算法 leetcode 链表

二叉树的层序遍历1

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：

二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层序遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

参考答案

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

二叉树层序遍历2

给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如： 给定二叉树 [3,9,20,null,null,15,7],

  3
 / \
9  20
  /  \
 15   7

返回其自底向上的层序遍历为：

[
  [15,7],
  [9,20],
  [3]
]

参考答案

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

二叉树后序遍历

给定一个二叉树，返回它的 后序 遍历。

示例:

输入: [1,null,2,3]  
   1
    \
     2
    /
   3 
​
输出: [3,2,1]

参考答案

class Solution {
public:
    void addPath(vector<int> &vec, TreeNode *node) {
        int count = 0;
        while (node != nullptr) {
            ++count;
            vec.emplace_back(node->val);
            node = node->right;
        }
        reverse(vec.end() - count, vec.end());
    }
 
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        if (root == nullptr) {
            return res;
        }
 
        TreeNode *p1 = root, *p2 = nullptr;
 
        while (p1 != nullptr) {
            p2 = p1->left;
            if (p2 != nullptr) {
                while (p2->right != nullptr && p2->right != p1) {
                    p2 = p2->right;
                }
                if (p2->right == nullptr) {
                    p2->right = p1;
                    p1 = p1->left;
                    continue;
                } else {
                    p2->right = nullptr;
                    addPath(res, p1->left);
                }
            }
            p1 = p1->right;
        }
        addPath(res, root);
        return res;
    }
};

二叉树的锯齿形层序遍历

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如： 给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回锯齿形层序遍历如下：

  [
    [3],
    [20,9],
    [15,7]
  ]

参考答案

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if (!root) {
            return ans;
        }
 
        queue<TreeNode*> nodeQueue;
        nodeQueue.push(root);
        bool isOrderLeft = true;
 
        while (!nodeQueue.empty()) {
            deque<int> levelList;
            int size = nodeQueue.size();
            for (int i = 0; i < size; ++i) {
                auto node = nodeQueue.front();
                nodeQueue.pop();
                if (isOrderLeft) {
                    levelList.push_back(node->val);
                } else {
                    levelList.push_front(node->val);
                }
                if (node->left) {
                    nodeQueue.push(node->left);
                }
                if (node->right) {
                    nodeQueue.push(node->right);
                }
            }
            ans.emplace_back(vector<int>{levelList.begin(), levelList.end()});
            isOrderLeft = !isOrderLeft;
        }
 
        return ans;
    }
};

二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

提示：

  • 树中节点数目在范围 [0, 100] 内

  • -100 <= Node.val <= 100

class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        if (root == nullptr) {
            return res;
        }
 
        TreeNode *p1 = root, *p2 = nullptr;
 
        while (p1 != nullptr) {
            p2 = p1->left;
            if (p2 != nullptr) {
                while (p2->right != nullptr && p2->right != p1) {
                    p2 = p2->right;
                }
                if (p2->right == nullptr) {
                    res.emplace_back(p1->val);
                    p2->right = p1;
                    p1 = p1->left;
                    continue;
                } else {
                    p2->right = nullptr;
                }
            } else {
                res.emplace_back(p1->val);
            }
            p1 = p1->right;
        }
        return res;
    }
};

二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
​
   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

参考答案

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        unordered_map<int, int> rightmostValueAtDepth;
        int max_depth = -1;
 
        queue<TreeNode*> nodeQueue;
        queue<int> depthQueue;
        nodeQueue.push(root);
        depthQueue.push(0);
 
        while (!nodeQueue.empty()) {
            TreeNode* node = nodeQueue.front();nodeQueue.pop();
            int depth = depthQueue.front();depthQueue.pop();
 
            if (node != NULL) {
            	// 维护二叉树的最大深度
                max_depth = max(max_depth, depth);
 
                // 由于每一层最后一个访问到的节点才是我们要的答案，因此不断更新对应深度的信息即可
                rightmostValueAtDepth[depth] =  node -> val;
 
                nodeQueue.push(node -> left);
                nodeQueue.push(node -> right);
                depthQueue.push(depth + 1);
                depthQueue.push(depth + 1);
            }
        }
 
        vector<int> rightView;
        for (int depth = 0; depth <= max_depth; ++depth) {
            rightView.push_back(rightmostValueAtDepth[depth]);
        }
 
        return rightView;
    }
};

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的 中序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[2,1]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

提示：

  • 树中节点数目在范围 [0, 100] 内

  • -100 <= Node.val <= 100

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;
    }
};

二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例： 给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

参考答案

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

二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

树中节点数的范围在 [0, 105] 内 -1000 <= Node.val <= 1000

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }
 
        queue<pair<TreeNode *, int> > que;
        que.emplace(root, 1);
        while (!que.empty()) {
            TreeNode *node = que.front().first;
            int depth = que.front().second;
            que.pop();
            if (node->left == nullptr && node->right == nullptr) {
                return depth;
            }
            if (node->left != nullptr) {
                que.emplace(node->left, depth + 1);
            }
            if (node->right != nullptr) {
                que.emplace(node->right, depth + 1);
            }
        }
 
        return 0;
    }
};

二叉树展开为链表

给你二叉树的根结点 root ，请你将它展开为一个单链表：

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。 展开后的单链表应该与二叉树 先序遍历 顺序相同。

示例 1：

输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [0]
输出：[0]

提示：

树中结点数在范围 [0, 2000] 内 -100 <= Node.val <= 100

参考答案

class Solution {
public:
    void flatten(TreeNode* root) {
        TreeNode *curr = root;
        while (curr != nullptr) {
            if (curr->left != nullptr) {
                auto next = curr->left;
                auto predecessor = next;
                while (predecessor->right != nullptr) {
                    predecessor = predecessor->right;
                }
                predecessor->right = curr->right;
                curr->left = nullptr;
                curr->right = next;
            }
            curr = curr->right;
        }
    }
};

二叉树的最大路径和

路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

路径和 是路径中各节点值的总和。

给你一个二叉树的根节点 root ，返回其 最大路径和 。

示例 1：

输入：root = [1,2,3]
输出：6
解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6

示例 2：

输入：root = [-10,9,20,null,null,15,7]
输出：42
解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42

提示：

  • 树中节点数目范围是 [1, 3 * 104]

  • -1000 <= Node.val <= 1000

参考答案

class Solution {
private:
    int maxSum = INT_MIN;
 
public:
    int maxGain(TreeNode* node) {
        if (node == nullptr) {
            return 0;
        }
        
        // 递归计算左右子节点的最大贡献值
        // 只有在最大贡献值大于 0 时，才会选取对应子节点
        int leftGain = max(maxGain(node->left), 0);
        int rightGain = max(maxGain(node->right), 0);
 
        // 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值
        int priceNewpath = node->val + leftGain + rightGain;
 
        // 更新答案
        maxSum = max(maxSum, priceNewpath);
 
        // 返回节点的最大贡献值
        return node->val + max(leftGain, rightGain);
    }
 
    int maxPathSum(TreeNode* root) {
        maxGain(root);
        return maxSum;
    }
};

二叉搜索树迭代器

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：

  • BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。

  • boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。

  • int next()将指针向右移动，然后返回指针处的数字。 注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。

你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

示例：

输入
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
输出
[null, 3, 7, true, 9, true, 15, true, 20, false]
​
解释
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
bSTIterator.next();    // 返回 3
bSTIterator.next();    // 返回 7
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 9
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 15
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 20
bSTIterator.hasNext(); // 返回 False

提示：

  • 树中节点的数目在范围 [1, 105] 内

  • 0 <= Node.val <= 106

  • 最多调用 105 次 hasNext 和 next 操作

参考答案

class BSTIterator {
private:
    TreeNode* cur;
    stack<TreeNode*> stk;
public:
    BSTIterator(TreeNode* root): cur(root) {}
    
    int next() {
        while (cur != nullptr) {
            stk.push(cur);
            cur = cur->left;
        }
        cur = stk.top();
        stk.pop();
        int ret = cur->val;
        cur = cur->right;
        return ret;
    }
    
    bool hasNext() {
        return cur != nullptr || !stk.empty();
    }
};
二叉树遍历算法-递归、迭代(深度优先搜索、广度优先搜索)
qq_39568387的博客
06-30 1184
二叉树的遍历方法，有递归和迭代（非递归）本篇做全面介绍！！
【二叉树】- 层序遍历（ js 实现）
yan的秘密基地
08-07 1569
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。 这种遍历的方式和我们之前学习的都不太一样。 需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。 而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。 使用队列实现二叉树广度优先遍历...
【算法练习】leetcode算法题合集之二叉树篇
秋装什么的博客
01-08 1223
【算法练习】leetcode算法题合集之二叉树篇
leetcode二叉树遍历与递归题目汇总
书生的日常
03-11 1077
目录 1.前序遍历 2.中序遍历 3.后序遍历 4.总结规律 5.层次遍历 二叉树的遍历是二叉树的基本操作。 对于一颗二叉树，其主要的遍历形式有四种：前序遍历、中序遍历、后序遍历、层次遍历。 以一颗形状如下的二叉树为例 1.前序遍历 前序遍历执行的是中左右的遍历原则，即先遍历中间的根节点，然后左节点，最后右节点。这样获得的遍历顺序为：1245367 前序遍历的代码利用了递...
LeetCode刷题笔记：二叉树前序遍历、中序遍历、后序遍历和层序遍历 | 递归法 | 迭代法 | 统一迭代法 | 深度优先搜索 | 广度优先搜索
神马都会亿点点的毛毛张
05-18 925
Problem:144. 二叉树的前序遍历Problem:94.二叉树的中序遍历Problem:145.二叉树的后序遍历Problem:102. 二叉树的层序遍历Problem:107. 二叉树的层序遍历 II二叉树的遍历方式有多种，毛毛张今天在这里结合代码随想录的教程来分享一下二叉树的多种遍历方式及代码实现深度优先遍历和广度优先遍历。
【算法-LeetCode】103. 二叉树的锯齿形层序遍历（二叉树；层序遍历；BFS）
赖念安的博客
09-23 251
103. 二叉树的锯齿形层序遍历 - 力扣（LeetCode） 发布：2021年9月23日21:19:26 问题描述及示例 给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 给定二叉树 [3,9,20,null,null,15,7],   3  / \ 9  20   /  \  15   7 返回锯齿形层序遍历如下： [
面试必考真题-算法篇：请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图
gaozhuang63的博客
12-16 764
面试必考真题-算法篇 牛客网 树 题目描述 请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图 题目分析： 首先利用二叉树的前序和中序遍历结果重建该二叉树，之后利用层次遍历，找到每层最右侧的节点，同时将其加入ArrayList中，最后转换为int数组即可。 下面是Java代码 import java.util.*; public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 求二叉树
【LeetCode】专题一 二叉树层序遍历
weixin_51630192的博客
12-10 1951
【LeetCode】专题一 二叉树层序遍历
Python数据结构与算法篇（十五）-- 二叉树的遍历：深度优先搜索与广度优先搜索
CarpeDiem
05-24 3852
本篇带你走进二叉树，使用深度优先搜索和广度优先搜索思想进行二叉树的顺序遍历和层序遍历，带你刷遍LeetCode上的二叉树遍历题目。
Python 数据结构之二叉树：二叉树的遍历：DFS 深度优先（先序遍历、中序遍历、后续遍历）和 BFS 广度优先遍历。
CaoChengtai的博客
04-16 2107
1. 二叉树： 二叉树是一种常用的数据结构，是树这种数据机构的一种特例。它最多只有两个子节点，且如果有两个子节点，两个子节点之间是有顺序的，一个称为左孩子节点，一个称为右孩子节点。 每个节点的构造如下： class TreeNode: def __init__(self, x): self.val = x self.left = None s...
刷算法Leetcode---8（二叉树篇）（层序遍历）
m0_70220973的博客
07-01 826
Leetcode刷算法之二叉树篇（层序遍历）~
算法分析之二叉树遍历
小朱小朱绝不认输的博客
12-14 3153
二叉树的基础知识已经在上一篇文章算法分析之二叉树学习过了，这篇文章主要是二叉树的遍历方式，包括递归和迭代版本。 文章目录一、二叉树的遍历二、二叉树的递归遍历1. 二叉树的前序遍历2. 二叉树的中序遍历3. 二叉树的后序遍历三、二叉树的迭代遍历1. 二叉树的前序遍历2. 二叉树的中序遍历3. 二叉树的后序遍历四、二叉树的层序遍历1. 层序遍历的迭代实现2. leetcode关于层序遍历的算法107. 二叉树的层序遍历 II199. 二叉树的右视图 一、二叉树的遍历 二叉树的遍历方式主要有两种： 深度优先遍历
数据结构——二叉树层序遍历
weixin_61015911的博客
04-29 1216
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历。层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。输入：root = [3,9,20,null,null,15,7]输入: [1,2,3,null,5,null,4]输出：[[15,7],[9,20],[3]]输出: [1,3,4]
二叉树的层序遍历(js)
weixin_45805570的博客
08-06 890
除了先序、中序、后序三种遍历外，还有一个层序遍历，所谓层序遍历就是按照每一层的顺序遍历整棵树（也就是说一层一层，从左往右遍历下来） 迭代法 层序遍历采用配合队列的方式来实现，其原因是它是从左往右遍历的，所以队列这种数据结构非常适合它。 var levelOrder = function(root) { if (!root) { return []; } var res = [];
代码随想录算法训练营第 5 天（哈希表1）| 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和
YOLO的博客
01-13 1121
242.有效的字母异位词当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法数据小用数组，数据大用set，数据比较散用map。
【优选算法篇】：深入浅出位运算--性能优化的利器
2301_82347435的博客
01-12 850
位运算（Bitwise operation）是直接对整数在内存中的二进制位进行操作的运算。在计算机编程中，位运算非常高效，因为它们直接在二进制层面上操作数据，能够以较少的操作实现复杂的逻辑。下面是几种常用的位运算符号讲解。
【LC】2270. 分割数组的方案数
世界就是一个巨大的草台班子
01-13 400
给你一个下标从开始长度为n的整数数组nums。如果以下描述为真，那么nums在下标i处有一个i + 1n - i - 1ii请你返回nums中的方案数。2总共有 3 种不同的方案可以将 nums 分割成两个非空的部分：- 在下标 0 处分割 nums。那么第一部分为 [10] ，和为 10。第二部分为 [4,-8,7] ，和为 3。因为 10 >= 3 ，所以 i = 0 是一个合法的分割。- 在下标 1 处分割 nums。那么第一部分为 [10,4] ，和为 14。
算法【Java】—— 动态规划之子数组问题
最新发布
熵减玩家
01-16 600
算法【Java】—— 动态规划之子数组问题
Java面试题解：掌握LeetCode第199题二叉树右视图
资源摘要信息:"Java面试-leetcode题解之第199题二叉树的右视图.zip" 在当今的IT行业中，掌握编程技能并能够在面试中展现自己的技术能力是求职成功的关键。本资源包专注于Java编程语言，并通过leetcode上的一道具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值