【leetcode-DFS】求根节点到叶节点数字之和/二叉树的最大路径和/路径总和/左叶子之和/树的直径

最新推荐文章于 2023-06-16 22:57:15 发布

Hung武

最新推荐文章于 2023-06-16 22:57:15 发布

阅读量2.8k

点赞数 1

分类专栏： leetcode

本文链接：https://blog.csdn.net/qq_31478771/article/details/115459723

版权

leetcode 专栏收录该内容

87 篇文章 1 订阅

订阅专栏

文章目录

求根节点到叶节点数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
计算从根节点到叶节点生成的所有数字之和。
叶节点是指没有子节点的节点。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：

输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此，数字总和 = 495 + 491 + 40 = 1026

深度优先搜索

class Solution {
    public int sumNumbers(TreeNode root) {
        return dfs(root, 0);
    }

    private int dfs(TreeNode root, int prevSum) {
        if (root == null)
            return 0;
        
        int sum = prevSum * 10 + root.val;
        if (root.left == null && root.right == null)
            return sum;
        return dfs(root.left, sum) + dfs(root.right, sum);
    }
}

广度优先搜索

class Solution {
    public int sumNumbers(TreeNode root) {
        if (root == null)
            return 0;
        
        int sum = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            TreeNode left = node.left, right = node.right;
            if (left == null && right == null) {
                sum += node.val;
            } else {
                if (left != null) {
                    left.val += node.val * 10;
                    queue.offer(left);
                }
                if (right != null) {
                    right.val += node.val * 10;
                    queue.offer(right);
                }
            }
        }
        return sum;
    }
}

二叉树的最大路径和

路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中至多出现一次。该路径至少包含一个节点，且不一定经过根节点。
路径和是路径中各节点值的总和。
给你一个二叉树的根节点 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

DFS

class Solution {
    private int max = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        dfs(root);
        return max;
    }

    private int dfs(TreeNode root) {
        if (root == null)
            return 0;
        
        int left_val = Math.max(dfs(root.left), 0);
        int right_val = Math.max(dfs(root.right), 0);
        max = Math.max(root.val + left_val + right_val, max);
        return root.val + Math.max(left_val, right_val);
    }
}

路径总和1

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。
叶子节点是指没有子节点的节点。

示例 1：
在这里插入图片描述
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true

示例 2：
在这里插入图片描述
输入：root = [1,2,3], targetSum = 5
输出：false

示例 3：
输入：root = [1,2], targetSum = 0
输出：false

深度优先搜索

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null)
            return false;
        if (root.left == null && root.right == null)
            return targetSum == root.val;
        return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
    }
}

广度优先搜索

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) 
            return false;
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.left == null && node.right == null) {
                if (node.val == sum) 
                    return true;
                continue;
            }
            if (node.left != null) {
                node.left.val += node.val;
                queue.offer(node.left);
            }
            if (node.right != null) {
                node.right.val += node.val;
                queue.offer(node.right);
            }
        }
        return false;
    }
}

路径总和2

给你二叉树的根节点 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
输出：[]

回溯法

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, new ArrayList<Integer>(), root, targetSum);
        return result;
    }

    private void backtrack(List<List<Integer>> result, List<Integer> path, TreeNode root, int target) {
        if (root == null) 
            return;
        path.add(root.val);
        target -= root.val;
        if (root.left == null && root.right == null && target == 0)
            result.add(new ArrayList<Integer>(path));
        backtrack(result, path, root.left, target);
        backtrack(result, path, root.right, target);
        path.remove(path.size() - 1);
    }
}

广度优先搜索

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> result = new LinkedList<>();
        if (root == null)
            return result;

        Queue<TreeNode> queueNode = new LinkedList<>();
        queueNode.offer(root);
        Queue<List<Integer>> queueList = new LinkedList<>();
        queueList.add(new ArrayList<>(){{add(root.val);}});
        while (!queueNode.isEmpty()) {
            TreeNode node = queueNode.poll();
            List<Integer> list = queueList.poll();

            if (node.left == null && node.right == null && node.val == targetSum) {
                result.add(list);
            } else {
                if (node.left != null) {
                    list.add(node.left.val);
                    queueList.add(new ArrayList<>(list));
                    node.left.val += node.val;
                    queueNode.offer(node.left);
                    list.remove(list.size() - 1);
                }
                if (node.right != null) {
                    list.add(node.right.val);
                    queueList.add(new ArrayList<>(list));
                    node.right.val += node.val;
                    queueNode.offer(node.right);
                }
            }
        }
        return result;
    }
}

左叶子之和

计算给定二叉树的所有左叶子之和。

示例：

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

递归

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null)
            return 0;
        int val = 0;
        if (root.left != null && root.left.left == null && root.left.right == null)
            val = root.left.val;
        return val + sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
    }
}

DFS

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        return root == null ? 0 : dfs(root);
    }

    private int dfs(TreeNode root) {
        int val = 0;
        if (root.left != null)
            val += isLeafNode(root.left) ? root.left.val : dfs(root.left);
        if (root.right != null && !isLeafNode(root.right))
            val += dfs(root.right);
        return val;
    }

    private boolean isLeafNode(TreeNode node) {
        return node.left == null && node.right == null;
    }
}

树的直径

给定一棵树，求出这棵树的直径，即树上最远两点的距离。
包含n个结点，n-1条边的连通图称为树。
示例1的树如下图所示。其中4到5之间的路径最长，是树的直径，距离为5+2+4=11
在这里插入图片描述

示例：
输入：
6, [[0,1],[1,5],[1,2],[2,3],[2,4]],[3,4,2,1,5]
返回值：
11

两次DFS

第一次DFS找离根结点最远的结点，第二次从该结点出发，找离该结点最远的结点。

class Solution {
    class Node {
        int end;
        int val;
        Node (int e, int v) {
            end = e;
            val = v;
        }
    }

    private int ans = 0, prevNode = -1;

    public int solve (int n, Interval[] Tree_edge, int[] Edge_value) {
        int len = Edge_value.length;
        ArrayList<ArrayList<Node>> graph = new ArrayList<>();
        for (int i = 0; i < n; ++i)
            graph.add(new ArrayList<Node>());
        for (int i = 0; i < len; i++) {
            graph.get(Tree_edge[i].start).add(new Node(Tree_edge[i].end, Edge_value[i]));
            graph.get(Tree_edge[i].end).add(new Node(Tree_edge[i].start, Edge_value[i]));
        }

        dfs(graph, -1, 0, 0);
        dfs(graph, -1, prevNode, 0);
        return ans;
    }

    private void dfs(ArrayList<ArrayList<Node>> graph, int pre, int cur, int sum) {
        ArrayList<Node> edges = graph.get(cur);
        for (int i = 0; i < edges.size(); ++i) {
            Node next = edges.get(i);
            if (next.end != pre) {
                if (sum + next.val > ans) {
                    ans = sum + next.val;
                    prevNode = next.end;
                }
                dfs(graph, cur, next.end, sum + next.val);
            }
        }    
    }
}

Hung武

关注

1
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
【leetcode-DFS】求根节点到叶节点数字之和/二叉树的最大路径和/路径总和/左叶子之和/树的直径

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。每条从根节点到叶节点的路径都代表一个数字：例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。计算从根节点到叶节点生成的所有数字之和。叶节点是指没有子节点的节点。示例 1：输入：root = [1,2,3]输出：25解释：从根到叶子节点路径 1->2 代表数字 12从根到叶子节点路径 1->3 代表数字 13因此，数字总和 = 12 + 13 =
复制链接

扫一扫