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

文章目录

求根节点到叶节点数字之和
- 深度优先搜索
- 广度优先搜索
二叉树的最大路径和
- DFS
路径总和1
- 深度优先搜索
- 广度优先搜索
路径总和2
- 回溯法
- 广度优先搜索
左叶子之和
- 递归
- DFS
树的直径
- 两次DFS

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

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