STL LeetCode练习

重建二叉树（vector）

​
输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

示例 1:
Input:
preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output:
[3,9,20,null,null,15,7]
示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]
限制：
0 <= 节点个数 <= 5000

​

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    // 递归解决：前序遍历是根左右，中序遍历是左根右，我们可以根据根来分别划分 前序数组和中序数组，然后递归处理划分的数组即可
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.empty()||inorder.empty())return nullptr;
        // 1、建立根节点，然后根据根节点来划分 前序数组 和 中序数组
        TreeNode *root=new TreeNode(*preorder.begin());
        // 2、来找到 中序数组 中根节点的位置
        auto it=find(inorder.begin(),inorder.end(),*preorder.begin());
        // 3、划分中序数组，根据根节点的位置，因为中序数组根节点的左边为左子树，右边为右子树
        vector<int> iLeft(inorder.begin(),it),iRight(it+1,inorder.end());
        // 4、划分前序数组，根据中序数组的左右子树的大小
        int n=iLeft.size();
        vector<int> pLeft(preorder.begin()+1,preorder.begin()+1+n),pRight(preorder.begin()+1+n,preorder.end());
        // 5、递归处理左右子树
        root->left=buildTree(pLeft,iLeft);
        root->right=buildTree(pRight,iRight);
        return root;
    }
};

用两个栈实现队列（stack）

剑指 Offer 09. 用两个栈实现队列
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：
输入：
[“CQueue”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[3],[],[]]
输出：
[null,null,3,-1]
示例 2：
输入：
[“CQueue”,“deleteHead”,“appendTail”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[],[5],[2],[],[]]
输出：
[null,-1,null,null,5,2]
提示：

1 <= values <= 10000 最多会对 appendTail、deleteHead 进行 10000 次调用

题目解释:
输入： [“CQueue”,“appendTail”,“deleteHead”,“deleteHead”]
这里是要执行的方法，从左到右执行

[[],[3],[],[]]对应上面的方法，是上面方法的参数。CQueue和deleteHead方法不需要指定数字，只有添加才需要指定数字

1.创建队列，返回值为null

2.将3压入栈，返回值为null

3.将栈底的元素删除，也就是消息队列中先进来的元素，所以是deleteHead，返回该元素的数值，所以为3

4.继续删除栈底的元素，但是没有元素了，所以返回-1

所以就有了下面的输出 输出：[null,null,3,-1]

示例 2： 输入：
[“CQueue”,“deleteHead”,“appendTail”,“appendTail”,“deleteHead”,“deleteHead”]

[[],[],[5],[2],[],[]]

1.创建队列，返回值为null

2.删除栈底的元素，但是没有元素，所以返回-1

3.把5压入栈，返回null

4.把2压入栈，返回null

5.删除栈底的一个元素，也就是消息队列中先进来的元素，所以是deleteHead，就是最先进来的5，返回值为5，

6.删除栈底的一个元素，就是后进来的2，返回值为2，

所以就有了下面的输出

输出：[null,-1,null,null,5,2]

有没有发现先进来的数字，首先显示出来了，但是题目中说要使用栈，栈是先进后出的，使用栈来实现先进先出，在这里使用两个栈就好了，从一个进来再到另一个栈，这样顺序就是先进先出了。题目的主旨写在第一句，就是，使用两个栈实现一个队列

class CQueue {
private:
    stack<int>st1,st2;

public:
    CQueue() {}
    
    void appendTail(int value) {
        st1.push(value);
         }
    
    int deleteHead() {
        if(st1.empty()&&st2.empty())return -1;
        if(st2.size()==0){
            while(st1.size()){
                st2.push(st1.top());
                st1.pop();
            }
        }
        int x=st2.top();
        st2.pop();
        return x;

    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */