LeetCode题解——树（三）

最新推荐文章于 2024-01-17 19:40:50 发布
最新推荐文章于 2024-01-17 19:40:50 发布
阅读量256 收藏
点赞数
分类专栏： LeetCode题解 文章标签： 算法 数据结构 leetcode 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wardseptember/article/details/106639081
版权

文章目录

前中后序遍历

二叉树的前序遍历

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

示例:

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

输出: [1,2,3]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

迭代

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        if (root == null) {
            return new LinkedList<>();
        }
        List<Integer> res = new LinkedList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        stack.addFirst(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.removeFirst();
            res.add(node.val);
            if (node.right != null) {
                stack.addFirst(node.right);
            }
            if (node.left != null) {
                stack.addFirst(node.left);
            }
        }
        return res;
    }
}

二叉树的后序遍历

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

示例:

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

输出: [3,2,1]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

迭代解法1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if (root == null) {
            return new LinkedList<>();
        }
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        stack.addFirst(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.removeFirst();
            res.add(node.val);
            if (node.left != null) {
                stack.addFirst(node.left);
            }
            if (node.right != null) {
                stack.addFirst(node.right);
            }
        }
        Collections.reverse(res);
        return res;
    }
}

迭代解法2

利用LinkedList的性质，可每次插入到链头，相当于翻转。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if (root == null) {
            return new LinkedList<>();
        }
        LinkedList<Integer> res = new LinkedList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        stack.addFirst(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.removeFirst();
            res.addFirst(node.val);
            if (node.left != null) {
                stack.addFirst(node.left);
            }
            if (node.right != null) {
                stack.addFirst(node.right);
            }
        }
        return res;
    }
}

二叉树的中序遍历

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

示例:

输入: [1,null,2,3]
1

2
/
3

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

迭代解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        if (root == null) {
            return new LinkedList<>();
        }
        List<Integer> res = new LinkedList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode node = root;
        while(node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.addLast(node);
                node = node.left;
            }
            node = stack.removeLast();
            res.add(node.val);
            node = node.right;
        }
        return res;
    }
}

BST

修剪二叉搜索树

给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。

示例 1:

输入: 
    1
   / \
  0   2

  L = 1
  R = 2

输出: 
    1
      \
       2
示例 2:

输入: 
    3
   / \
  0   4
   \
    2
   /
  1

  L = 1
  R = 3

输出: 
      3
     / 
   2   
  /
 1

递归算法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode trimBST(TreeNode root, int L, int R) {
        if (root == null) {
            return null;
        }
        if (root.val > R) {
            return trimBST(root.left, L, R);
        }
        if (root.val < L) {
            return trimBST(root.right, L, R);
        }
        root.left = trimBST(root.left, L, R);
        root.right = trimBST(root.right, L, R);
        return root;
    }
}

二叉搜索树中第K小的元素

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
输出: 1
示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 3
进阶：
如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化 kthSmallest 函数？

中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private int cnt = 0;
    private int val;
    public int kthSmallest(TreeNode root, int k) {
        inOrder(root, k);
        return val;
    }
    private void inOrder(TreeNode node, int k) {
        if (node == null) {
            return;
        }
        inOrder(node.left, k);
        cnt++;
        if (cnt == k) {
            val = node.val;
            return;
        }
        inOrder(node.right, k);
    }
}

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int kthSmallest(TreeNode root, int k) {
        int leftCount = count(root.left);
        if (leftCount == k - 1) {
            return root.val;
        }
        if (leftCount > k - 1) {
            return kthSmallest(root.left, k);
        }
        return kthSmallest(root.right, k - leftCount - 1);
    }
    private int count(TreeNode node) {
        if (node == null) {
            return 0;
        }
        return 1 + count(node.left) + count(node.right);
    }
}

把二叉搜索树转换为累加树

给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 原始二叉搜索树:
              5
            /   \
           2     13

输出: 转换为累加树:
             18
            /   \
          20     13

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        traver(root);
        return root;
    }
    private void traver(TreeNode node) {
        if (node == null) {
            return;
        }
        traver(node.right);
        sum += node.val;
        node.val = sum;
        traver(node.left);
    }
}

二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
 

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        int val = root.val;
        if (val > p.val && val > q.val) {
            return lowestCommonAncestor(root.left, p, q);
        }
        if (val < p.val && val < q.val) {
            return lowestCommonAncestor(root.right, p, q);
        }
        return root;
    }
}

二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
 

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        return left == null ? right : right == null ? left : root;
    }
}
推荐阅读

