二叉树根节点到叶子节点的所有路径和

int ans = 0; 
    public int sumNumbers (TreeNode root) {
        // write code here
        if (root == null) {
            return ans;
        }
        int path = 0;
        process(root, path);
        return ans;
    }

    private void process(TreeNode root, int path) {
        path = path * 10 + root.val;
        if (root.left == null && root.right == null) {
            ans += path;
            return;
        }
        
        if (root.left != null) {
            process(root.left, path);
        }
        if (root.right != null) {
            process(root.right, path);
        }
    }

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型
     */
    public int sumNumbers (TreeNode root) {
        ArrayList<ArrayList<Integer>> allPath = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> path  = new ArrayList<Integer>();
        if (root == null) {
            return 0;
        }
        path.add(root.val);
        if (root.left == null && root.right == null) {
            allPath.add(new ArrayList<Integer>(path));
        } else {
            findAllPath(allPath, path, root.left);
            findAllPath(allPath, path, root.right);
        }
        int pathSum = allPath.stream().filter(list->list != null &&
        list.size() > 0).mapToInt(list-> {
            int sum = 0;
            for (int idx = 0; idx < list.size(); idx++) {
                sum += list.get(idx) * Math.pow(10, list.size() - 1 - idx);
            }
            return sum;
        }).sum();
        return pathSum;
    }

    public void findAllPath(ArrayList<ArrayList<Integer>> allPath,
                            ArrayList<Integer> path, TreeNode node) {
        if (node == null) {
            return;
        }
        path.add(node.val);
        if (node.left == null && node.right == null) {
            allPath.add(new ArrayList<Integer>(path));
        } else {
            findAllPath(allPath, path, node.left);
            findAllPath(allPath, path, node.right);
        }
        path.remove(path.size() - 1);
        return;
    }
}

public int sumNumbers (TreeNode root) {
        ArrayList<Integer>list = new ArrayList<>();
        ArrayList<ArrayList<Integer>>lists = new ArrayList<>();
        dfs(root, list, lists);
        int sum = 0;
        for (int i = 0; i < lists.size(); i++) {
            int n = 1;
            ArrayList<Integer>newlist = new ArrayList<>();
            for (int j = 0; j < lists.get(i).size(); j++) {
                int num = lists.get(i).get(lists.get(i).size() - j - 1) * n;
                sum += num;
                n = 10 * n;
            }
        }
        return sum;
    }
    public void dfs(TreeNode root, ArrayList<Integer>list,
                    ArrayList<ArrayList<Integer>>lists) {
        if (root == null) {
            return;
        }
        if (root.left != null || root.right != null) {
            list.add(root.val);
            dfs(root.left, list, lists);
            dfs(root.right, list, lists);
            list.remove(list.size()-1);
        }
        if (root.left == null && root.right == null) {
            list.add(root.val);
            lists.add(new ArrayList<>(list));
            list.remove(list.size() - 1);
        }
    }

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型
     */
    int res = 0;
    public int sumNumbers (TreeNode root) {
        // write code here
        if (root == null) return 0;

        dfs(root, 0);

        return res;
    }

    public void dfs(TreeNode t, int sum) {
        if (t == null) return;
        if (t.left == null && t.right == null) {
            res = res + t.val + sum * 10;
            return;
        }
        dfs(t.left, sum * 10 + t.val);
        dfs(t.right, sum * 10 + t.val);
    }
}

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    public int sumNumbers (TreeNode root) {
        // write code here
        if(root == null)  return 0;
        int res = 0;
        return dfs(root, res);

    }
    public int dfs(TreeNode t, int res){
        if(t == null)  return 0;
        if(t.left == null && t.right == null){
            return res * 10 + t.val;
        }
        return dfs(t.left, res*10 + t.val) + dfs(t.right, res*10 + t.val);
    }
}

import java.util.*;

public class Solution {
    public int sumNumbers (TreeNode root) {
        return dfs(root, 0);
    }
    public int dfs (TreeNode root, int temp) {
        if (root == null) {
            return 0;
        }
        temp = temp * 10 + root.val;
        if (root.left == null && root.right == null) return temp;
        return dfs(root.left, temp) + dfs(root.right, temp);
    }
}

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    ArrayList<ArrayList<Integer>> res=new ArrayList<>();
    ArrayList<Integer> path=new ArrayList<>();
    public int sumNumbers (TreeNode root) {
        // write code here
         backtrace(root);
        int resNum=0;
        for(ArrayList<Integer> tem:res){
            int cur=0;
            for(int i=0;i<tem.size();i++){
                cur=cur*10+tem.get(i);
            }
            resNum+=cur;
        }
        return resNum;
    }
    public void backtrace(TreeNode root){
        //base case
        if(root==null) return;
        //将根加到path中
        path.add(root.val);
        //sum-=root.val;
        //因为要到叶子节点
        if(root.left==null&&root.right==null){
            //符合条件
            res.add(new ArrayList(path));
        }
        backtrace(root.left);
        backtrace(root.right);
        //路径恢复，将当前节点从路径中移除
        path.remove(path.size()-1);
        
    }
}

