二叉树LC总结

最新推荐文章于 2024-08-10 22:52:22 发布

柠檬茶五元

最新推荐文章于 2024-08-10 22:52:22 发布

阅读量846

点赞数 26

文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/m0_60469045/article/details/136693632

版权

1.将有序数组转化为二叉搜索树：总是选择中间位置左边的数字作为根节点
2.反转二叉树：判空，定义左右结点，交换左右子树
3.对称二叉树：判空，比较左右结点，比较左右孩子，再比较左节点右孩子和右节点左孩子
4.二叉树的直径：定义最大长度，最大深度递归
5.二叉树的中序遍历：设置res存结果，Deque存储结点，先左后右，出栈
6.二叉树的最大深度：判空，遍历左右子树的最大深度
7.二叉树的层序遍历：Deque存树节点，res存最终结果，tmp存每层节点
8.验证二叉搜索树：设置最大、最小两个变量，每个根节点小于右子树，大于左子树
9.二叉树展开为链表：判空，若左子树为空，直接将右子树展开，否则，展开左右子树，设置TreeNode 值存之前根节点的右子树，设置变量循环，找到左子树的最右节点，分别挂载
10.从前序与中序遍历序列构造二叉树：前序第一个节点是根结点，中序定位根节点，递归
11.二叉搜索树中第K小的元素：设置Deque栈，判空，循环
12.二叉树的右视图：设置RES，dfs(root,0)

1.将有序数组转化为二叉搜索树

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵平衡二叉搜索树。

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

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

    public TreeNode helper(int[] nums, int left, int right) {
        if (left > right) {
            return null;
        }

        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;

        TreeNode root = new TreeNode(nums[mid]);
        root.left = helper(nums, left, mid - 1);
        root.right = helper(nums, mid + 1, right);
        return root;
    }
}

2.反转二叉树：

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);
        root.left = right;
        root.right = left;
        return root;
    }
}

3.对称二叉树：

给你一个二叉树的根节点 root ，检查它是否轴对称。

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

class Solution {

    public boolean isSymmetric(TreeNode root) {
        if(root==null) {
        return true;
        }
        //调用递归函数，比较左节点，右节点
        return dfs(root.left,root.right);
    }
    boolean dfs(TreeNode left, TreeNode right) {
        //递归的终止条件是两个节点都为空
        //或者两个节点中有一个为空
        //或者两个节点的值不相等
        if(left==null && right==null) {
            return true;
        }
        if(left==null || right==null) {
            return false;
        }
        if(left.val!=right.val) {
            return false;
        }
        //再递归的比较 左节点的左孩子 和 右节点的右孩子
        //以及比较  左节点的右孩子 和 右节点的左孩子
        return dfs(left.left,right.right) && dfs(left.right,right.left);
    }
}

4.二叉树的直径：

给你一棵二叉树的根节点，返回该树的直径。

二叉树的直径是指树中任意两个节点之间最长路径的长度。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的长度由它们之间边数表示

输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。

class Solution {
    int maxDiameter = 0;

    public int diameterOfBinaryTree(TreeNode root) {

        maxDepth(root);
        return maxDiameter;
    }

    int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int LeftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        int myDiameter = LeftMax + rightMax;
        maxDiameter= Math.max(maxDiameter, myDiameter);

        return Math.max(LeftMax, rightMax) + 1;
    }
}

5.二叉树的中序遍历：

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

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

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
     //将所有节点的值存入res中
     List<Integer> res=new ArrayList<Integer>();
     //建立一个双端队列
     Deque<TreeNode> dl = new LinkedList<TreeNode>();
     //判断根节点是否为空或者队列是否为空
     while(root != null || !dl.isEmpty()){
         while(root != null){
             dl.push(root); //将当前节点压入
             root = root.left; //遍历左子树
         }
         root = dl.pop(); //出栈
         res.add(root.val);//将值加入res中
         root = root.right;//迭代右子树
     }
     return res;
    }
}

6.二叉树的最大深度：

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数

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

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int LeftDepth =  maxDepth(root.left);
        int RightDepth = maxDepth(root.right);
        int res = Math.max(LeftDepth,RightDepth) + 1;
        return res;
    }
}

7.二叉树的层序遍历：

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

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

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if (root != null) queue.add(root);
        while (!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

8.验证二叉搜索树：

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

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

class Solution {
    public boolean isValidBST(TreeNode root) {
          return isValidBST(root,Long.MIN_VALUE,Long.MAX_VALUE);
    }
      public boolean isValidBST(TreeNode node, long lower, long upper) {
        if (node == null) {
            return true;
        }
        if (node.val <= lower || node.val >= upper) {
            return false;
        }
        return isValidBST(node.left, lower, node.val) && isValidBST(node.right, node.val, upper);
    }
}

9.二叉树展开为链表：

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

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。

展开后的单链表应该与二叉树先序遍历顺序相同。

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

class Solution {
    public void flatten(TreeNode root) {
        if (root == null) {
            return; //Base case: 空树
        }
        if (root.left == null) {
            flatten(root.right); //若左子树为空，直接flatten右子树即可
        } else { //否则，先将左右子树分别flatten
            flatten(root.left); 
            flatten(root.right);
            TreeNode oldRight = root.right; //用一个TreeNode变量保存faltten之后的右子树
            TreeNode curr = root.left; //设置curr变量并循环，找到左子树的最右子节点
            while (curr.right != null) {
                curr = curr.right;
            }
            curr.right = oldRight; //将与右子树挂载到左子树的最后
            root.right = root.left; //将左子树挂载为原根节点的右子树
            root.left = null; //根节点左子树设为空
        }
    }
}

10.从前序与中序遍历序列构造二叉树：

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

class Solution {
    private Map<Integer, Integer> indexMap;

    public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return null;
        }

        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = indexMap.get(preorder[preorder_root]);
        
        // 先把根节点建立出来
        TreeNode root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root.left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        // 构造哈希映射，帮助我们快速定位根节点
        indexMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            indexMap.put(inorder[i], i);
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
}

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

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。

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

class Solution {
    public int kthSmallest(TreeNode root, int k) {
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            --k;
            if (k == 0) {
                break;
            }
            root = root.right;
        }
        return root.val;

    }
}

12.二叉树的右视图：

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

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

//dfs
class Solution {
    private List<Integer> ans;

    public List<Integer> rightSideView(TreeNode root) {
        ans = new ArrayList<>();
        dfs(root, 0);
        return ans;
    }

    private void dfs(TreeNode node, int depth) {
        if (node == null) return;
        if (ans.size() <= depth) 
            ans.add(node.val);
        else 
            ans.set(depth, node.val);
        dfs(node.left, depth + 1);
        dfs(node.right, depth + 1);
    }
}

//bfs
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) return ans;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        int count;
        while (!q.isEmpty()) {
            count = q.size();
            for (int i = 0; i < count; i++) {
                TreeNode node = q.poll();
                if (node.left != null) q.offer(node.left);
                if (node.right != null) q.offer(node.right);
                if (i == count - 1) ans.add(node.val);
            }
        }
        return ans;
    }
}

柠檬茶五元

关注

26
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
二叉树LC总结

/ 先序遍历中「从左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从左边界开始到根节点定位-1」的元素。// 先序遍历中「从左边界+1+左子树节点数目开始到右边界」的元素就对应了中序遍历中「从根节点定位+1 到右边界」的元素。输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]输出：[1,null,2,null,3,null,4,null,5,null,6]root = root.right;
复制链接

扫一扫