基本数据结构的模拟

目录

• 基本数据结构
  • 模拟栈
    • 1. 普通栈
    • *2. 单调栈
  • 模拟队列
    • 1.普通队列
    • 2.*循环队列
    • 3.*单调队列
  • 模拟链表
    • 1.单链表
    • 2.双链表
  • 模拟堆
    • 手写堆（支持修改任意一个操作）

基本数据结构

除了用STL调用容器来实现基本的数据结构，

在一些特殊情况下（如：对时间、空间作限制；题目的要求比较特别的时候），

我们可以自己模拟数据结构。

以下给出几种常用数据结构的模拟，以及它们的特殊题型模板。

模拟栈

1. 普通栈

// tt表示栈顶
int stk[N], tt = 0;

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

// 从栈顶弹出一个数
tt -- ;

// 栈顶的值
stk[tt];

// 判断栈是否为空
if (tt > 0)

*2. 单调栈

一种题型：

要求对序列之中的数，找它最近的某个符合性质的数

常见模型：找出每个数左边/右边离它最近的比它大/小的数
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
    while (tt && check(stk[tt], i)) tt -- ;
    stk[ ++ tt] = i;
}

模拟队列

1.普通队列

// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;

// 向队尾插入一个数
q[ ++ tt] = x;

// 从队头弹出一个数
hh ++ ;

// 队头的值
q[hh];

// 判断队列是否为空
if (hh <= tt)

2.*循环队列

// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;

// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;

// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;

// 队头的值
q[hh];

// 判断队列是否为空
if (hh != tt)

3.*单调队列

一种题型：滑动窗口

常见模型：找出滑动窗口中的最大值/最小值
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个插入点来进行操作（针对所有的插入操作，即使删除），因此我们考虑用数组来保存，其下标就能保存每次k的值。

1.单链表

int head, e[N], ne[N], idx;

//* 初始化
void init()
{
  head = -1;
  idx = 0;
}

//* 将 x 插到头节点
void add_to_head(int x)
{
  // 将值赋给新节点
  e[idx] = x;
  // 将新节点指向原来的头节点
  ne[idx] = head; 
  // 将头节点更新为新节点
  head = idx;
  // idx更新备用
  idx++;     
}

//*将 x 这个点 插入到 第 k 个插入 的点后面
void add(int k, int x)
{
  // 将值赋给新结点
  e[idx] = x;
  // 将新结点指向插入结点的下一个位置
  ne[idx] = ne[k];
  // 将新结点左边的结点指向新结点
  ne[k] = idx;
  // idx更新备用
  idx++;
}
//* 将第k个插入的点 后面的一个点删除
void remove(int k)
{
  ne[k] = ne[ne[k]];
}

2.双链表

int l[N],r[N],index,value[N];
void ini()
{
    //初始化两个左右节点
    //下标为0结点指向右边下标1结点，下标为1结点指向左边下标0结点
    r[0]=1;
    l[1]=0;
    //更新节点索引
    index=2;
}

void insert(int k,int x)//在第k个节点后插入x
{
    //将值赋给新节点
    value[index]=x;
    //将新节点分别指向插入位置的右节点和左节点
    r[index]=r[k], l[index]=k;
    //将左右两边结点指向新结点
    l[r[k]]=index, r[k]=index;
    //更新节点索引
    index++;
}
void remove(int k)
{
    //删除第k个节点,第k-1的右指针指向原先第k个节点的右指针指向的节点
    r[l[k]]=r[k];
    //删除第k个节点,原先第k个节点的右指针指向的节点的左指针指向原先第k个节点的左指针指向
    //的节点
    l[r[k]]=l[k];
}

模拟堆

手写堆（支持修改任意一个操作）

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
int h[N], ph[N], hp[N], size;

// 交换两个点，及其映射关系
void heap_swap(int a, int b)
{
    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a], hp[b]);
    swap(h[a], h[b]);
}

void down(int u)
{
    int t = u;
    if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    if (u != t)
    {
        heap_swap(u, t);
        down(t);
    }
}

void up(int u)
{
    while (u / 2 && h[u] < h[u / 2])
    {
        heap_swap(u, u / 2);
        u >>= 1;
    }
}

// O(n)建堆
for (int i = n / 2; i; i -- ) down(i);