【剑指offer】（33~36）

33：二叉树的后序遍历序列

题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

    bool VerifySquenceOfBST(vector<int> sequence) {
        int size=sequence.size();
        if(size==0) 
            return false;
        int root=sequence[size-1];
        int i=0;
        vector<int> seq_left;
        for(;i<size-1;i++)
        {
            if(root<sequence[i])
                break;
            seq_left.push_back(sequence[i]);         
        }
        int j=i;
        vector<int> seq_right;
        for(;j<size-1;j++)
        {
            if(root>sequence[j])
                return false;
            seq_right.push_back(sequence[j]);
        }
        bool left=true,right=true;
        if(i>0)
            left=VerifySquenceOfBST(seq_left);
        if(i<size-1)
            right=VerifySquenceOfBST(seq_right);
        return left&&right；        
    }

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

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

    vector<vector<int> > vec;
    vector<int> tmp;
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {        
        if(root==NULL)
            return vec;
        tmp.push_back(root->val);
        if((expectNumber-root->val)==0&&root->left==NULL&&root->right==NULL){
            vec.push_back(tmp);
        }
       FindPath(root->left,expectNumber-root->val);
       FindPath(root->right,expectNumber-root->val);
       if(tmp.size()!=0)
           tmp.pop_back();
        return vec;
    }

35：复杂链表的复制

题目：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。

struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};

RandomListNode* Clone(RandomListNode* pHead)
    {
        if(pHead==NULL) return NULL;
        RandomListNode* currNode=pHead;
        //复制next
        while(currNode!=NULL)
        {
            RandomListNode* node=new RandomListNode(currNode->label);
            node->next=currNode->next;
            currNode->next=node;
            currNode=node->next;
        }

        //复制random
        currNode=pHead;
        while(currNode!=NULL)
        {
            RandomListNode* node=currNode->next;
            if(currNode->random!=NULL)
                node->random=currNode->random->next;
            currNode=node->next;
        }

        //拆分链表
        RandomListNode *pClonHead=pHead->next;
        currNode=pHead;
        while(currNode->next!=NULL)
        {
            RandomListNode *tmp=currNode->next;
            currNode->next=tmp->next;
            currNode=tmp;
        }
        return pClonHead;
    }

36：二叉搜索树与双向链表

题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(pRootOfTree==NULL)
            return NULL;
        if(pRootOfTree->left==NULL&&pRootOfTree->right==NULL)
            return pRootOfTree;
        TreeNode* left=Convert(pRootOfTree->left);
        TreeNode* p=left;
        while(p!=NULL&&p->right!=NULL)
            p=p->right;
        if(left!=NULL){
            p->right=pRootOfTree;
            pRootOfTree->left=p;
        }
        TreeNode* right=Convert(pRootOfTree->right);
        if(right!=NULL){
            right->left=pRootOfTree;
            pRootOfTree->right=right;
        }
        return left!=NULL?left:pRootOfTree;
    }