1.栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
思路：建立一个栈，一次按压入顺序压栈，每压入一个元素的时候判断与弹出序列元素是否相等，若相等，则弹出，若不等，继续压栈，都压完后看这个栈是否是空的。

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if(pushV.size()==0||popV.size()==0) return false;
        stack<int> s1;
        int len=pushV.size();
        int i=0,j=0;
        while(i<len)
        {
            s1.push(pushV[i]);
            while(!s1.empty()&&s1.top()==popV[j])
            {
                s1.pop();
                j++;//如果栈顶元素等于弹出序列元素，就依次弹出
            }
            i++;//不等于就继续压栈
        }
        return s1.empty();
    }
};

2.从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路:建立一个队列，首先放入根节点，然后当队列不为空时，再依次放入根节点的左右子节点，依次类推。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        if(root==nullptr) return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            res.push_back(q.front()->val);//将队首存入数组
            TreeNode *p=q.front();//设置一个临时变量
            q.pop();//弹出
            if(p->left)
            {
                q.push(p->left);//压入子节点
            }
            if(p->right)
            {
                q.push(p->right);//压入右节点
            }
        }
        return res;          
    }
};

3.二叉搜索树的后序遍历
输入一个非空整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路：二叉搜索树后续遍历，根节点在最后面，前面是左子树（小于根节点的值），后面是右子树（大于根节点的值），对应子树也要符合这种规律。因此我们利用递归的思想。构建两个数组，一个存储根节点的左子树，一个存储根节点的右子树。首先找到根节点，从头遍历数组，小于根节点的放入左子树，出现大于，改为放入右子树，一旦后面的值有小于根节点的，就直接返回false，如果成功遍历完数组，则递归判断左子树数组与右子树数组。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int len=sequence.size();
        if(len==0) return false;
        vector<int> left;
        vector<int> right;
        int root=sequence[len-1];//根节点
        int i=0;
        for(;i<len-1;i++)
        {
            if(sequence[i]>root)
                break;
            left.push_back(sequence[i]);//左子树的节点值都小于根节点
        }
        int j=i;
        for(;j<len-1;j++)
        {
            if(sequence[j]<root)
                return false;//右子树的节点值都大于根节点，因此出现小于根节点的，直接删除
            right.push_back(sequence[j]);
        }
        if(i>0)
            VerifySquenceOfBST(left);//有左子树的话，就递归遍历左子树
        if(i<len-1)
            VerifySquenceOfBST(right);//有右子树的话，就递归遍历右子树
        return true;
    }
};