力扣刷题小记1

博主个人博客网站：文客
这个系列主要记录在力扣刷题的总结和问题
如果你想每天和我一起刷题，可以关注一下我的个人博客网站：文客，我会每天在这里更新技术文章和面试题，也会及时收到大家的评论与留言，欢迎各位大佬来交流！

113.路径总和Ⅱ

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

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

示例 3：

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

思路：

首先读题，给了一个目标和，让你找出路径和等于目标和的路径，注意路径是指从根节点到叶子节点，这就很明确了。这道题可以用回溯算法，找出所有从根节点到叶子节点的路径，然后判断路径和是否等于目标和，符合的路径加入到结果集当中，不管路径是否合法，判断完后都要进行回溯，也就是往上回溯，继续判断其它路径。

代码：

/**
 * 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 {
    LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        if(root == null){
            return res;
        }
        path.add(root.val);
        backtracking(root,targetSum,root.val);
        return res;
    }

    public void backtracking(TreeNode root, int targetSum, int sum){
        if(root.left == null && root.right == null){
            //是叶子节点，而且路径和等于目标和
            if(sum == targetSum){
                res.add(new ArrayList<>(path));
            }
            return;
        }
        //左路径
        if(root.left != null){
            path.add(root.left.val);
            backtracking(root.left,targetSum,sum + root.left.val);
            //回溯
            path.removeLast();
        }
        //右路径
        if(root.right != null){
            path.add(root.right.val);
            backtracking(root.right,targetSum,sum + root.right.val);
            //回溯
            path.removeLast();
        }
    }
}

114.二叉树展开为链表

给你二叉树的根结点 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]

思路：

这道题进阶要求是使用O(1)的额外空间，思考了好几个方案，但是都没能实现，暂且先用O(n)的额外空间啦，我再研究研究进阶的方法。

题目要求按照先序遍历的顺序将二叉树转换为链表，那就先序遍历咯，把遍历到的每个节点存起来，然后再组装成链表

题解：

/**
 * 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 {
    LinkedList<TreeNode> list = new LinkedList<>();

    public void flatten(TreeNode root) {
        if(root == null){
            return;
        }
        inorder(root);
        root = list.pollLast();
        while(!list.isEmpty()){
            root.right = list.pollLast();
            root.left = null;
            root = root.right;
        }
    }

    public void inorder(TreeNode root){
        if(root == null){
            return;
        }
        list.addFirst(root);
        inorder(root.left);
        inorder(root.right);
    }
}

124.二叉树的最大路径和

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

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

给你一个二叉树的根节点 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

思路：

首先看题，这道题的路径被定义为从任意节点出发，沿父节点-子节点连接，达到任意节点的序列，然后求出最大的路径和。这就有些麻烦了。这道题是一种贪心的思想，先求出局部路径的最大和，从小到大递推，不断更新最大路径和。

可以用后序遍历，每个叶子节点的局部最大路径和就是自己的val，父节点的局部最大路径和是自身的val与左右节点最大路径和的最大值的加和，每一条通路即是：左->根->右。

代码：

/**
 * 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 {
    int res = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        getMax(root);
        return res;
    }

    public int getMax(TreeNode root){
        if(root == null){
            return 0;
        }

        int leftMax = Math.max(getMax(root.left),0);
        int rightMax = Math.max(getMax(root.right),0);
        res = Math.max(res,root.val + leftMax + rightMax);
        return root.val + Math.max(leftMax,rightMax);
    }
}

博客原文地址

力扣刷题小记1