牛客网 - 简单的数据结构

题目描述

栗酱有一天在网上冲浪的时候发现了一道很有意思的数据结构题。

该数据结构形如长条形。

一开始该容器为空，有以下七种操作。

1 a从前面插入元素a

2 从前面删除一个元素

3 a从后面插入一个元素

4 从后面删除一个元素

5 将整个容器头尾翻转

6 输出个数和所有元素

7 对所有元素进行从小到大排序

输入描述:

只有一组数据，第一行n≤50000,m≤200000, a≤100000 代表最大数据数目和操作次数。
接下来每一行一个操作如上描述。保证所有操作合法（不会在容器为空时删除元素）。
6、7操作共计不会超过10次。

输出描述:

当执行6操作时，第一行先输出当前的个数，然后从头到尾按顺序输出，每两个元素之间用一个空格隔开，末尾不能有空格。

输入

10 9
1 1
3 5
3 4
6
4
5
6
7
6

输出

3
1 5 4
2
5 1
2
1 5

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

链接：https://ac.nowcoder.com/acm/problem/14661
来源：牛客网
 

题目分析：

这个题目非常简单，直接暴力模拟就行了，可以自己用数组模拟，如果会用STL里的容器就方便很多了，可以用双端队列，头文件是 #include<deque> ，也可以用vector，头文件是 #include <vector> ，两种方法我都会在下面附上代码，值得一提的是，在本题中我发现switch - case 比 if -else 快，我在使用if -else 加 vector 时超时了，但我关闭同步流，加快读写速度后就A了，发现别人用switch - case 加 vector A了，不过也用了九百多ms，于是我百度了一下，switch-case 是比 if - else 快一些，但是switch的执行速度并不是一直都超过if，当数据量达到万级或者百万级时，if的执行速度反而会比switch更快。使用迭代器好像也比使用类似数组下标遍历vector慢一些，不过还是差不了多少。不过后来我又看到有人使用 if - else 加vector过了，还只用了八百多，将近九百ms，难道我代码写矬了？看了一下，发现差不多，不同的是我使用了迭代器it，并且每次在开头插入和删除前都先 it = v.begin()，改掉后，发现快了一百多ms。

代码：

使用vector

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    vector <int > v;
    vector <int > :: iterator it;
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i ++){
        int op;
        cin >> op;
        int a;
        if (op == 1){
            cin >> a;
            it = v.begin();
            v.insert(it, a);
        }else if(op == 2){
            it = v.begin();
            v.erase(it);
        }else if (op == 3){
            cin >> a;
            v.push_back(a);
        }else if (op == 4){
            v.pop_back();
        }else if (op == 5){
            reverse(v.begin(), v.end());
        }else if (op == 6){
            cout << v.size() << endl;
            for (int j = 0; j < v.size() - 1; j ++){
                cout << v[j] << ' ';
            }
            cout << v[v.size() - 1] << endl;
        }else {
            sort(v.begin(), v.end());
        }
    }
    return 0;
}

使用vector并作修改后

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    vector <int > v;
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i ++){
        int op;
        cin >> op;
        int a;
        if (op == 1){
            cin >> a;
            v.insert(v.begin(), a);
        }else if(op == 2){
            v.erase(v.begin());
        }else if (op == 3){
            cin >> a;
            v.push_back(a);
        }else if (op == 4){
            v.pop_back();
        }else if (op == 5){
            reverse(v.begin(), v.end());
        }else if (op == 6){
            cout << v.size() << endl;
            for (int j = 0; j < v.size() - 1; j ++){
                cout << v[j] << ' ';
            }
            cout << v[v.size() - 1] << endl;
        }else {
            sort(v.begin(), v.end());
        }
    }
    return 0;
}

 

使用双端队列：

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;
int main()
{
    ios :: sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    deque<int> q;
    for (int i = 0; i < m; i ++){
        int op;
        cin >> op;
        int a;
        switch(op){
            case 1: 
                cin >> a;
                q.push_front(a);
                break;
            case 2:
                q.pop_front();
                break;
            case 3:
                cin >> a;
                q.push_back(a);
                break;
            case 4:
                q.pop_back();
                break;
            case 5:
                reverse(q.begin(), q.end());
                break;
            case 6:
                cout << q.size() << endl;
                for (int j = 0; j < q.size() - 1; j ++){
                    cout << q[j] << ' ' ;
                }
                cout << q[q.size() - 1] << endl;
                break;
            case 7:
                sort(q.begin(), q.end());
                break;
            default:break;
        }
    }
    return 0;
}

双端队列也可以像数组一样访问，双端队列deque是一个支持在两端高效插入或删除元素的连续线性存储空间。它就像是vector和queue的结合，与vector相比，deque在头部增删元素仅需要O(1)的时间，不过牛客网的运行时间误差有点大，同一份代码运行时间竟然能相差近两百ms。