剑指Offer第24题 - 二叉树中和为某一值的路径 （C++）

题目描述

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

 

思路：递归，用两个列表分别存储可能的结果 res列表 以及 总的筛出的结果 buffer列表

深入理解一下：递归之后pop元素的操作，因为递归回到上一层，res也需要回到上一个状态

另外一点需要注意的时：Python版本 res复制到 buffer中时一定要深复制  res[:] 或者 res.copy

否则，res.pop时 buffer中的值也会跟着变化。

Python 完整版

“”“
测试用例：
输入：
9
6 3 1 # # 4 1 # # # # # # # 1

输出：
[6, 3]
[6, 1, 1, 1]


输入：
7
5 # 1 # # 2 #

输出：
No path

输出：

”“”
class BTNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None


class Solution:
    # def __init__(self):
    #     self.buffer = []
    #     self.res = []
    buffer = []
    res = []

    def Main(self):
        key = int(input())
        mid = input().split(' ')
        node_list = []
        for one in mid:
            if one != '#':
                node_list.append(int(one))
            else:
                node_list.append(one)

        # print(node_list)

        Nodes = [BTNode(_) for _ in node_list]
        for i in range(int(len(Nodes)/2)):  # 层次遍历 构建（复原）二叉树
            if Nodes[2*i+1].value != '#':
                Nodes[i].left = Nodes[2*i+1]
            if Nodes[2*i+2].value != '#':
                Nodes[i].right = Nodes[2*i+2]

        # print(type(key), key)
        # for one in Nodes:
        #     print(one, one.value, one.left, one.right)

        if len(Nodes) < 0:
            print('No path')
        else:
            self.findPath(Nodes[0], key)
            if len(self.buffer) == 0:
                print('No path')
            else:
                for one in self.buffer:
                    print(one)

    def findPath(self, root, key):
        if not root:
            return self.buffer

        self.res.append(root.value)
        # print(self.res)
        if not root.left and not root.right and root.value == key:
            self.buffer.append(self.res[:])  # 注意：这里需要深复制
            # print(self.buffer)

        self.findPath(root.left, key-root.value)
        self.findPath(root.right, key-root.value)
        if len(self.res) > 0:
            self.res.pop()

        # print(self.buffer)
        return self.buffer


Solution().Main()

 

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> > buffer;
    vector<int> tmp;
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root==NULL)
            return buffer;
        tmp.push_back(root->val);
        if((expectNumber-root->val)==0 && root->left==NULL && root->right==NULL)
        {
            buffer.push_back(tmp);
        }
        FindPath(root->left,expectNumber-root->val);
        FindPath(root->right,expectNumber-root->val);
        if(tmp.size()!=0)
            tmp.pop_back(); //弹出动态数组最后元素
        return buffer;
    }
};