剑指 Offer 34. 二叉树中和为某一值的路径附完整可运行代码

Posted 2021-06-30 来老铁干了这碗代码

立志用最少的代码做最高效的表达

---

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
示例:
给定如下二叉树，以及目标和 target = 22，

          5
         / \\
        4   8
       /   / \\
      11  13  4
     /  \\    / \\
    7    2  5   1

返回:
[
[5,4,11,2],
[5,8,4,5]
]

提示：
节点总数 <= 10000

---

解法：dfs
边界条件：当某节点是叶子结点，并且当前和等于target。

注意：
1、将容器设为成员变量，而不是把当做参数传递，后者效率很低。
2、对树的dfs中，无需设立vis数组，因为树是具有规律性的，只会从上到下，从左到右的搜索。
3、dfs剪枝时的语句：if(nowValue > Value) return; 不适用于节点值可能为负的情况。

---

/**
 * 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 {
        // 定义成员变量
        List<List<Integer>>list;
        int sum, tar;
        List<Integer>tmp;
        public List<List<Integer>> pathSum(TreeNode root, int target) {
            // 为成员变量赋值
            sum = 0; tar = target;
            tmp = new ArrayList<>();
            list = new ArrayList<>();

            if(root == null) return list;        // 鲁棒性
            tmp.add(root.val);          // 先加入根节点
            dfs(root.val, root);    // 先不加vis试一下
            return list;
        }
        public void dfs(int nowSum, TreeNode nowRoot) {
            // if(nowSum > tar) return;     // 剪枝 这个剪枝，只能用在节点是正的情况下
            // 遍历到了叶节点，且等于目标值，则该路径符合
            if((nowRoot.left==null && nowRoot.right == null) && nowSum == tar) {
                list.add(new ArrayList<>(tmp));
                return;
            }

            if(nowRoot.left != null) {
                tmp.add(nowRoot.left.val);
//                System.out.println(tmp.toString());
                dfs(nowSum + nowRoot.left.val, nowRoot.left);
                tmp.remove(tmp.size()-1);
            }
            if(nowRoot.right != null) {
                tmp.add(nowRoot.right.val);
//                System.out.println(tmp.toString());
                dfs(nowSum + nowRoot.right.val, nowRoot.right);
                tmp.remove(tmp.size()-1);
            }
        }
}

---

完整可运行代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class 剑指Offer34_二叉树中和为某一值的路径 {
    static class TreeNode {
        int val;
        TreeNode left, right;
        TreeNode(int v) { val = v; }
    }
    static class Solution {
        // 定义成员变量
        List<List<Integer>>list;
        int sum, tar;
        List<Integer>tmp;
        public List<List<Integer>> pathSum(TreeNode root, int target) {
            // 为成员变量赋值
            sum = 0; tar = target;
            tmp = new ArrayList<>();
            list = new ArrayList<>();

            if(root == null || target == 0) return list;        // 鲁棒性
            tmp.add(root.val);          // 先加入根节点
            dfs(root.val, root);    // 先不加vis试一下
            return list;
        }
        public void dfs(int nowSum, TreeNode nowRoot) {
            if(nowSum > tar) return;     // 剪枝
            // 遍历到了叶节点，且等于目标值，则该路径符合
            if((nowRoot.left==null && nowRoot.right == null) && nowSum == tar) {
                list.add(new ArrayList<>(tmp));
                return;
            }

            if(nowRoot.left != null) {
                tmp.add(nowRoot.left.val);
//                System.out.println(tmp.toString());
                dfs(nowSum + nowRoot.left.val, nowRoot.left);
                tmp.remove(tmp.size()-1);
            }
            if(nowRoot.right != null) {
                tmp.add(nowRoot.right.val);
//                System.out.println(tmp.toString());
                dfs(nowSum + nowRoot.right.val, nowRoot.right);
                tmp.remove(tmp.size()-1);
            }
        }
    }

    public static void main(String[] args) {
        // [10, 5, 12, 4, 7, null, null]
        TreeNode treeNode = new TreeNode(10);
        TreeNode tmp21 = new TreeNode(5), tmp22 = new TreeNode(12);
        TreeNode tmp31 = new TreeNode(4), tmp32 = new TreeNode(7);
        treeNode.left = tmp21; treeNode.right = tmp22;
        tmp21.left = tmp31; tmp21.right = tmp32;


        Solution solution = new Solution();
        List<List<Integer>> list = solution.pathSum(treeNode, 22);
        // toString打印数组中的值
        System.out.println(list.toString());
    }
}