第六天 用两个栈实现队列+双栈排序+猫狗收容所

最近由于写论文的原因，刷题的频率相对下降。为了节约时间，一般题目只有自己代码，不满意的题目会贴别人优秀代码。

用两个栈实现队列和双栈排序想法大致相同，有点像插入排序，每次通过在两个栈之间相互传输保证相对顺序，并在适当地方插入新值。

第一题

class Solution
{
public:
    void push(int node) 
    {
        if (stack1.empty())
            stack1.push(node);
        else
        {
            while (!stack1.empty())
            {
                stack2.push(stack1.top()) ;
                stack1.pop();
            }
            stack1.push(node);
            while (!stack2.empty())
            {
                stack1.push(stack2.top()) ;
                stack2.pop();
            }
        }
        
    }

    int pop() 
    {
        int x = stack1.top();
        stack1.pop();
        return x;
    }

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

第二题

class TwoStacks {
public:
    vector<int> twoStacksSort(vector<int> numbers) {
        // write code here
        if (numbers.empty()) return numbers;
        vector<int> result;
        while (!numbers.empty())
        {   
            int temp = numbers.front();
            numbers.erase(numbers.begin());
            if (result.empty())
                result.insert(result.begin(), temp);
            else
            {
                int num = 0;
                while (!result.empty() && result.front() > temp)
                {
                    numbers.insert(numbers.begin(), result.front());
                    result.erase(result.begin());
                    num++;
                }
                result.insert(result.begin(), temp);
                while(num--)
                {
                    result.insert(result.begin(), numbers.front());
                    numbers.erase(numbers.begin());
                }
            }
        }
        return result;
    }
};

猫狗这题思路：1. 两个队列，为了不用依次搜索下去，只要检查队列的头即可（时间复杂度） 2. 把操作索引直接放入队列，来判断先后。

缺点：代码太长了，感觉重复的很多。

吐槽：看了几份别人的代码，都好长...

class CatDogAsylum {
public:
    vector<int> asylum(vector<vector<int> > ope) {
        // write code here
        vector<int> result;
        if(!ope.size()) return result;
        queue<int> cat, dog;
        
        for(int i = 0; i < ope.size(); i++)
        {
            vector<int> temp = ope[i];
            if(temp[0] == 1 && temp[1] > 0)
                dog.push(i);
            if(temp[0] == 1 && temp[1] < 0)
                cat.push(i);
            if(temp[0] == 2 && !temp[1])
            {
                if(cat.empty() && !dog.empty())
                {
                    result.push_back(ope[dog.front()][1]);
                    dog.pop();
                }
                if(!cat.empty() && dog.empty())
                {
                    result.push_back(ope[cat.front()][1]);
                    cat.pop();
                }
                if(!cat.empty() && !dog.empty())
                {
                    if(cat.front() > dog.front())
                    {
                        result.push_back(ope[dog.front()][1]);
                        dog.pop();
                    }
                    else
                    {
                        result.push_back(ope[cat.front()][1]);
                        cat.pop();
                    }
                }
            }
            if(temp[0] == 2 && temp[1] == 1)
            {
                if(!dog.empty())
                {
                    result.push_back(ope[dog.front()][1]);
                    dog.pop();
                }
            }
            if(temp[0] == 2 && temp[1] == -1)
            {
                if(!cat.empty())
                {
                    result.push_back(ope[cat.front()][1]);
                    cat.pop();
                }
            }            
        }
        return result;
    }
};