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

#include<iostream>
using namespace std;
#include<vector>

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

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) {
        /**
        使用对二叉树的层序遍历方式实现(队列的数据结构)
        维护数据类型为 TreeNode*   和数据类型为 vector<int > 的队列
        在对二叉树中的节点进行中序遍历的过程中,将每个节点存储到队列的同时
        同时将由根节点到树中的当前节点的路径(从二叉树的根节点到树中的任意一个节点的路径存在且唯一)
        构成的向量作为整体添加到队列中
        **/

        vector<TreeNode* > node_queue;
        vector<vector<int> > path_queue;
        vector<int> sum;

        if(root==NULL){
            return path_queue;
        }
        node_queue.push_back(root);
        vector<int> temp_path;
        temp_path.push_back(root->val);
        path_queue.push_back(temp_path);
        sum.push_back(root->val);

        TreeNode* temp_node=new TreeNode(-1);

        vector<vector<int> > result_path;
        int temp_sum;

        while(node_queue.size()>0){
            temp_node=node_queue[0];
            node_queue.erase(node_queue.begin());

            temp_path=path_queue[0];
            path_queue.erase(path_queue.begin());

            temp_sum=sum[0];
            sum.erase(sum.begin());

            if(temp_node->left==NULL and temp_node->right==NULL and temp_sum==expectNumber){
                if(result_path.size()==0){
                    result_path.push_back(temp_path);
                }
                else{
                    unsigned int temp_length=temp_path.size();
                    int suit_index=-1;
                    for(unsigned int i=0;i<result_path.size();i++){
                        if(temp_length>result_path[i].size()){
                            suit_index=i;
                            break;
                        }
                    }
                    if(suit_index==-1){
                        // 将新得到的路径插入到result_path最后一位
                        result_path.push_back(temp_path);
                    }
                    else{
                        result_path.insert(result_path.begin()+suit_index,temp_path);
                    }
                }
            }
            else{
                if(temp_node->left!=NULL){
                    node_queue.push_back(temp_node->left);
                    vector<int> left_seq=temp_path;
                    left_seq.push_back(temp_node->left->val);
                    path_queue.push_back(left_seq);
                    sum.push_back(temp_sum+temp_node->left->val);
                }
                if(temp_node->right!=NULL){
                    node_queue.push_back(temp_node->right);
                    vector<int> right_seq=temp_path;
                    right_seq.push_back(temp_node->right->val);
                    path_queue.push_back(right_seq);
                    sum.push_back(temp_sum+temp_node->right->val);
                }
            }
        }
        return result_path;
    }
};

int main(){
    TreeNode *root=new TreeNode(1);
    root->left=new TreeNode(2);
    root->right=new TreeNode(3);

    root->left->left=new TreeNode(4);
    root->left->right=new TreeNode(5);

    root->right->left=new TreeNode(6);
    root->right->right=new TreeNode(7);

    root->left->left->left=new TreeNode(8);
    root->left->left->right=new TreeNode(9);

    root->left->right->left=new TreeNode(10);
    root->left->right->right=new TreeNode(11);

    root->right->left->left=new TreeNode(12);
    root->right->left->right=new TreeNode(13);

    root->right->right->left=new TreeNode(14);
    root->right->right->right=new TreeNode(15);

    Solution a;
    vector<vector<int> > result;
    result=a.FindPath(root,11);

    return 0;
}