链表 栈和队列以及KMP算法

最新推荐文章于 2024-07-20 09:51:47 发布
最新推荐文章于 2024-07-20 09:51:47 发布
阅读量134 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71434369/article/details/129163732
版权

链表 栈和队列以及KMP算法


​
注意：做算法题的时候，尽量不要用结构体加指针的方法去实现链表，因为每次插入新节点时需要用new来申请内存空间，此操作比较慢，很容易超时，因此，我们最好使用数组来模拟链表，实现比较快。

一 链表

1.单链表

数组模拟单链表的基本思想：

用head表示头节点的下标，e[i]表示节点i的值，ne[i]表示节点i的next指针，即节点i的下一个节点的下标，idx表示当前用到了哪个点。

基本操作：

1. 初始化

void init()
{
	head = -1;//初始化为-1，表示空表
	idx = 0;//没有使用任何点，故idx为0
}

2. 插入

//将x插入到头节点的后面
void add_to_head(int x)
{
	e[idx] = x;//保存节点x
	ne[idx] = head;//节点x的指针指向头节点的后继节点
	head = idx++;//头节点的指针指向x
}

//将x插入到下标为k的节点后面
void add(int k, int x)
{
	e[idx] = x;
	ne[idx] = ne[k];
	ne[k] = idx++;
}

3. 删除

//将下标是k的节点的后面那个节点删除
void remove(int k)
{
	ne[k] = ne[ne[k]];
}

4. 遍历单链表

从头节点开始遍历，每次循环使i指向后继节点，只要头节点的下标不为-1，一直循环下去

for (int i = head; i != -1; i = ne[i]) cout << e[i] << ' ';

2.双链表

数组模拟双链表的基本思想：

用l[i]表示节点i左边的节点，r[i]表示节点i右边的节点，e[i]表示节点i的值，idx表示已经用到了的哪个点。

基本操作：

1. 初始化：

void init()
{
	//0表示左端点，1表示右端点
	r[0] = 1;
	l[1] = 0;
	idx = 2;//因为已经使用了两个点，故初始化为2
}

2.插入操作

//在下标为k的节点右边插入x，如果在下标为k的左边插入x
//直接调用以下函数，将k置为l[k]

void add(int k, int x)
{
	e[idx] = x;
	r[idx] = r[k];
	l[idx] = k;
	l[r[k]] = idx;
	r[k] = idx++;
}

3. 删除操作

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

二 栈

用数组模拟栈的基本思想：
用数组stk表示一个栈，tt表示栈顶元素下标（习惯上初始化为0）。
int tt=0;//表示栈顶
int stk[N];//表示栈

1.普通栈

基本操作：

1.1 插入：

stk[++tt] = x;//向栈顶插入x

1.2弹出：

tt--;//弹出栈顶元素

1.3 判断是否为空：

if (tt > 0) return false;判断栈是否为空
else return true;

1.4 取栈顶元素：

stk[tt];

2.单调栈

常见模型：找出每个数左边离它最近的比他大或者小的数

代码模板：

int tt = 0;
for (int i = 0; i < n; i++)
{
while (tt && check(stk[tt], i)) tt–;
if(tt)
//具体问题的逻辑
stk[++tt] = i;
}

举例：
输入几个整数，输出每个整数左边第一个比它小的整数，若不存在，则输出-1；

输入：5

3 4 2 7 5

输出：-1 3 -1 2 2

1.采用数组模拟的栈进行解决

代码实例：

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int stk[N];
int n,tt;
int main()
{
	ios;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		int x; cin>>x;
		while(tt&&stk[tt]>=x) tt--;//只要栈不空并且栈顶元素的值大于等于x的话，栈顶指针--
		if(tt) cout<<stk[tt]<<' ';//如果栈不空的话，说明找到了比x小的数，输出即可
		else cout<<"-1"<<' ';//当栈为空的时候也没有找到，说明不存在比x小的数，输出-1
		stk[++tt]=x;//每次将x入栈
	}
	return 0;
}

2.采用STL库中实现好的栈进行解决
代码实例：

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int n;
stack<int> s;
int main()
{
	ios;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		int x; cin>>x;
		while(s.size()&&s.top()>=x) s.pop();//只要栈不空并且栈顶元素的值大于等于x的话，栈顶指针--
		if(s.size()) cout<<s.top()<<' ';//如果栈不空的话，说明找到了比x小的数，输出即可
		else cout<<"-1"<<' ';//当栈为空的时候也没有找到，说明不存在比x小的数，输出-1
		s.push(x);//每次将x入栈
	}
	return 0;
}

