二叉树中和为某一值的路径

题目描述

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

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}

       该题是考察树的遍历，我们可以逆向思维，从叶子节点到根节点只会有一条路径，所有关键就在于遍历出这条路径并记录下和值就能达到题意所说。

     实现如下：

    

#pragma once
#include <vector>
using namespace std;

namespace tree_sum
{
    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> vec;
            int sum = 0;
            _expectNumber = expectNumber;

            if (root == nullptr)
            {
                return ret;
            }
            foreach(root, vec, ret, sum);

            for (int i = 0; i < ret.size(); ++i)
            {
                for (int j = i + 1; j < ret.size(); ++j)
                {
                    if (ret[i].size() < ret[j].size())
                    {
                        vector<int> vec = ret[i];
                        ret[i] = ret[j];
                        ret[j] = vec;
                    }
                }
            }

            return ret;
        }

        void foreach(TreeNode* root, vector<int> vec, vector<vector<int>> &ret, int sum)
        {
            sum += root->val;
            vec.push_back(root->val);

            if (root->left == nullptr && root->right == nullptr)
            {
                if (sum == _expectNumber)
                {
                    ret.push_back(vec);
                }
                return;
            }
            if (root->left != nullptr)
            foreach(root->left, vec, ret, sum);
            if (root->right != nullptr)
            foreach(root->right, vec, ret, sum);
        }

        int _expectNumber;
    };
}

test.cpp

#pragma once
#include "tree_sum.h"

namespace tree_sum
{
    class tree_sum_test
    {
    public:
        tree_sum_test();
        ~tree_sum_test();

        void start_case()
        {
            TreeNode *root1 = new TreeNode(1);
            TreeNode *root2 = new TreeNode(2);
            TreeNode *root3 = new TreeNode(3);
            TreeNode *root4 = new TreeNode(28);
            TreeNode *root5 = new TreeNode(5);
            TreeNode *root6 = new TreeNode(6);
            TreeNode *root7 = new TreeNode(7);
            TreeNode *root8 = new TreeNode(8);
            TreeNode *root9 = new TreeNode(9);
            TreeNode *root10 = new TreeNode(10);
            TreeNode *root11 = new TreeNode(11);

            root1->left = root2;
            root1->right = root3;

            root2->left = root4;
            root2->right = root5;

            root5->left = root6;
            root5->right = root7;

            root3->right = root8;

            root8->right = root9;

            root9->left = root10;
            root9->right = root11;

            vector<vector<int> >  ret;
            Solution s;
        //    root1 = nullptr;
            ret = s.FindPath(root1, 31);
        }
    private:

    };
}

二、优化

     我们发现，生成完二维数组后，还进行了一次排序，把大的放在前面，这部分应该有优化的空间。

     优化实现，暂无。