129. Sum Root to Leaf Numbers

一、题目

　　1、审题

　　2、分析

　　　　给出一棵二叉树，求其从根节点到叶子节点的所有路径中所经过的节点组成的数值之和。　　

二、解答

　　1、思路：　

　　　　方法一、

　　　　　　采用递归进行 DFS，记录从根节点到叶子节点的所有的路径，在对数值进行累加。

    public int sumNumbers(TreeNode root) {
        
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        
        sumNumbersHelper(resultList, new ArrayList<Integer>(), root);
        int sum = 0;
        for(List<Integer> list: resultList) {
            int tmp = 0;
            for(Integer i: list)
                tmp = tmp * 10 + i;
            sum += tmp;
        }
        return sum;
    }
    
    private void sumNumbersHelper(List<List<Integer>> resultList,
            ArrayList<Integer> targetList, TreeNode root) {

        if(root == null) {
            resultList.add(new ArrayList<>(targetList));
        }
        else {
            targetList.add(root.val);
            if(root.left == null && root.right == null) {
                sumNumbersHelper(resultList, targetList, root.left);
                
            }
            else if(root.left == null){    // 避免加入两次
                sumNumbersHelper(resultList, targetList, root.right);
            }
            else if(root.right == null){    // 避免加入两次
                sumNumbersHelper(resultList, targetList, root.left);
            }
            else {
                sumNumbersHelper(resultList, targetList, root.right);
                sumNumbersHelper(resultList, targetList, root.left);
                
            }
            targetList.remove(targetList.size() - 1);
        }
    }

　　　　方法二、

　　　　　　采用两个 Queue 进行层次遍历，其中 一个 Queue 记录节点，一个 Queue 记录从根节点到此节点经过的路径所组成的数值。

    public int sumNumbers2(TreeNode root) {
    
        if(root == null) 
            return 0;
        
        int sum = 0;
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        Queue<Integer> valQueue = new LinkedList<>();
        nodeQueue.add(root);
        valQueue.add(root.val);
        
        while(!nodeQueue.isEmpty()) {
            
            root = nodeQueue.poll();
            if(root.left == null && root.right == null) {
                sum += valQueue.poll();
            }
            else{
                boolean flag = false;
                int val = 0;
                if(root.left != null) {
                    flag = true;
                    nodeQueue.add(root.left);
                    val = valQueue.poll();
                    valQueue.add(val*10 + root.left.val);
                }
                
                if(root.right != null) {
                    nodeQueue.add(root.right);
                    if(flag == false)
                        val = valQueue.poll();
                    valQueue.add(val*10 + root.right.val);
                }
            }
        }
        return sum;
    }

　　　　方法三、采用 Stack 进行 PreOrder 并记录路径的和值

    public int sumNumbers4(TreeNode root) {
        
        if(root == null)
            return 0;
        
        Stack<TreeNode> nodeStack = new Stack<>();
        Stack<String> nodePath = new Stack<>();
        nodeStack.push(root);
        nodePath.push(root.val + "");
        int sum = 0;
        
        while(!nodeStack.isEmpty()) {
            TreeNode node = nodeStack.pop();
            String currentPath = nodePath.pop();
            if(node.right != null) {
                nodeStack.push(node.right);
                nodePath.push(currentPath + node.right.val);
            }
            if(node.left != null) {
                nodeStack.push(node.left);
                nodePath.push(currentPath + node.left.val);
            }
            if(node.left == null && node.right == null)
                sum += Integer.valueOf(currentPath);
        }
        return sum;
    }

　　　　方法四、

　　　　　　采用递归直接计算路径的和值。

    public int sumNumbers(TreeNode root) {
       return helper(root, 0);
    }
    
    private int helper(TreeNode root, int i) {
        if(root == null)
            return 0;
        if(root.left == null && root.right == null)
            return i * 10 + root.val;

        return helper(root.left, i * 10 + root.val) + helper(root.right, i * 10 + root.val);
    }