数据结构操作与算法应用-优快云博客

本文链接：https://blog.youkuaiyun.com/starryHW/article/details/129508700

1.链表

1.1 理论

用数组关联链表：

1.2 单链表基本操作

实现一个单链表，链表初始为空，支持三种操作：

1.向链表头插入一个数；
2.删除第 k个插入的数后面的数；
3.在第 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 m;
int head,e[N],ne[N],idx;
void init()
{
    head = -1;
    idx = 0;
}
void addhead(int x)
{
    e[idx] = x , ne[idx] = head , head = idx ++;
}
void add(int k , int x)
{
    e[idx] = x , ne[idx] = ne[k] , ne[k] = idx ++;
}
void remove(int k)
{
    ne[k] = ne[ne[k]];
}
int main()
{
    cin >> m;
    init();
    while(m --)
    {
        int k,x;
        char se;
        cin >> se;
        if(se == 'H')
        {
            cin >> x;
            addhead(x);
        }else if(se == 'D')
        {
            cin >> k;
            if(!k) head = ne[head];
            else remove(k-1);
        }
        else
        {
            cin >> k >> x;
            add(k-1 , x);
        }
    }
    for(int i = head ; i != -1 ; i = ne[i] ) cout << e[i] <<" ";
    cout<<endl;
    return 0;
}

1.3 双链表基本操作

初始化双链表： 0 和 1 不算实质内容：
在节点右边或者左边插入节点：

若在下标是k的左边插入x，则可调用add(l[k], x)
删除第k个的节点

4.例题

实现一个双链表，双链表初始为空，支持 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 = 1e5 + 10;

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


//! 初始化
void init()
{
    l[1] = 0, r[0] = 1;//* 初始化 第一个点的右边是 1   第二个点的左边是 0
    idx = 2;//! idx 此时已经用掉两个点了
}

//* 在第 K 个点右边插入一个 X 
void add(int k, int x)
{
    e[idx] = x;
    l[idx] = k;
    r[idx] = r[k]; //todo 这边的 k 不加 1 ， 输入的时候 k+1 就好
    l[r[k]] = idx;
    r[k] = idx;
    idx++;
}//! 当然在 K 的左边插入一个数 可以再写一个 ， 也可以直接调用我们这个函数，在 k 的左边插入一个 数 等价于在 l[k] 的右边插入一个数 add(l[k],x)

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

int main(void)
{
    ios::sync_with_stdio(false);
    cin >> m;

    init();

    while(m--)
    {
        string op;
        cin >> op;
        int k, x;
        if(op=="R")
        {
            cin >> x;
            add(l[1], x); //!   0和 1 只是代表 头和尾  所以   最右边插入 只要在  指向 1的 那个点的右边插入就可以了
        }
        else if(op=="L")//! 同理  最左边插入就是 在指向 0的数的左边插入就可以了   也就是可以直接在 0的 有右边插入
        {
            cin >> x;
            add(0, 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] << ' ';

    return 0;
}

2.栈–数组模拟

实现一个栈，栈初始为空，支持四种操作：

1.push x – 向栈顶插入一个数 x；
2.pop – 从栈顶弹出一个数；
3.empty – 判断栈是否为空；
4.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 st[N];
int top = -1;
int n;
int main()
{
    cin >> n;
    while(n--)
    {
        string s;
        cin >> s;

        //栈顶所在索引往后移动一格，然后放入x。
        if(s == "push")
        {
            int a;
            cin >> a;
            st[++top] = a;
        }

        //往前移动一格
        if(s == "pop")
        {
            top --;
        }
        //返回栈顶元素
        if(s == "query")
        {
            cout << st[top] << endl;
        }
        //大于等于 0 栈非空，小于 0 栈空
        if(s == "empty")
        {
            cout << (top == -1 ? "YES" : "NO") << endl;
        }
    }
}

2.1 单调栈

给定一个长度为 N的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 −1。

输入格式第一行包含整数 N，表示数列长度。

第二行包含 N个整数，表示整数数列。

输出格式共一行，包含 N个整数，其中第 i个数表示第 i个数的左边第一个比它小的数，如果不存在则输出 −1。

数据范围
1≤N≤105

1≤数列中元素≤109
输入样例：
5
3 4 2 7 5
输出样例：
-1 3 -1 2 2

在这里插入图片描述
代码：

下面用printf 和 scanf 效率会提高十倍：

3. 队列

3.1 单调队列

队列里面存的是下标：
在这里插入图片描述

给定一个大小为 n≤10 e6的数组。

有一个大小为 k的滑动窗口，它从数组的最左边移动到最右边。

你只能在窗口中看到 k个数字。

每次滑动窗口向右移动一个位置。

以下是一个例子：

该数组为 [1 3 -1 -3 5 3 6 7]，k为 3。

       窗口位置	        最小值	      最大值
[1 3 -1] -3 5 3 6 7	    -1	           3
1 [3 -1 -3] 5 3 6 7	    -3	           3
1 3 [-1 -3 5] 3 6 7	    -3	           5
1 3 -1 [-3 5 3] 6 7	    -3	           5
1 3 -1 -3 [5 3 6] 7	     3	           6
1 3 -1 -3 5 [3 6 7]	     3	           7
你的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。

输入格式
输入包含两行。

第一行包含两个整数 n和 k，分别代表数组长度和滑动窗口的长度。

第二行有 n个整数，代表数组的具体数值。

同行数据之间用空格隔开。

输出格式
输出包含两个。

第一行输出，从左至右，每个位置滑动窗口中的最小值。

第二行输出，从左至右，每个位置滑动窗口中的最大值。

输入样例：
8 3
1 3 -1 -3 5 3 6 7
输出样例：
-1 -3 -3 -3 3 3
3 3 5 5 6 7

在这里插入图片描述

3.2 KMP算法

思想与前面的单调栈和单调队列比较相似：就是去掉肯定不需要的步骤或是数据
在这里插入图片描述

例题：

给定一个字符串 S，以及一个模式串 P，所有字符串中只包含大小写英文字母以及阿拉伯数字。

模式串 P在字符串 S中多次作为子串出现。
求出模式串 P在字符串 S中所有出现的位置的起始下标。

输入格式
第一行输入整数 N，表示字符串 P 的长度。
第二行输入字符串 P。
第三行输入整数 M，表示字符串 S的长度。
第四行输入字符串 S。

输出格式
共一行，输出所有出现位置的起始下标（下标从 0开始计数），整数之间用空格隔开。

数据范围
1≤N≤105

1≤M≤106
输入样例：
3
aba
5
ababa
输出样例：
0 2

在这里插入图片描述