二叉树中和为某一值的路径

1、问题

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

2、解法（Java实现）

public class Solution {
    private ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
    private ArrayList<Integer> path = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        // 刚进来必须判断root是否为None
        if(root == null) return result;
        path.add(root.val);
        // 既然相加要返回到根结点，那么相减就会到叶子结点
        target -= root.val;
        if(target == 0 && root.left == null && root.right == null){
            // 必须利用构造函数，将已取得值转换为新的ArrayList,否则会指向同一ArrayList，
            // 造成ArrayList重复
            // 这里不能返回，因为我是每走一步，添加一个结点，最后都得删掉它
            result.add(new ArrayList<Integer>(path));
        }
        ArrayList<ArrayList<Integer>> path1 = FindPath(root.left, target);
        ArrayList<ArrayList<Integer>> path2 = FindPath(root.right, target);
        // 当你得左右子树都检测完毕之后，再删掉这个结点
        path.remove(path.size()-1);
        // 最终目的是要知道共有多少符合要求得路径，所以返回result
        return result;
    }
}

3、一些思考

为了便于自己理解，可以忽略哈~~

3.1 输出二叉树的路径（Python实现）

递归解法

class TreeNode:
    def __init__(self, value):
        self.val = value
        self.right = None
        self.left = None
class Solution:
    # 通过先序遍历构建满二叉树
    def buildBinaryTree(self, lis):
        # 方法1：对于列表来说，当mid=0时，lis将为空，所以可以设置这个条件
        # if len(lis) == 0:
        #     return None
        # 方法2：
        root = TreeNode(lis[0])
        mid = (len(lis)-1)//2
        # 不包括列表的最后一位
        # print(root.val)
        if(mid> 0):
            root.left = self.buildBinaryTree(lis[1:mid+1])
        if(mid<len(lis)-1):
            root.right = self.buildBinaryTree(lis[mid+1:len(lis)])
        return root

    # 碰到不同条件时，设置函数
    def binaryTreePaths(self, root):
        # 如果遇到空树
        if(root == None):
            return []
        result = []
        # path 是为了存储整个路径
        # result传递进去，函数里面任何改变，它都会改变
        self.DFS(root, result, [root.val])
        return result

    def DFS(self, root, result, path):
        # 只有传递进来的参数，函数才可以使用，要不就标明是global
        # 这里并不能使用：因为叶结点的左右子树皆空，会重复append两次
        # if(root == None):
        #     result.append(path)
        #     return
        ## 错误1：&是位运算符，不是逻辑运算符
        ## 最近几天一直使用Java，写起python出现好多问题
        if (root.left == None and root.right == None):
            result.append(path)
        if(root.left != None):
            self.DFS(root.left, result, path+[root.left.val])
        if(root.right !=None):
            self.DFS(root.right, result, path+[root.right.val])

so = Solution()
root = so.buildBinaryTree([1, 2, 4, 5, 3, 6, 7])
result = so.binaryTreePaths(root)
print(result)

实验结果

非递归解法

• 栈实现（将列表当做栈）

# 非递归方法，有什么方式可以将结点存放起来，随取随用，用完就删
    # 只有stack、queue
    def binaryTreePaths(self, root):
        if(root == None):
            return []
        result = []
        stack = []
        stack.append((root, [root.val]))
        # 列表可以直接判断是否为None
        while stack:
            # 看来一个元组或者列表中的数据，可以分开的写的前提是可迭代
            # 可迭代的意思就是是一个变量
            root, path = stack.pop()
            if(root.left == None and root.right == None):
                result.append(path)
            if(root.left != None):
                stack.append((root.left, path + [root.left.val]))
            if(root.right != None):
                stack.append((root.right, path + [root.right.val]))
        return result

• 队列实现

    def binaryTreePaths(self, root):
        if(root == None):
            return []
        result = []
        que = queue.Queue()
        que.put((root, [root.val]))
        # 列表可以直接判断是否为None
        while not que.empty():
            # 看来一个元组中的数据，可以分开的写的前提是可迭代
            root, path = que.get()
            if(root.left == None and root.right == None):
                result.append(path)
            if(root.left != None):
                que.put((root.left, path + [root.left.val]))
            if(root.right != None):
                que.put((root.right, path + [root.right.val]))
        return result

3.2 该题的（Python实现）

题目的意思是：路径是从根结点到叶子结点所经过的所有结点，也就是路径必须到叶子结点结束，而不是中间一结点。

递归解法

    class Solution:
    def judgeLen(self, lis):
        return len(lis)
    def FindPath(self, root, expectNumber):
        if(root == None):
            return []
        result = []
        self.target = expectNumber
        self.DFS(root, result, [root.val])
        result.sort(key=self.judgeLen, reverse=True)
        return result
    def DFS(self, root, result, path):
        if (root.left == None and root.right == None and sum(path) == self.target):
            result.append(path)
            return
        if(root.left != None):
            self.DFS(root.left, result, path+[root.left.val])
        if(root.right !=None):
            self.DFS(root.right, result, path+[root.right.val])

非递归解法

    class Solution:
    def FindPath(self, root, expectNumber):
        if(root == None):
            return []
        self.target = expectNumber
        result = []
        stack = []
        stack.append((root, [root.val]))
        while stack:
            root, path = stack.pop()
            if(root.left == None and root.right == None and sum(path) == self.target):
                result.append(path)
                continue
            if(root.left != None):
                stack.append((root.left, path + [root.left.val]))
            if(root.right != None):
                stack.append((root.right, path + [root.right.val]))  
        result.sort(key=lambda i:len(i), reverse=True)
        return result