二叉树系列

思路：

采用队列，将节点进行打印，若该节点具有子节点，则将子节点加入打印序列，直至为空。

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        queue<TreeNode*> q; //队列存放每棵树
        q.push(root); //单独push,不能以root初始化
        vector<int> v;//vector存放节点值
        if(root==NULL)
            return v;
        while(!q.empty()){
            root=q.front();//获取第一棵树
            q.pop();//弹出第一棵树，队列先进先出
            v.push_back(root->val);
            if(root->left)
                q.push(root->left);//队列是push操作
            if(root->right)
                q.push(root->right);
        }
        return v;
    }
};

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
    /*思路：
    已知条件：后序序列最后一个值为root；二叉搜索树左子树值都比root小，右子树值都比root大。
    1、确定root；
    2、遍历序列（除去root结点），找到第一个大于root的位置，则该位置左边为左子树，右边为右子树；
    3、遍历右子树，若发现有小于root的值，则直接返回false；
    4、分别判断左子树和右子树是否仍是二叉搜索树（即递归步骤1、2、3）。*/
        
        if(sequence.size()==0)//分情况考虑，鲁棒性
            return false;
        return judge(sequence,0,sequence.size()-1); // 返回值
    }
    bool judge(vector<int> sequence,int l,int r){
        if(l>=r)       //当后续递归到某个左子树(单节点)，返回true
            return true;
        int i;  //作为全局变量，记录右根的起始位置
        for(i=l;i<=r-1;i++){
            if (sequence[i]>sequence[r])
                break;    //跳出，或者while也行,只需要记录索引
        }
        for(int j=i;j<=r-1;j++)
            if (sequence[j]<sequence[r]) //一旦右子树中出现小于根的值，不满足搜索树定义，返回false
                return false;
        return judge(sequence,l,i-1)&&judge(sequence,i,r-1); //同时进行比较，返回交的结果
    }
};

注意：

此算法实际上没有实现长度大的数组靠前这一点。

class Solution {
public:
    vector<vector<int> > FindPath(TreeNode* root, int expectNumber) {
        vector<vector<int>> path;
        vector<int> current_path;
        //int current_sum = 0;
        if (root)
            dfs(root,expectNumber,path,current_path); //调用时很简单
        return path;
    }

    void dfs(TreeNode* root, int expectNumber, vector<vector<int>> &path, vector<int> &current_path){  //定义函数时(类型+地址引用，返回void), 原地址对值进行修改，不用返回值
        current_path.push_back(root->val);
        expectNumber -= root->val; //不采用变量累计sum,而是目标值递减
        if (!root->left&&!root->right&&expectNumber==0){ // 到达叶子节点，进行判断
            path.push_back(current_path); //采用push_back加入满足条件的子路径
        }
        if (root->left)
            dfs(root->left, expectNumber, path, current_path);    //递归递归
        if (root->right)
            dfs(root->right, expectNumber, path, current_path);
        current_path.pop_back();//上述条件不满足则返回父节点
    };

};