【模板总结】根节点要叶子节点（递归法）

bijian0530

已于 2022-07-23 11:43:10 修改

阅读量148

点赞数

文章标签：深度优先 leetcode 算法逻辑回归

于 2022-07-22 19:17:02 首次发布

本文链接：https://blog.csdn.net/bijian0530/article/details/125937966

版权

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

在这里插入图片描述

   public int sumNumbers(TreeNode root) {
      if(root == null){
         return 0;
      }
      return dfs(root, 0);
   }

   private int dfs(TreeNode root, int preSum) {
      if(root == null){
         return 0;
      }
      int sum = preSum * 10 + root.val;
      if(root.left == null && root.right == null){
         return sum;
      }else {
         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> nodeQueue = new LinkedList<TreeNode>();
        Queue<Integer> numQueue = new LinkedList<Integer>();
        nodeQueue.offer(root);
        numQueue.offer(root.val);
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.poll();
            int num = numQueue.poll();
            TreeNode left = node.left, right = node.right;
            if (left == null && right == null) {
                sum += num;
            } else {
                if (left != null) {
                    nodeQueue.offer(left);
                    numQueue.offer(num * 10 + left.val);
                }
                if (right != null) {
                    nodeQueue.offer(right);
                    numQueue.offer(num * 10 + right.val);
                }
            }
        }
        return sum;
    }
}

112. 路径总和

在这里插入图片描述

   public boolean hasPathSum(TreeNode root, int targetSum) {
      if(root == null){
         return false;
      }
      return dfs(root, targetSum);
   }

   private boolean dfs(TreeNode root, int targetSum) {
      if(root == null){
         return false;
      }
      targetSum -= root.val;
      if(root.left == null && root.right == null && targetSum == 0){
         return true;
      }
      return dfs(root.left, targetSum) ||dfs(root.right, targetSum);
   }

113. 路径总和 II

在这里插入图片描述

   class Solution {
      List<List<Integer>> res = new ArrayList<>();
      LinkedList<Integer> queue = new LinkedList<>();
      public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
         if(root == null){
            return res;
         }
         dfs(root, targetSum);
         return res;
      }

      private void dfs(TreeNode root, int targetSum) {
         targetSum -= root.val;
         queue.add(root.val);
         if(root.left == null && root.right == null && targetSum == 0){
            res.add(new ArrayList<>(queue));
            return;
         }
         if(root.left != null){
            dfs(root.left, targetSum);
            queue.removeLast();
         }
         if(root.right != null){
            dfs(root.right, targetSum);
            queue.removeLast();
         }
      }
   }