方法一：递归。每次把左节点加入到列表中，知道遇到叶节点结束，返回至上一层节点，并查其右节点，以此类推。

	private static List<String> binTreePath1(TreeNode root) {
		LinkedList<String> l = new LinkedList<String>();
		if(root==null)return l;//如果为空，返回空
		getPath(root,l,root.val+"");
		return l;
	}


	private static void getPath(TreeNode root, List<String> re, String s) {
		if(root.left==null && root.right==null) {//此时为叶节点，把s添加到结果列表中，返回
			re.add(s+"");
			return ;
		}
		if(root.left!=null)//左子树不为空，递归
			getPath(root.left,re,s+"->"+root.left.val);
		if(root.right!=null)//右子树不为空，递归
			getPath(root.right,re,s+"->"+root.right.val);
	}

方法二：在方法一的基础之上，不需要借助 getPath 函数。

	//不借用辅助函数
	private static List<String> binTreePath2(TreeNode root) {
		LinkedList<String> l = new LinkedList<String>();
		if(root==null)return l;
		if(root.left==null && root.right==null) {
			l.add(root.val+"");
			return l;
		}
		for (String s : binTreePath2(root.left)) {
			l.add(root.val+"->"+s);
		}
		for (String s : binTreePath2(root.right)) {
			l.add(root.val+"->"+s);
		}
		return l;
	}

方法三：BFS算法应用，建两个队列，一个存储节点，另一存储路径

	//队列BFS算法应用
	private static List<String> binTreePath3(TreeNode root) {
		    List<String> l=new ArrayList<String>();//结果列表
		    Queue<TreeNode> queueNode = new LinkedList<TreeNode>();//存储节点队列
		    Queue<String> queueStrPath = new LinkedList<String>();//存储路径队列
		    if(root==null)return l;
		    queueNode.add(root);
		    queueStrPath.add("");
		    while(!queueNode.isEmpty()) {
		    	TreeNode curNode = queueNode.poll();
		    	String curPath = queueStrPath.poll();
		    	if(curNode.left==null && curNode.right==null) {
		    		l.add(curPath+curNode.val);
		    	}
		    	if(curNode.left!=null) {
		    		queueNode.add(curNode.left);
		    		queueStrPath.add(curPath+curNode.val+"->");
		    	}
		    	if(curNode.right!=null) {
		    		queueNode.add(curNode.right);
		    		queueStrPath.add(curPath+curNode.val+"->");
		    	}
		    }
		    return l;
	}

最后树定义

public class TreeNode {

	public int val;
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int x){val = x;};
}