wardseptember
关注
专栏目录
LeetCode题解——700.二叉树搜索树中的搜索
openallzzz
11-26 223
原题链接：LeetCode-700.二叉树搜索树中的搜索 题意： 在解决这道题之前，我们需要了解二叉搜索树(BST, Binary Search Tree) 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与
LeetCode 题解——岛屿数量
fe_watermelon的博客
02-12 5150
大家好，我是前端西瓜哥，今天我们做一道经典算法题——岛屿数量。 LeetCode 上对应题目为 200 题：https://leetcode-cn.com/problems/number-of-islands/ 这道题归属于岛屿问题，是有固定套路的，那就是 Flood fill 算法。 Flood fill 算法 Flood fill 算法是一种特殊的算法，它在一个区域内，从某个点开始往外扩散找到与其联通的所有点，最终获得一个区域块。 从一个点开始覆盖整个区域的过程，因很像洪水淹没一个岛屿的过程，所以被命
LeetCode题解——打家劫舍
yxh_1_的博客
05-05 183
LeetCode题解——打家劫舍 题目介绍 解题思路 这题的解题思路其实和LeetCode题解——删除并获得点数_yxh_1_的博客-CSDN博客一样都是动态规划 假设我现在需要偷窃最后一间房子也就是nums[3],现在要考虑一点到底要不要偷，因为相连两间房，偷了相连的一间就会发生警报。 第一种偷窃nums[3]：也就是偷窃倒数第三间的总金额dp(n-2)加上nums[3]的最后总金额要大于等于偷窃倒数第二次nums[2]的最大总金额dp(n-1)。 第二种不偷窃：和第一种情况相反，偷窃倒数第二
LeetCode题解——移除元素
yxh_1_的博客
05-14 121
LeetCode题解——移除元素 题目介绍 解题思路 这题的解题思路其实和LeetCode题解——删除有序数组中的重复项_yxh_1_的博客-CSDN博客蛮像的 首先我们定义一个index，把index看成我们想要的结果下标，遍历数组，当元素的值与目标值不一样时，那就将元素拷贝到nums[index++] 那么最后到index结束的前面所有的元素都是不包含val的，而新的数组长度就是index+1，也就是原来数组长度减去val出现的次数 代码示例 class Solution { publi
LeetCode题解——有效的括号
yxh_1_的博客
05-14 148
LeetCode题解——有效的括号 题目介绍 解题思路 这题可以从两个角度来考虑，首先第一种寻找删除，在字符串里面查找成对出现的括号，然后用空格替换，最后检查字符串是不是为空 第二种，好比消消乐一样，当正确的配对括号就删除，首先我们创建一个栈，然后遍历字符串 当第一次栈为空，直接将元素字符入栈，然后接下来每次的字符和栈首对比，如果是配对括号，就将栈首出栈，否则入栈，遍历完字符串后，通过查看栈是否为空 第二种比第一种的时间复杂度要好点，但是多了一个栈的空间，相当于空间换时间 代码示例 第一种：
LeetCode题解——加一
yxh_1_的博客
05-15 93
LeetCode题解——加一 题目介绍 解题思路 这题其实只要注意一点就可以了，那就是注意当前数组元素的值是不是9，还有就是99，9这种特殊情况，要在容器的头部多插入一位1 代码示例 class Solution { public: vector<int> plusOne(vector<int>& digits) { vector<int>::iterator it = digits.end()-1; *i.
LeetCode题解——搜索插入位置
yxh_1_的博客
05-14 104
LeetCode题解——搜索插入位置 题目介绍 解题思路 题目的意思是当存在目标元素就返回下标，没有就把目标插入到合适的位置 那么存在的情况很简单，那何时插入元素，可以这么想只有当遇到第一个比目标大的数据才会将数据插入 如果数组里面没有比目标数据大的，那就插入到最后 代码示例 class Solution { public: int searchInsert(vector<int>& nums, int target) { int len= nums.
LeetCode题解——汉明距离
yxh_1_的博客
05-27 222
LeetCode题解——汉明距离 题目介绍 解题思路 这题的思路就是找到两个数二进制位不相同的个数 我们可以很容易用x^y的结果来表示二进制位不相同的情况，因为^的作用是相同为0，不相同为1 那么异或的结果里面有多少个1，就有多少不相同的个数 代码示例 class Solution { public: int hammingDistance(int x, int y) { int tag = x^y; int res = 0; while(
LeetCode题解——两数相加
yxh_1_的博客
05-17 208
LeetCode题解——两数相加 题目介绍 解题思路 同时遍历l1和l2，计算两个节点的数据和，注意一下进位 利用递归的方式遍历，只有当两个链表的next都为空的时候返回，但是返回时要看一下有没有上个节点的进位，没有就返回NULL，否则返回值为1的节点 代码示例 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode()
Leetcode题解——26.树的子结构
weixin_61857742的博客
08-31 307
如果False，再开始将B树顶与A剩下节点匹配，直到True或A全部匹配结束False。当A中节点与B的树顶匹配时，再匹配B中剩下节点，全部一致True;该函数的中心思想是查看此时AB节点是否匹配，若匹配就继续判断A左B左以及A右B右。当B节点到空时，此时说明B中某一分支已经匹配完毕且与A完全一致，直接返回True。需要注意的是，递归时，左右子树的关系是或，当左或右有一个能有B树匹配即可。当A节点空时（B不空），此时说明A与B并不匹配，返回False。②此时节点与B树顶不匹配，直接递归A节点左右子树。...
leetcode题解——hot100easy题
ukhgg的博客
10-10 254
动态规划、递归
LeetCode题解——删除并获得点数
yxh_1_的博客
05-05 298
LeetCode题解——删除并获得点数 题目介绍 解题思路 这是一类动态规划的题目，假设nums = [2,2,3,3,3,4]，我们进行一次映射转换sum[0,0,4,9,4],第一行是sum下标也是nums的值，第二行是sum值，那题目的意思可以转换为sum数组，相连的两个数不能同时取，求sum里面元素怎么相加才能最大。 0 1 2 3 4 0 0 2*2 = 4 3*3 = 9 1*4 = 4 那么最后一次相加求和，对于要不要加上s.
python/c++ Leetcode题解——2744. 最大字符串配对数目
最新发布
weixin_68756152的博客
01-17 191
我们可以直接使用二重循环，枚举给定的数组 words 中的 words[i] 和 words[j] 是否可以匹配。由于题目规定了数组 words 中包含的字符串互不相同，因此在枚举时，只要保证 i
LeetCode题解——与数组中元素的最大异或值
yxh_1_的博客
05-23 418
LeetCode题解——与数组中元素的最大异或值 题目介绍 解题思路 这题的解题思路路和LeetCode题解——数组中两个数的最大异或值_yxh_1_的博客-CSDN博客基本一致，区别在于多了限制值，找到的值要小于limit 第一种暴力解法，双重循环时间复杂度O(n*m)，但是可能会超时 第二种字典树，我们先要知道一点，异或就是相同为0，否则为1，那么我们随机给出一个数nums[i]怎么让它的异或结果最大呢，是不是要选择一个和num[i]二进制位数基本相反的，就是你是1，那我就选0 比如nums
字符串面试题总结（终极版）
wardseptember的博客
11-24 2565
文章目录有效的字母异位词解法最长回文串解法同构字符串解法回文子串解法回文数解法计数二进制子串解法剑指 Offer 58 - I. 翻转单词顺序解法剑指 Offer 58 - II. 左旋转字符串解法剑指 Offer 67. 把字符串转换成整数解法 有效的字母异位词 242. 有效的字母异位词 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 示例 1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat
LeetCode题解——树(一)
wardseptember的博客
06-05 1649
文章目录递归二叉树的最大深度递归解法非递归解法平衡二叉树解法二叉树的直径解法翻转二叉树递归解法合并二叉树递归解法路径总和递归解法路径总和 III解法另一个树的子树递归解法推荐阅读 递归 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。
LeetCode题解——二分查找
wardseptember的博客
10-15 1423
69. x 的平方根 实现 int sqrt(int x) 函数。 计算并返回 x 的平方根，其中 x 是非负整数。 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。 二分法 class Solution { ...
LeetCode题解——数组(一)
wardseptember的博客
07-07 1338
文章目录移动零解法重塑矩阵解法最大连续1的个数解法搜索二维矩阵 II解法有序矩阵中第K小的元素二分查找法堆排序错误的集合解法寻找重复数双指针推荐阅读 移动零 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 解法 class Solution { public void moveZeroes(int[] num
LeetCode题解——数学问题（一）
wardseptember的博客
05-17 762
文章目录计算质数最大公约数最小公倍数二进制求和字符串相加最少移动次数使数组元素相等 II先排序再计算快速选择找到中位数多数元素排序找中间那个数Boyer-Moore Majority Vote Algorithm有效的完全平方数3的幂直接法除自身以外数组的乘积三个数的最大乘积推荐阅读 计算质数 统计所有小于非负整数 n 的质数的数量。 示例: 输入: 10 输出: 4 解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。 class Solution { public int
LeetCode题解：二叉查找树与独特BST
LeetCode题解部分给出了作者戴方勤对这个问题的C++11实现，代码简洁高效，遵循了使代码尽可能短的原则，利用递归和STL库来解决问题。此外，书中还强调了在编写代码时的一些考虑，如避免不必要的防御式编程，以及适应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值