链表与邻接表
单链表
链表分为动态链表和静态链表
动态链表如下 :
struct Node{
int val ;
Node *next ;
}
但由于 在 c++ 中,在使用动态链表的情况下,每次创建一个链表就需要调用 new() 函数来创建为其创建一个空间进行存储,但是据我们所知 , c++ 中的new()函数是非常慢的, 当我们处理百万级以上的数据时,使用动态链表就会超时,注意 : 这里所说的情况仅仅只针对于算法题中, 不考虑内存泄露的问题,而在实际的工程项目中,需要考虑内存的问题.
所以在算法题中我们常常用 数组 来模拟链表 , 也就是我们所说的静态链表.
模版 :
H 表示向头结点插入一个结点
I 表示向 k - 1 的结点后面插入一个结点
D 表示删除第 k - 1 个结点后面的结点
// 数组实现单链表 -- 静态链表
#include <iostream>
using namespace std;
const int N = 100010 ;
int head , e[N] , ne[N] , idx ;
// 初始化操作
void init()
{
head = -1 ;
idx = 0 ;
}
// 插入到头结点
void add_to_head(int x)
{
e[idx] = x ;
ne[idx] = head ;
head = idx ++ ;
}
// 将 x 插入到下标为 k 的结点的后面 k - 1
void add(int x, int k)
{
e[idx] = x ;
ne[idx] = ne[k] ;
ne[k] = idx ++ ;
}
// 将下标为 k 的结点的后面的点删掉
void remove(int k)
{
ne[k] = ne[ne[k]] ;
}
int main()
{
int n ; cin >> n ;
init() ;
while(n -- )
{
int k , x;
char op ;
cin >> op ;
if(op == 'H')
{
cin >> x;
add_to_head(x) ;
}
else if(op == 'D')
{
cin >> k;
if(!k) head = ne[head] ;
remove(k - 1) ; // 注意因为下标从零开始 删除第k个数后面的数是删 下标 k-1后面的 数
}
else
{
cin >> k >> x;
add(x , k - 1) ; // 与上面删除操作同理 所以这里传参的时候需要 - 1
}
}
for(int i = head ; i != - 1;i = ne[i]) cout << e[i] << " " ;
return 0;
}
双向链表
每个结点有两个指向 分别指向前面或者后面 这样在进行插入操作的时候就可以对前后进行插入 且时间复杂度为 O( 1 )
模版 :
#include <iostream>
using namespace std;
const int N = 100010 ;
int e[N] , l[N] , r[N] , idx ;
void init()
{
r[0] = 1; l[1] = 0;
idx = 2;
}
// 在第 k 个点的后面插入一个点
void add(int k,int x)
{
e[idx] = x;
r[idx] = r[k] ;
l[idx] = k ;
// 这里要注意修改结点指向的先后顺序 !!!
l[r[k]] = idx ;
r[k] = idx ;
}
// 删除第k个点
void remove(int k)
{
l[r[k]] = l[k] ;
r[l[k]] = r[k];
}
栈与队列
部分代码 :
#include <iostream>
using namespace std;
const int N = 100010 ;
int e[N] , l[N] , r[N] , idx ;
void init()
{
r[0] = 1; l[1] = 0;
idx = 2;
}
// 在第 k 个点的后面插入一个点
void add(int k,int x)
{
e[idx] = x;
r[idx] = r[k] ;
l[idx] = k ;
// 这里要注意修改结点指向的先后顺序 !!!
l[r[k]] = idx ;
r[k] = idx ;
}
// 删除第k个点
void remove(int k)
{
l[r[k]] = l[k] ;
r[l[k]] = r[k];
}
单调栈
应用 : 给定一个序列 . 求这个序列中的每一个数左边离他最近的且比它小的数 , 没有的话则返回 -1
思路 : 这里考虑的方法与双指针算法考虑类似 , 首先暴力求解 , 再挖掘一些性质使得我们可以把 焦点 集中在比较少的状态里面 --> 时间复杂度降低
在这个问题中, 首先我们假设这里有一个数轴 , 它是从 a1 — ai 那么我们要求 离ai 最近且比 ai小的数
从暴力入手 , 可得到如下代码 :
for (int i = 0;i < n;i ++ )
for(int j = i -1;j >= 0;j -- )
if(ai > aj)
{
cout << aj << endl; break ;
}
由此可见其时间复杂度为 O( n )
此时我们可以把 ai 单独拎出来 , 剩下的 a1 – a(i-1)可以看作一个栈 , 通过观察我们可以发现如下性质 , 当ax >= ay 且 x < y 的时候,此时可以把 x 直接从栈中剔除 ,因为我们要找的是离ai最近且比ai小的元素,在这种情况下, ax不满足条件, 所以不需要进行比较 . 也就是说, 我们可以把 a1 ---- ai中所有逆序的点全部删掉 , 得到的就是一个单调栈 , 此时再从栈顶往下遍历这个栈并将其与 ai进行比较 , 如果 其 < ai 就可知其是正确答案 , 反之则知无正确答案 , 输出 - 1.
经过优化后整个算法的时间复杂度为 O( n )
代码如下:
#include <iostream>
using namespace std;
const int N = 100010 ;
int n ; int stk[N] , tt ;
int main()
{
ios::sync_with_stdio(false) ;
cin >> n ;
for(int i = 0;i < n;i ++ )
{
int x ; cin >> x ;
// 当skt[tt] >= x 时, 栈顶元素弹出 直到 skt[tt] < x 或者 栈空
while(tt && stk[tt] >= x) tt -- ;
if(tt) cout << stk[tt] << " " ;
else cout << -1 << " " ;
// 每次输入后 将 x 压入栈 等于在数轴的右边插入 x
stk[++ tt] = x ;
}
return 0 ;
}
单调队列
滑动窗口 :
给定一个数组 , 一个给定长度的滑动的窗口从其左边往右滑动 , 求每次滑动一个单位后 窗口 内的最值
思路 : 和单调栈一样
先想朴素算法如何实现 , 再从中挖掘一些性质 , 使得能把其中无用的元素剔除 , 从会儿实现优化 .
暴力做法 , 两重循环 , 每次向队列入队一个新元素的时候都需要添加循环一遍队列 , 这样复杂度非常大 , 很容易超时 .
优化方法 :
假设我们要求窗口中的最小值 , 例如这组数
3 -1 -3
很明显其最小值是 -3 , 而且-3在最右边 , 也就是队列的队尾,此时前面两个数都比其大 , 说明这两个数就不需要比较, 只要 -3 在 , 它们就永远都不可能输出 , 所以这两个数都可以删除 , 因此 , 我们可以得到 : 只要我们将比新插入的数大的数删去 , 最后就可以得到一个单调递增的队列, 由此可知 此时 队列的最小值即是队头所对应的值.(注: 在这里我们队列存的是数组的下标 , 而不是数组的值 .)
代码如下 :
// 单调队列 滑动窗口应用
// monotone queue
#include <iostream>
using namespace std;
const int N = 1000010 ;
int n , k; int a[N] , q[N] ;
int main()
{
scanf("%d%d",&n,&k) ;
for(int i = 0;i < n;i ++ ) scanf("%d",&a[i]) ;
// 求滑动窗口的最小值
int hh = 0, tt = -1 ;
for(int i = 0;i < n;i ++ )
{
// 判断当前队头是否已经滑出队
if(hh <= tt && i - k + 1 > q[hh]) hh ++ ;
// 如果当前插入的点小于等于队尾的点 则将队尾的点弹出
while(hh <= tt && a[q[tt]] >= a[i]) tt -- ;
// 将当前插入的点 入队
// 这里是从 0 开始存队列中的数 所以前面计算起点的时候需要加一
q[++ tt] = i;
// 输出 这里需要进行一层判断 只有窗口中的数大于等于 k 时才输出
if(i - k + 1 >= 0) printf("%d ",a[q[hh]]) ;
}
cout << endl ;
// 求滑动窗口的最大值
hh = 0, tt = -1 ;
for(int i = 0;i < n;i ++ )
{
// 判断当前队头是否已经滑出队
if(hh <= tt && i - k + 1 > q[hh]) hh ++ ;
// 如果当前插入的点大于等于队尾的点 则将队尾的点弹出
while(hh <= tt && a[q[tt]] <= a[i]) tt -- ;
// 将当前插入的点 入队
q[++ tt] = i;
// 输出 这里需要进行一层判断 只有窗口中的数大于等于 k 时才输出
if(i - k + 1 >= 0) printf("%d ",a[q[hh]]) ;
}
return 0 ;
}