数组模拟实现数据结构

数组模拟链表实现

① 单链表: 邻接表 (存储图和树)

② 双链表: 优化某些问题

单链表

int e[N] 存储 val , int ne[N] 存储 next

//单链表模板

int head,e[N],ne[N],idx;
//head表示头节点的下标,e[i]表示节点i的值,ne[i]表示节点i的指针是多少,idx存储当前已经用到了哪个点

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

void add_to_head (int x) //将x插到头节点
{
    e[idx]=x;
    ne[idx]=head;
    head=idx++;
}

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

void remove (int k) //删除下标是k的点的下一个点
{
    ne[k]=ne[ne[k]];
}

双链表

每个节点有两个指针, 指向上一个和下一个节点

int l[N],r[N];
0: head	  //下标为0的点作为头节点
1: tail   //下标为1的点作为尾节点

//双链表模板

int e[N],l[N],r[N],idx;
//e[]表示节点的值,l[]表示节点的左指针,r[]表示节点的右指针,idx表示当前用到了哪个节点

void init() //初始化
{
    r[0]=1,l[1]=0;	//0是左端点,1是右端点
    idx=2;
}

void add_to_right (int a,int x) //在节点a的右边插入一个数x
{
    e[idx]=x;
    l[idx]=a,r[idx]=r[a];
    l[[r[a]]]=idx,r[a]=idx;
    idx++;
}

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

数组模拟栈实现

//数组模拟栈模板

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

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

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

stk[tt];	//栈顶的值

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

单调栈

常见模型: 找出每个数左边离它最近的比它大/ 小的数

int stk[N],tt=0;
for(int i=1;i<=n;i++)
{
    while(tt&&check(stk[tt],a[i]))tt--;
    stk[++tt]=a[i];
}

数组模拟队列实现

//数组模拟队列模板

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

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

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

q[hh];	//队头的值

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

单调队列

常用模型: 找出滑动窗口中的最大值/ 最小值

int q[N],hh=0,tt=-1;
for(int i=1;i<=n;i++)
{
    while(hh<=tt&&check_out(q[hh]))hh++;  //判断队头是否滑出窗口
    while(hh<=tt&&check(q[tt],a[i]))t--;
    q[++tt]=a[i];
}

数组模拟堆实现

堆是一棵完全二叉树

对于小根堆: 每一个点都小于等于左右两个子节点

存储方式(完全二叉树的存储方式): 用一维数组存储

堆数组下标从1开始(1为根节点)

x的左儿子是 2x , x的右儿子是 2x+1

如何手写一个堆?

1. 插入一个数 heap[++size] = x , up(size)
2. 求集合中的最小值 heap[1]
3. 删除最小值 heap[1] = heap[size] , size-- , down(1)
4. 删除任意一个元素 heap[k] = heap[size] , size-- , down(k) , up(k)
5. 删除任意一个元素 heap[k] = x , down(k) , up(k)

//堆数组操作模板

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

//down操作
void down (int u)
{
    int t=u;		//t最终存储最小值下标
    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)
    {
        swap(h[u],h[t]);
        down(t);
    }
}

//up操作
void up (int u)
{
    while(u/2&&h[u/2]>h[u])
    {
        swap(h[u/2],h[u]);
        u/=2;
    }
}

//维护映射关系的堆模板

int h[N],ph[N],hp[N],size;
//h[]存储堆中的值
//ph[k]存储第k个插入的点在堆中的位置
//hp[k]存储堆中下标是k的点是第几个插入的

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