一個小演算法，分享一下思路：

描述：

寫一個程式建立一棵二叉樹，並按照一定規則，輸出二叉樹根節點到葉子節點的路徑。

規則如下：
1、從最頂端的根結點，到最下面的葉子節點，計算路徑通過的所有節點的和，如果與設定的某一值的相同，那麼輸出這條路徑上的所有節點。

2、從根節點遍歷樹時，請請按照左到右遍歷，即優先訪問左子樹的節點。

二叉樹建立規則：從上到下一層一層的，按照從左到右的順序進行構造

輸入"10,5,12,4,7"值，構造的樹如下：

1）    10

2）    10
       /
      5
      
3）    10
       /\
      5  12
 
4）    10
       /\
      5  12 
     /
    4     
      
5）    10
       /\
      5  12 
     /\
    4  7

針對上面的二叉樹，如果當前我們設定的“路徑和”為19，那麼輸出結果為:

10,5,4

如果有多個路徑，按到左到右的順序遍歷生成的結果每行顯示一個顯示。例如如果當前我們設定的“路徑和”為22，那麼輸出結果為:

10,5,7

10,12

如果沒有找到路徑和為設定的值的路徑，輸出error。

輸入：

輸入整數N---路徑和

一行字串，多個正整數，之間用","隔開

輸出：

滿足條件的二叉樹路徑

樣例輸入：

22
10,5,12,4,7

樣例輸出：

10,5,7
10,12

實現程式碼：

/*
*Created on 2016年8月17日
*Copyright 2016 Yong Cai Limited crop. All Rights Reserved
*
*728**
 
[email protected]
*/


import java.util.Scanner;

public class Main {
	
	public static int counter = 0;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int N  = Integer.valueOf(sc.nextLine());
		String line =  sc.nextLine();
		
		compute(N, line);
	}
	
	public static void compute(int N, String line){
		
		String[] arr = line.split(",");
		int len = arr.length;
		
		//從index=1開始存資料
		Node[] nodeArr = new Node[len + 1];
		
		for(int i = 0; i < len; i++){
			int val = Integer.valueOf(arr[i]);
			nodeArr[i + 1] = new Node(val);
		}
		
		//構建二叉樹
		Node root = nodeArr[1];
		for(int i = 1; i < len + 1; i++){
			if(i * 2 < len + 1){
				nodeArr[i].left = nodeArr[2 * i];
			}
			
			if(i * 2 + 1 < len + 1){
				nodeArr[i].right = nodeArr[2 * i + 1];
			}
		}
		
//		printTree(root);
		
		printPaths(root, len, N);
	}
	
	
	public static void printTree(Node root){
		if(root == null){
			return;
		}
		
		System.out.println(root.val);
		
		if(root.left != null){
			printTree(root.left);
		}
		
		if(root.right != null){
			printTree(root.right);
		}
	}
	
	public static void printPaths(Node root, int n, int N) {  
	    int[] path = new int[n];  
	    printPaths(root, path, 0, N);
	    
	    if(counter == 0){
			System.out.println("error");
		}
	    
	}  

	
	public static void printPaths(Node root, int[] path, int pathLen, int N) {
	    if (root == null) return;  
	        path[pathLen++] = root.val;  
	    if (root.left == null && root.right == null) {  
	        printArray(path, pathLen, N);
	    }  
	    else {  
	        printPaths(root.left, path, pathLen, N);  
	        printPaths(root.right, path, pathLen, N);  
	    }  
	}  
  
	public static void printArray(int[] ints, int len, int N) {
		int total = 0;
		StringBuilder sb = new StringBuilder();

		for (int i = 0; i < len; i++) {
	        sb.append(ints[i] + ",");
	        total += ints[i];
	    }
	    
	    if(total == N){
	    	System.out.println(sb.toString().substring(0, sb.toString().length() - 1));
	    	counter++;
	    }
	}  
	
	
}

class Node{
	
	public int val;
	public Node left;
	public Node right;
	
	public Node(int val){
		this.val = val;
	}
}