C++牛客网编程（十三）

目录

序列化二叉树

用两个栈实现队列

包含min函数的栈

---

序列化二叉树

描述：请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。

二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）

二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，可以根据层序遍历的方案序列化，如下图:

层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。

当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。

数据范围：节点数 n≤100，树上每个节点的值满足 0≤val≤1500

要求：序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)

思路：利用先序遍历进行先序排序

class Solution {
public:
    char* Serialize(TreeNode* root) {    
        if(!root) return "#";
        string res=to_string(root->val);
        res.push_back(',');
        char* left=Serialize(root->left);
        char* right=Serialize(root->right);
        char* ret=new char[strlen(left)+strlen(right)+res.size()];
        strcpy(ret,res.c_str());
        strcat(ret,left);
        strcat(ret,right);
        return ret;
    }
    TreeNode* deseri(char* s){
        if(*s=='#'){
            ++s;
            return nullptr;
        }
        int num=0;
        while(*s!=','){
            num=num*10+(*s-'0');
            ++s;
        }
        ++s;
        TreeNode* root=new TreeNode(num);
        root->left=deseri(s);
        root->right=deseri(s);
        return root;
    }
    TreeNode* Deserialize(char *str) {
        return deseri(str);
    }
};

重点：忽略了逗号

用两个栈实现队列

描述：用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。

数据范围： n≤1000n

要求：存储n个元素的空间复杂度为 O(n) ，插入与删除的时间复杂度都是 O(1)

思路：两个栈，第一个栈只负责加入，top是队列尾部，如果要pop需要另外一个栈改变序列方向，将序列加入第二个栈，则top是队列头部，可以pop。总结而言：如果是push只用往stack1中加入数据，如果是pop，看stack2是否为空，若不为空直接pop，若为空，则需要将stack1中的腾到stack2再pop。

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        int tmp;
        if(stack2.empty()){
            while(!stack1.empty()){
                tmp=stack1.top();
                stack1.pop();
                stack2.push(tmp);
            }
        }
        if(!stack2.empty()) {
            tmp=stack2.top();
            stack2.pop();
            return tmp;
        }
        else {
            return -1;
        }
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

包含min函数的栈

描述：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的 min 函数，输入操作时保证 pop、top 和 min 函数操作时，栈中一定有元素。

此栈包含的方法有：

push(value):将value压入栈中

pop():弹出栈顶元素

top():获取栈顶元素

min():获取栈中最小元素

数据范围：操作数量满足 0≤n≤300 ，输入的元素满足 ∣val∣≤10000
进阶：栈的各个操作的时间复杂度是 O(1) ，空间复杂度是 O(n)

思路：用两个栈，一个栈保存原来序列，另外一个栈保存最小元素。最初想法是只保存最小的一个元素就可以了，后来发现在pop的过程中最小元素是跟随着改变的，最好保存每个存入元素阶段的最小元素。

class Solution {
public:
    stack<int> normal,minval;
    void push(int value) {
        normal.push(value);
        if(minval.empty())
            minval.push(value);
        else{
            if(value<=minval.top()){
                minval.push(value);
            }   
            else minval.push(minval.top());
        }
    }
    void pop() {
        minval.pop();
        normal.pop();
    }
    int top() {
        return normal.top();
    }
    int min() {
        return minval.top();
    }
};