C++手写简单STL(数组模拟实现STL)

有STL库函数了，为什么还要用数组模拟？
因为STL库的速度是要比数组模拟慢2-3倍的，在某些题目中会有极限数据卡在超时的边缘，这时候如果你能很快的用数组进行模拟，就可以直接AC这个题目，而不再考虑有没有可能极限数据会超时。

单链表

单链表是一中存储带有指向信息的动态数组，可在任意位置删除或添加结点，单链表最常用的地方在于有向图的存储，当然无向图也可以看做是两点之间有两条边的有向图。

826. 单链表

实现一个单链表，链表初始为空，支持三种操作：
向链表头插入一个数；
删除第 k 个插入的数后面的数；
在第 k 个插入的数后插入一个数。
现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。

注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。

输入格式

第一行包含整数 M，表示操作次数。
接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：

H x，表示向链表头插入一个数 x。
D k，表示删除第 k 个插入的数后面的数（当 k 为 0 时，表示删除头结点）。
I k x，表示在第 k 个插入的数后面插入一个数 x（此操作中 k 均大于 0）。

输出格式

共一行，将整个链表从头到尾输出。

数据范围

1≤M≤100000
所有操作保证合法。

输入样例：

10
H 9
I 1 1
D 1
D 0
H 6
I 3 6
I 4 5
I 4 5
I 3 4
D 6

输出样例：

6 4 6 5

样例代码

#include<iostream>

using namespace std;

const int N=100010;
int head,e[N],ne[N],idx;
//head 头结点 e[i] 表示i的值 ne[i] 表示i的下一个结点 idx 表示用到了那个点
void init()
{//头结点的初始化
    head=-1;
    idx=0;
}
void add_head(int x)
{//在头结点插入X
    ne[idx]=head;//使idx指向原头结点，从而使idx代替原头结点，成为新的头结点
    e[idx]=x;//把x赋给新的头结点
    head=idx;//令新头结点的位置更新为idx
    idx++;//更新idx
}

void add(int k,int x)
{//在k后插入x
    e[idx]=x;//将x赋给idx
    ne[idx]=ne[k];//使idx的下一个结点指向原先k的下一个结点
    ne[k]=idx;//使k的下一个结点指向新创立的idx
    idx++;//更新idx
}

void remove(int k)
{//直接使k的指向结点成为k下一个结点的指向结点
    ne[k]=ne[ne[k]];
}

int main()
{
    int m;
    cin >> m;
    init();//初始化

    while (m--)
    {
        int k, x;
        char op;

        cin >> op;
        if (op == 'H')
        {//在头结点插入X
            cin >> x;
            add_head(x);
        }
        else if (op == 'D')
        {//删除第k个位置的结点
            cin >> k;
            if (!k) head = ne[head];
            else remove(k - 1);
        }
        else
        {//在k后添加一个结点
            cin >> k >> x;
            add(k - 1, x);
        }
    }
	//从头结点开始，不断更新i，直到i指向了-1，即空节点
    for (int i = head; i != -1; i = ne[i]) cout << e[i] << ' ';
    cout << endl;
    return 0;
}

双链表

双链表与单链表类似，差别在于，双链表的每个点都可以指向它的前一个点和后一个点。

827. 双链表

实现一个双链表，双链表初始为空，支持 5 种操作：
1.在最左侧插入一个数；
2.在最右侧插入一个数；
3.将第 k 个插入的数删除；
4.在第 k 个插入的数左侧插入一个数；
5.在第 k 个插入的数右侧插入一个数
现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。

注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。

输入格式

第一行包含整数 M，表示操作次数。

接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：
L x，表示在链表的最左端插入数 x。
R x，表示在链表的最右端插入数 x。
D k，表示将第 k 个插入的数删除。
IL k x，表示在第 k 个插入的数左侧插入一个数。
IR k x，表示在第 k 个插入的数右侧插入一个数。

输出格式

共一行，将整个链表从左到右输出。

数据范围

1≤M≤100000
所有操作保证合法。

输入样例：

10
R 7
D 1
L 3
IL 2 10
D 3
IL 2 7
L 8
R 9
IL 4 7
IR 2 2

输出样例：

8 7 7 3 2 9

样例代码

#include<iostream>

using namespace std;

const int N = 100010;

