題目描述

輸入一顆二叉樹的跟節點和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。(注意: 在返回值的list中，陣列長度大的陣列靠前)

C++

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        vector<vector<int>>ret;
        vector<int>path;
        dfs(ret,root,path,expectNumber,0,0);
        return ret;
    }

    void dfs(vector<vector<int>>&ret,TreeNode* root,vector<int>&path,int expectNumber,int len,int sum)
    {
        if(root == nullptr)
            return;
        if(len == path.size())
            path.push_back(root->val);
        else
            path[len] = root->val;

        if(sum + root->val == expectNumber && root->left == nullptr && root->right == nullptr)
        {
            vector<int>arr(len+1);
            for(int i=0;i<len+1;i++)
            {
                arr[i] = path[i];
            }
            ret.push_back(arr);
        }

        dfs(ret,root->left,path,expectNumber,len+1,sum + root->val);
        dfs(ret,root->right,path,expectNumber,len+1,sum + root->val);       
    }
};
 

java 

import java.util.ArrayList;
import java.util.Stack;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {//思路：用一個棧儲存先序遍歷所經過的路徑，每經過一個節點，target就減去對應節點的值，這樣到了葉子節點，如果能夠匹配，則target的值會等於葉子節點的值
    //root可能為null，可能只有一個節點，可能沒有和與target匹配的路徑；用一個棧儲存所經過的所有節點，當回退的時候再將棧裡元素取出
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        ArrayList<ArrayList<Integer>> arrayArrayList = new ArrayList();
        if (null == root) {
            return arrayArrayList;
        }
        Stack<Integer> stack = new Stack();
        findPathByFST(arrayArrayList, root, target, stack);
        return arrayArrayList;
    }
    private void findPathByFST(ArrayList<ArrayList<Integer>> arrayArrayList, TreeNode root, int target, Stack<Integer> stack) {
        stack.push(root.val);
        if (root.left == null && root.right == null) {
            if (root.val == target) {
                ArrayList<Integer> array = new ArrayList();//只有在獲取滿足條件的路徑下才會新建陣列
                for (Integer data : stack) {
                    array.add(data);
                }
                arrayArrayList.add(array);
            }
 
            return;
        }
        
        if (root.left != null) {
            findPathByFST(arrayArrayList, root.left, target-root.val, stack);
            stack.pop();
        } 
        
        if (root.right != null) {
            findPathByFST(arrayArrayList, root.right, target-root.val, stack);
             stack.pop();
        }
 
    }
}
 

python 

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # run:32ms memory:5736k
    def FindPath(self, root, expectNumber):
        if None == root: return []
        return self.FindAPath(root,expectNumber,[],[])
    
    def FindAPath(self,root,expectNumber,path_list,lt):
        if None == root: return 
        expectNumber = expectNumber - root.val
        lt.append(root.val)
        if expectNumber !=0:
            left_lt = list(lt)
            self.FindAPath(root.left,expectNumber,path_list,left_lt)
            right_lt = list(lt)
            self.FindAPath(root.right,expectNumber,path_list,right_lt)
        elif root.left == None and root.right == None:
            path_list.append(lt)
        return path_list