3.常规做法：（暴力枚举）

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int n,j;
int a[N];
int main()
{
	ios;
	cin>>n;
	for(int i=0;i<n;i++) cin>>a[i];
	for(int i=0;i<n;i++)
	{
		int flag=0;
		for(j=i-1;j>=0;j--)
		{
			if(a[j]<a[i])
			{
				flag=1;
				break;
			}
		}
		if(flag) cout<<a[j]<<' ';
		else cout<<-1<<' ';
	}
	return 0;
}

三 队列

用数组模拟队列基本思想：
用数组q来表示队列，hh表示队头指针，tt表示队尾指针（习惯上初始化为-1，这点与栈不同，要注意区分）

基本操作：

1.普通队列

1.1 在队尾插入元素：

q[++tt] = x;//在队尾插入元素

1.2 在队头弹出元素：

hh++；//弹出队头元素

1.3 判断队列是否为空：

if (hh <= tt) return false;//判断队列是否为空
eles return true;

1.4 取队头元素：

q[hh];//取出队头元素

1.5 取队尾元素：

q[tt];//取队尾元素

2.单调队列：

常见模型：

找出滑动窗口中的最大值和最小值

模板：

int hh = 0, tt = -1;
for (int i = 0; i < n; i++)
{
	while (hh <= tt && check_out(q[hh])) hh++;//判断队头是否划出窗口
	while (hh <=tt && check(q[tt], i)) tt--;
	q[++tt] = i;
	//具体问题的逻辑
}

例题：

滑动窗口：每次在窗口中只能看到k个数字，并且每次滑动窗口向右移动一个位置，求出每一个窗口里的最大值和最小值。

输入：8 3

1 3 -1 -3 5 3 6 7

输出：

-1 -3 -3 -3 3 3

3 3 5 5 6 7

解题思路：
用单调队列存储元素下标，遍历整个序列，枚举所有终点，只要队列不空并且当起点下标大于队头元素下标，说明队头已经划出了窗口，则出队，hh++，只要队列不空并且队尾元素的值大于等于当前元素的值，tt–,要注意一下，只有队列中元素个数大于等于k的时候，才输出队头元素的值，即为最小值。求最大值的话只需要将当队尾元素的值小于等于当前元素的值的时候，tt–。

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int n,k;
int a[N];
int q[N];
int hh=0,tt=-1;
int main()
{
	ios;
	cin>>n>>k;
	for(int i=0;i<n;i++) cin>>a[i];
	for(int i=0;i<n;i++)
	{
		while(hh<=tt&&i-k+1>q[hh]) hh++;
		while(hh<=tt&&a[q[tt]]>=a[i]) tt--;
		q[++tt]=i;
		if(i-k+1>=0) cout<<a[q[hh]]<<' ';
	}
	cout<<endl;
	hh=0,tt=-1;
		for(int i=0;i<n;i++)
		{
			while(hh<=tt&&i-k+1>q[hh]) hh++;
			while(hh<=tt&&a[q[tt]]<=a[i]) tt--;
			q[++tt]=i;
			if(i-k+1>=0) cout<<a[q[hh]]<<' ';
		}
		return 0;
}

四 KMP算法（模式匹配算法）

算法思路：用指针i和j分解指向主串和模式串中正待比较的字符位置，i从一开始，j从0开始，当产生失配的时候，i不变，j退回到ne[j]的地方重新进行比较，当j退为0的时候，i和j同时加一；

s[]是主串，m是主串长度，t[]是模板串，n是模板串长度

1. 求next数组

//求next数组
for (int i = 2, j = 0; i <= n; i++)
{
while (j && t[i] != t[j + 1]) j = ne[j];
if(t[i]==t[j+1]) j++:
ne[i] = j;
}

2. 匹配过程

for (int i = 1, j = 0; i <= m; i++)
{
while (j && s[i] != t[j + 1]) j = ne[j];
if (s[i] == t[j + 1]) j++;
if (j == n)
{
j = ne[j];
//匹配成功之后的逻辑
}
}

代码实例：

输出模板串在主串中所有出现的位置

输入：3

aba

5

ababa

输出：0 2

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
char s[N], t[N];
int n, m;
int ne[N];
int main()
{
	ios;
	cin >> n >> t + 1 >> m >> s + 1;//匹配时从下标为1开始匹配，所以读入字符串时从下标为1开始
	for (int i = 2, j = 0; i <= n; i++)
	{
		while (j && t[i] != t[j + 1]) j = ne[j];
		if (t[i] == t[j + 1]) j++;
		ne[i] = j;
	}
	for (int i = 1, j = 0; i <= m; i++)
	{
		while (j && s[i] != t[j + 1]) j = ne[j];
		if (s[i] == t[j + 1]) j++;;
		if (j == n)
		{
			cout << i - n << ' ';
			j = ne[j];
		}
	}
	return 0;
}

​