没想到这么简单

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
      int res=0;
    public int sumNumbers (TreeNode root) {
         if(root==null) return 0;
        dfs(root,0);
        return res;
    }
    public void dfs(TreeNode root,int val){
        if(root==null) return;
        val=val*10+root.val;
        if(root.left==null&&root.right==null) res+=val;
        dfs(root.left,val);
        dfs(root.right,val);
    }
}

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    public int sumNumbers (TreeNode treeNode) {
        // write code here
        List<Integer> pathList = new ArrayList<>();
        getNumber(treeNode, "", pathList);
        if (pathList.size() == 0) {
            return 0;
        }
        return pathList.get(0);
    }
    
    private void getNumber(TreeNode node, String path, List<Integer> pathValue) {
        if (node == null) {
            return;
        }
        path += node.val;
        getNumber(node.left, path, pathValue);
        getNumber(node.right, path,pathValue);
        if (node.left == null && node.right == null) {
            if (pathValue.size() == 0) {
                pathValue.add(Integer.valueOf(path));
            } else {
                pathValue.set(0, pathValue.get(0) + Integer.valueOf(path));
            }
        }
    }
}

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    public int sumNumbers (TreeNode root) {
        // write code here
        if(root==null) return 0;
        Stack<TreeNode> nodeStack=new Stack<>();
        Stack<Integer> valueStack=new Stack<>();
        int res=0;
        nodeStack.add(root);
        valueStack.add(root.val);
        while(!nodeStack.isEmpty()){
            TreeNode node=nodeStack.pop();
            int value=valueStack.pop();
            if(node.left==null&&node.right==null){
                res+=value;
            }else{
                if(node.left!=null){
                    nodeStack.push(node.left);
                    valueStack.push(value*10+node.left.val);
                }
                if(node.right!=null){
                    nodeStack.push(node.right);
                    valueStack.push(value*10+node.right.val);
                }
            }
        }
        return res;
    }
}

public class Solution {
    public int sumNumbers (TreeNode root) {
        if (root == null) return 0;
        ArrayList<String> res = new ArrayList<>();
        StringBuffer sb = new StringBuffer();
        dfs(root, sb, res);
        int sum = 0;
        for (int i = 0; i < res.size(); i++)
            sum = sum + Integer.parseInt(res.get(i));
        return sum;
    }
    void dfs(TreeNode root, StringBuffer sb, ArrayList<String> res){
        sb.append(root.val);
        if (root.left == null && root.right == null)
            res.add(sb.toString());
        if (root.left != null)
            dfs(root.left, sb, res);
        if (root.right != null)
            dfs(root.right, sb, res);
        sb.deleteCharAt(sb.length() - 1);        
    }   
}

public class Solution {
    public int sum=0;
    public int temp=0;
    public int sumNumbers (TreeNode root) {
        dfs(root);
        return sum;
    }
    public void dfs(TreeNode root){
        if(root==null) return;
        temp = temp*10 + root.val;
        //叶子节点，收集结果
        if(root.left==null&&root.right==null) sum+=temp;
        //递归
        dfs(root.left);
        dfs(root.right);
        //回溯
        temp = temp/10;
    }
}

import java.util.*;
public class Solution {
    ArrayList<StringBuilder> ansList = new ArrayList<>();
    public int sumNumbers (TreeNode root) {
        StringBuilder path = new StringBuilder();
        curVisitPath(root,path);
        int result = 0;
        for(StringBuilder sb : ansList)
            result += new Integer(sb.toString());
        return result;
    }
    
    public void curVisitPath (TreeNode root, StringBuilder path) {
        if(root == null)
            return;
        if(root.left == null && root.right == null) {
            path.append(root.val);
            ansList.add(new StringBuilder(path));
            path.delete(path.length() - 1, path.length());
            return;
        }
        path.append(root.val);
        curVisitPath(root.left,path);
        curVisitPath(root.right,path);
        path.delete(path.length() - 1, path.length());
    }
}