【力扣（二）】二叉树、二叉搜索树复习（1）

心海非海_

已于 2022-04-13 16:27:09 修改

阅读量403

点赞数

分类专栏：数据结构与算法文章标签： leetcode 算法二叉树 BST

于 2022-03-10 23:55:30 首次发布

本文链接：https://blog.csdn.net/weixin_46644403/article/details/123364173

版权

数据结构与算法专栏收录该内容

51 篇文章 7 订阅

订阅专栏

本文汇总了关于二叉树的多个经典算法问题，包括翻转二叉树、填充每个节点的下一个右侧节点指针、将二叉树展开为链表、构建最大二叉树以及从遍历序列构造二叉树等。此外，还涉及二叉树的节点计数、查找重复子树、计算直径、在BST中查找和操作元素等。这些算法对于理解和操作二叉树至关重要。

摘要由CSDN通过智能技术生成

文章目录

1. 翻转二叉树（简单）

地址: https://leetcode-cn.com/problems/invert-binary-tree/
2022/03/08

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

2. 填充每个节点的下一个右侧节点指针（中等）

地址: https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        connectTwo(root.left, root.right);
        return root;
    }

    void connectTwo(Node a, Node b) {
        if (a == null || b == null) {
            return;
        }
        a.next = b;
        connectTwo(a.left, a.right);
        connectTwo(a.right, b.left);
        connectTwo(b.left, b.right);
    }
}

3. 二叉树展开为链表（中等）

地址: https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/

class Solution {
    public void flatten(TreeNode root) {
        if (root == null) {
            return;
        }
        flatten(root.left);
        flatten(root.right);

        TreeNode tmp = root.right;
        root.right = root.left;
        root.left = null;
/*
        TreeNode p = root;
        while (p.right != null) {
            p = p.right;
        }

        p.right = tmp;
*/
        while (root.right != null) {
            root = root.right;
        }
        root.right = tmp;
    }
}

4. 最大二叉树（中等）

地址: https://leetcode-cn.com/problems/maximum-binary-tree/

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return build(nums, 0, nums.length - 1);
    }

    TreeNode build(int[] nums, int lo, int hi) {
        if (lo > hi) {
            return null;
        }
        int res = 0, max = Integer.MIN_VALUE;
        for (int i = lo; i <= hi; i++) {
            if (nums[i] > max) {
                max = nums[i];
                res = i;
            }
        }
        TreeNode root = new TreeNode(max);
        root.left = build(nums, lo, res - 1);
        root.right = build(nums, res + 1, hi);
        return root;
    }
}

5. 从前序与中序遍历序列构造二叉树（中等）

2020 近半年在字节跳动算法面试环节出现过高达 14 次
地址: https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
2022/03/09

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(preorder, 0, preorder.length - 1,
            inorder, 0, inorder.length - 1);
    }

    TreeNode build(int[] preorder, int preStart, int preEnd,
            int[] inorder, int inStart, int inEnd) {
        if (preStart > preEnd || inStart > inEnd) {
            return null;
        }

        int res = preorder[preStart], index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (res == inorder[i]) {
                index = i;
                break;
            }
        }

        int leftSize = index - inStart;
        TreeNode root = new TreeNode(res);
        root.left = build(preorder, preStart + 1, preStart + leftSize,
            inorder, inStart, index - 1);
        root.right = build(preorder, preStart + leftSize + 1, preEnd,
            inorder, index + 1, inEnd);
        return root;
    }
}

6. 从中序与后序遍历序列构造二叉树（中等）

地址: https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return build(inorder, 0, inorder.length - 1,
            postorder, 0, postorder.length - 1);
    }
    TreeNode build(int[] inorder, int inStart, int inEnd,
        int[] postorder, int postStart, int postEnd) {
            if (inStart > inEnd || postStart > postEnd) {
                return null;
            }
            
            int res = postorder[postEnd], index = 0;
            for (int i = inStart; i <= inEnd; i++) {
                if (inorder[i] == res) {
                    index = i;
                    break;
                }
            }

            int leftsize = index - inStart;
            TreeNode root = new TreeNode(res);
            root.left = build(inorder, inStart, index - 1,
                postorder, postStart, postStart + leftsize - 1);
            root.right = build(inorder, index + 1, inEnd,
                postorder, postStart + leftsize, postEnd - 1);
            return root;
        }
}

7. 计算一棵二叉树有多少个节点

地址: https://mp.weixin.qq.com/s/LJbpo49qppIeRs-FbgjsSQ

int count(TreeNode root) {
	if (root == null) {
		return 0;
	}
	int leftsize = count(root.left);
	int rightsize = count(root.right);
	int res = leftsize + rightsize + 1;
	return res;
}

8. 寻找重复的子树（中等）

地址: https://leetcode-cn.com/problems/find-duplicate-subtrees/

class Solution {
    List<TreeNode> res = new LinkedList<>();
    Map<String, Integer> memo = new HashMap<>();

    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        reverse(root);
        return res;
    }
    String reverse(TreeNode root) {
        if (root == null) {
            return "#";
        }

        String left = reverse(root.left);
        String right = reverse(root.right);

        String subTree = left + right + root.val;

        int flag = memo.getOrDefault(subTree, 0);
        if (flag == 1) {
            res.add(root);
        } 
        memo.put(subTree, flag + 1);
        return subTree;
    }
}

深入学习序列化二叉树相关！

9. 二叉树的直径（中等）

地址: https://leetcode-cn.com/problems/diameter-of-binary-tree/

class Solution {
    int maxDiameter = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        maxDepth(root);
        return maxDiameter;
    }
    int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth);
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

10. BST 第 K 小的元素（中等）

地址: https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/
2022/03/10

class Solution {
    int res = 0, i = 0;
    public int kthSmallest(TreeNode root, int k) {
        traverse(root, k);
        return res;
    }
    void traverse(TreeNode root, int k) {
        if (root == null) {
            return;
        }
        traverse(root.left, k);
        i++;
        if (i == k) {
            res = root.val;
        }
        traverse(root.right, k);
    }
}

11. 二叉搜索树转化累加树（中等）

地址: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/

class Solution {
    int sum = 0;
    public TreeNode bstToGst(TreeNode root) {
        traverse(root);
        return root;
    }
    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        traverse(root.right);
        sum += root.val;
        root.val = sum;
        traverse(root.left);
    }
}

12. 验证二叉搜索树（中等）

地址: https://leetcode-cn.com/problems/validate-binary-search-tree/

class Solution {
    public boolean isValidBST(TreeNode root) {
        return traverse(root, null, null);
    }
    boolean traverse(TreeNode root, TreeNode min, TreeNode max) {
        if (root == null) {
            return true;
        }
        if (min != null && root.val <= min.val) {
            return false;
        }
        if (max != null && root.val >= max.val) {
            return false;
        }
        return traverse(root.left, min, root) &&
            traverse(root.right, root, max);
    }
}

13. 二叉搜索树中的搜索（简单）

地址: https://leetcode-cn.com/problems/search-in-a-binary-search-tree/

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null) {
            return null;
        }
        if (root.val > val) {
            return searchBST(root.left, val);
        }
        if (root.val < val) {
            return searchBST(root.right, val);
        }
        return root;
    }
}

14. 二叉搜索树中的插入操作（中等）

地址: https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }
        if (root.val < val) {
            root.right = insertIntoBST(root.right, val);
        }
        if (root.val > val) {
            root.left = insertIntoBST(root.left, val);
        }
        return root;
    }
}