zs8787
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习笔记- 基于链表的KMP算法
LucasGao14的博客
02-14 1005
基于链表的KMP算法 数据结构学习笔记 模式串 pattern 需要匹配的串称为模式串 需求分析 查找首个与pattern匹配的子表 DoubleNode<T> search(DoublyList<T> pattern) 数据结构的声明 public class DoublyList<T> extends Object{ private Double...
数组链表算法思路三（KMP算法）
HanJuly9569的博客
05-12 292
思路 在字符串的比较中，不能双重循环的去做，时间复杂度是n^2，需要进行简化 例子：（KMP） 有s,m两个字符串，s= abcdabcdx,m=abcdx,请找出m子串在s中起始位置。 按照我们的常规思路我们会将m和s的每一个字符比较（有两个游标i,j，分别指向两个字符串的开头）： 1.如果m的第一个字符与s中的某一个位置的字符相等（比如：第一个），然后继续移动i,和j, i++ ,j++ 2.如果m中的某一个字符与s中不相等，就需要将两个指针重新定位 仔细看上图的几步：当第一步匹配失败后，其实第二步
单链表操作之链表插入--C语言实现
Kmp算法C语言简单实现
10-15 691
今天回顾了一下单链表，写了一个简单的单链表插入程序，使用的是头插法，以前学习的不太好，现在来看又有了收获，说明自己的基础还不行。现在贴出代码，希望大家多看看代码里面的注释，提出不同的看法或者纠正在下的错误。 //链表结点 typedef struct Node { int data; struct Node *next; }*PtrToNode; void InsrtNode(PtrToN...
基础-链表队列和KMP（数组模拟）
weixin_61600873的博客
09-19 218
单调栈、单调队列与双指针算法的思路类似，即先通过暴力算法写出来，然后观察规律（是不有单调性），双指针算法通过一个while限定减少循环的次数；单调栈、单调队列则直接在接口出拿最大最小值，两者适用的场合都非常单一，即单调栈解决距离某个数最近的比他大/小的问题，单调队列求解滑动窗口的最值；
数组-链表(单链表，双链表)-栈-队列-kmp
weixin_42336835的博客
03-16 1300
数组模拟链表： 更加方便，更加快捷，不需要新建数据结构。大部分都是这样写。 单链表 链表： 两个数组， 有头指针head e【】//存储当前节点的值 next【】//存储当前节点指向的下一个位置，也是指针 idx //表示当前节点的存储空间 //一个节点存储两个东西： //head头指针存储下一个位置 ps:可以用O（1）的时间查到下一个点的位置，找不到前一个的位置。 输出时注意，不能按照顺序输出，要按照定义进行输出，未节点最后指向的是空集，也就是-1； for(int i = head; i
KMP算法和next数组的性质
Sti1lWater的博客
10-30 181
KMP 整体思路：「天勤公开课」KMP算法易懂版_哔哩哔哩_bilibili next数组：KMP算法之求next数组代码讲解_哔哩哔哩_bilibili
数据结构中链表，栈和队列，串的算法实现代码
08-05
链表、栈、队列和串（字符串）是数据结构中的基本概念，这里我们将深入探讨它们以及相关的算法实现。 首先，链表是一种非连续的数据存储结构，其中每个元素称为节点，包含数据和指向下一个节点的引用。链表分为单向...
利用C++实现以下经典数据结构算法：线性表、栈、队列、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法）、树.zip
12-28
线性表（顺序表、链表、静态链表、三元组）、栈（双栈、共享栈）、队列（任务调度、循环队列、双向队列、链队列）、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法、KMP优化算法）、树（先序遍历、线索...
所有基础数据结构和算法的纯C语言实现，如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查.zip
02-28
本资源提供的是所有基础数据结构和算法的纯C语言实现，涵盖了广泛的主题，包括排序、链表、栈、队列、树、图算法、字符串匹配、回溯法以及并查集等。以下是对这些概念的详细说明： 1. **排序算法**：排序是将一组...
纯C语言实现如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等
06-16
字符串匹配算法，如KMP、Boyer-Moore和Rabin-Karp，用于在文本中查找子串。这些算法提高了搜索效率，对于文本处理和搜索引擎至关重要。 回溯法是一种试探性的解决问题方法，常用于解决约束满足问题和组合优化问题，...
特殊线性表-栈、队列和串
01-31
7. **课程内容**："数据结构第三章课件，特殊线性表--栈、队列和串"可能会涵盖这些概念的定义、操作、特性、实现方式、以及相关的算法和应用。电子教案可能包括PPT演示文稿、讲解笔记、习题解答等内容，帮助学生深入...
单链表概念及代码
KMP查找法
02-03 307
一、概念 单链表是一种链式存储的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 二、代码 1、头文件 #include<stdio.h> #include<assert.h> #include<s...
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1115
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 212
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 246
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
排序思想-快排
m0_58257626的博客
07-17 324
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 248
完全二叉树的节点个数-递归
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 279
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 289
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值