int m;
int e[N], l[N], r[N], idx;

void init()
{
    //0表示左端点，1表示右端点
	r[0] = 1, l[1] = 0;
	idx = 2;
}
//在下标k的右边，插入x
void add(int k, int x)
{
	e[idx] = x;
	l[idx] = k, r[idx] = r[k];
	l[r[k]] = idx,r[k] = idx++;
	
}
//在下标k的左边插入x
//add(l[k],x)

//删除第k个点
void remove(int k)
{
	l[r[k]] = l[k];
    r[l[k]] = r[k];
}

int main()
{
    cin >> m;
    
    init();
    
    while (m--)
    {
        string op;
        cin >> op;
        int k, x;
        if (op == "L")
        {
            cin >> x;
            add(0, x);
        }
        else if (op == "R")
        {
            cin >> x;
            add(l[1], x);
        }
        else if (op == "D")
        {
            cin >> k;
            remove(k + 1);
        }
        else if (op == "IL")
        {
            cin >> k >> x;
            add(l[k + 1], x);
        }
        else
        {
            cin >> k >> x;
            add(k + 1, x);
        }
    }
    for (int i = r[0]; i != 1; i = r[i]) cout << e[i] << ' ';
    cout <<endl;

    return 0;
}

栈

828. 模拟栈

实现一个栈，栈初始为空，支持四种操作：
push x – 向栈顶插入一个数 x；
pop – 从栈顶弹出一个数；
empty – 判断栈是否为空；
query – 查询栈顶元素。
现在要对栈进行 M 个操作，其中的每个操作 3 和操作 4 都要输出相应的结果。

输入格式

第一行包含整数 M，表示操作次数。
接下来 M 行，每行包含一个操作命令，操作命令为 push x，pop，empty，query 中的一种。

输出格式

对于每个 empty 和 query 操作都要输出一个查询结果，每个结果占一行。
其中，empty 操作的查询结果为 YES 或 NO，query 操作的查询结果为一个整数，表示栈顶元素的值。

数据范围

1≤M≤100000,
1≤x≤109
所有操作保证合法。

输入样例：

10
push 5
query
push 6
pop
query
pop
empty
push 4
query
empty

输出样例：

5
5
YES
4
NO

样例代码

#include <iostream>

using namespace std;

const int N = 100010;

int m;
int skt[N],tt=-1;
//tt表示头结点下标，tt从0开始
int main()
{
    cin>>m;
    while(m--)
    {
        string op;
        cin>>op;
        if(op=="push")cin>>skt[++tt];
        if(op=="pop")tt--;
        if(op=="empty")
            if(!tt)cout<<"YES"<<endl;
            else cout<<"NO"<<endl;
        if(op=="query")cout<<skt[tt]<<endl;
    }
    
    return 0;
}

队列

829. 模拟队列

实现一个队列，队列初始为空，支持四种操作：
push x – 向队尾插入一个数 x；
pop – 从队头弹出一个数；
empty – 判断队列是否为空；
query – 查询队头元素。
现在要对队列进行 M 个操作，其中的每个操作 3 和操作 4 都要输出相应的结果。

输入格式

第一行包含整数 M，表示操作次数。
接下来 M 行，每行包含一个操作命令，操作命令为 push x，pop，empty，query 中的一种。

输出格式

对于每个 empty 和 query 操作都要输出一个查询结果，每个结果占一行。
其中，empty 操作的查询结果为 YES 或 NO，query 操作的查询结果为一个整数，表示队头元素的值。

数据范围

1≤M≤100000,
1≤x≤109,
所有操作保证合法。

输入样例：

10
push 6
empty
query
pop
empty
push 3
push 4
pop
query
push 6

输出样例：

NO
6
YES
4

样例代码

#include <iostream>

using namespace std;

const int N=100010;

int m;
int q[N],hh,tt=-1;
//hh，表示队头tt表示队尾，tt从0开始
int main()
{
    cin>>m;

    while(m--)
    {
        string op;
        int x;

        cin>>op;
        if (op=="push")
        {
            cin>>x;
            q[++tt]=x;
        }
        if(op=="pop")hh++;
        if(op=="empty")cout<<(hh<=tt?"NO":"YES")<<endl;
        if(op=="query")cout<<q[hh]<<endl;
    }
    return 0;
}