Depth-first Search -- Leetcode problem113. Path Sum II

• 描述：Given a binary tree and a sum, find all root-to-leaf paths where each path’s sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

          5
         / \
        4   8
       /   / \
      11  13  4
     /  \    / \
    7    2  5   1

return

[
[5,4,11,2],
[5,8,4,5]
]

• 分析：这道题在path sum的基础上有改动，要求输出的是可能的所有情况的从根节点到叶子节点的值。
• 思路一；递归求解。(9ms)

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> paths;
        vector<int> path;
        findPath(root, sum, 0, path, paths);
        return paths;
    }
private:
    void findPath(TreeNode* root, int sum, int add, vector<int> &path, vector<vector<int>> &paths) {
        if (root == NULL) return;
        add += root -> val;
        path.push_back(root -> val);
        if (root -> right == NULL && root -> left == NULL && add == sum) {
            paths.push_back(path);
        }
        findPath(root -> left, sum, add, path, paths);
        findPath(root -> right, sum, add, path, paths);
        add -= root -> val;
        path.pop_back();
    }
};

• 思路二：非递归DFS。使用三个栈来实现，其中一个栈用vector模仿。(9ms)

public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> paths;
        if (root == NULL) return paths;
        stack<TreeNode*> my_stk;
        vector<TreeNode*> history;
        stack<int> result;
        int temp = 0;
        result.push(0);
        my_stk.push(root);
        while (!my_stk.empty()) {
            TreeNode* top = my_stk.top();
            my_stk.pop();
            while (!history.empty()) {
                TreeNode* pre = history.back();
                if (pre -> left == top || pre -> right == top) {
                    break;
                }
                history.pop_back();
            }
            temp = result.top();
            result.pop();
            temp += top -> val;
            if (top -> left == NULL && top -> right == NULL && temp == sum) {
                vector<int> path;
                for (int i = 0; i < history.size(); i++) {
                    path.push_back(history[i] -> val);
                }
                path.push_back(top -> val);
                paths.push_back(path);
            }
            history.push_back(top);
            if (top -> left) {
                my_stk.push(top -> left);
                result.push(temp);
            }
            if (top -> right) {
                my_stk.push(top -> right);
                result.push(temp);
            }
        }
        return paths;
    }
};