算法(cpp)-数据结构数据结构内容包括:链表，栈，队列，KMP（字符串匹配），字典树，并查集，堆，Hash表，S

链表

单链表

//head存储链表头节点位置
//val[]存储节点的值
//next[]存储节点的next指针
//idx表示当前用到了哪个节点 
int head, val[N], next[N], idx;

// 初始化
void init()
{
    head = -1;
    idx = 0;
}
  // 在链表头插入一个数a
void add_head(int a)
{
    val[idx] = a, next[idx] = head, head = idx ++ ;
}

// 将头结点删除，需要保证头结点存在
void remove_head()
{
    head = next[head];
}
//将第k个点的后一点删除
void remove(int k)
{
    next[k]=next[next[k]];
}
//将x插入k点后
void add(int k,int x)
{
    val[idx]=x;
    next[idx]=next[k];
    next[k]=idx++;
}

双链表

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

// 初始化
void init()
{
    //0是头节点，1是尾节点
    pr[0] = 1, ne[1] = 0;
    idx = 2;
}

// 在节点a的下一个插入一个数x
void insert(int a, int x)
{
    val[idx] = x;
    pr[idx] = a, ne[idx] = ne[a];
    pr[ne[idx]] = idx, ne[a] = idx ++ ;
}
// 删除节点a
void remove(int a)
{
    ne[pr[a]] = ne[a];
    pr[ne[a]] = pr[a];
}

栈

数组模拟栈

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

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

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

// 栈顶的值
stk[tt];

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

}

单调栈

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

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

队列

普通队列

// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;//tt表示超尾，hh表示队头，这样hh==tt时，队内存在元素

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

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

// 队头的值
q[hh];

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

}

循环队列

// 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)
{

}

单调队列

单调队列其实就是维持一个固定大小的单调栈
常见模型：找出滑动窗口中的最大值/最小值

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;
}

KMP（字符串匹配）

next[ i ]=j p[ 1 , j ]=p[i - j + 1, i ]
因为 ne[ i ]=1，表示 p 数组中第一个元素匹配，所以需要一个下标 0，ne[ i ]=0 来表示完全不匹配

循环寻找最长的匹配前缀，如果退了后，后一位没有匹配那就继续退直到 j 退到 0，循环结束后， j 前面的一定是匹配好的，所以只用判断 j+1 位置
后一个成功匹配相同 j++

// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
//求模式串的Next数组：
for (int i = 2, j = 0; i <= m; i ++ )//ne[1]=0,所以直接从2开始
{
    while (j && p[i] != p[j + 1]) j = ne[j];//1
    if (p[i] == p[j + 1]) j ++ ;、//2
    ne[i] = j;
}

// 匹配:
for (int i = 1, j = 0; i <= n; i ++ )
{
    while (j && s[i] != p[j + 1]) j = ne[j];//1
    if (s[i] == p[j + 1]) j ++ ;//2
    if (j == m)//匹配为成功
    {
        j = ne[j];//为了i可以再继续匹配，j向前退一步
        // 匹配成功后的逻辑
    }
}

Trie 树（字典树）

高效的存储和查找字符串集合的数据结构
son 数组中，每个节点表示一条边，整一层代表一个节点
而 Trie 中每个字符是存在边上，所以 son 数组的存储的是当前这条边所指向的节点
Trie 中，cnt（字符出现次数）存储都是在节点位置，也就是最后一条边所指的节点位置做存储

int son[N][26], cnt[N], idx;//下标是0的点即是根节点又是空节点
// 0号点既是根节点，又是空节点
// son[][]存储树中每个节点的子节点
// cnt[]存储以每个节点结尾的单词数量
//idx 表示哪一层的节点可用
// 插入一个字符串
void insert(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx; 
        p = son[p][u];
    }
    cnt[p] ++ ;
}

// 查询字符串出现的次数
int query(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

并查集

将两个集合合并
询问两个元素是否在一个集合中

如何判断树根 if（p[ x ]！=x)
如何求集合编号 while（p[ x ]！=x) x=p[x]

查询时进行路径压缩，一次查询就可以把路上所有的点都进行路径压缩

如何合并两个集合：直接把一个集合的祖宗指向另一个集合的祖宗

按秩合并，就是把矮树合并到高树上，以减小 find 的查询路径
需要注意只有同时应用「路径压缩」和「按秩合并」，并查集操作复杂度才为 O（α（n））

朴素并查集

    int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;//每个节点的指针都指向自己

    // 合并a和b所在的两个集合：
    void union(int a,int b)
    {
        p[find(a)] = find(b);
    }

维护 size 的并查集

   int p[N], cnt[N];
    //p[]存储每个点的祖宗节点, cnt[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        cnt[i] = 1;
    }

    // 合并a和b所在的两个集合+按秩合并：
void unions(int a,int b)
{
    a=find(a);
    b=find(b);
    if(a==b)return;
    if(cnt[a]>=cnt[b])
    {
        cnt[a]+=cnt[b];
        p[b]=a;
    }else unions(b,a);
}

维护到祖宗节点距离的并查集

d[x]里实际存的是 x 在到父节点的距离，由于路径压缩，所以实际上是到根节点的距离，但是这个距离其实还是在非路径压缩下的实际距离，所以才使用了 d[x]+=d[p[x]]，而且路径压缩后，节点的父节点就是根节点，所以除非根节点指向了其他节点，不然不会更新其距离；

 int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离
    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x)
        {
            int u = find(p[x]);
            d[x] += d[p[x]];//这里p[x]还没变，还是指向父节点
            p[x] = u;//路径压缩指向根节点
        }
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[i] = 0;
    }

    // 合并a和b所在的两个集合：
    void union(int a,int b)
    {
        p[find(a)] = find(b);
        d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量
    }

堆

插入一个数 h[++size] ，up（size）；
求集合的最小值 h[1]
删除最小值 h[1]=h[size]，size--，down（1）；
删除任意一个元素 h[k]=h[size]，size--，down（k），up（k）；
修改任意一个元素 h[k]=x，down（k），up（k）；

down（u），在把 u 变大后，使用 down，从上向下的更新最小值，恢复一个小根堆
up（u），在把 u 变小后，使用 up，从下向上的更新最小值，恢复一个大根堆

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
//ph[k]=j,hp[j]=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;  //比较当前节点，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)
    {
        heap_swap(u, t);//当前节点更新
        down(t);//u节点向下走
    }
}

void up(int u) 
{
    while (u / 2 && h[u] < h[u / 2])//每次跟父亲比，直到当前节点的值小于父亲
    {
        heap_swap(u, u / 2);//父节点更新最小值
        u >>= 1;//节点更新为节点的父节点
    }        
}

//初始化  O(n)
//完全二叉树中，最后一层的数量是n/2。最后一层不需要down
for (int i = n / 2; i; i -- ) down(i);

Hash 表

一般哈希

取模的数尽量是质数

（1）拉链法

    //h[N],哈希桶放相同哈希值的值链表，h[k]存的是链表的头节点
    //e[N],ne[N],idx，单链表
    int h[N], e[N], ne[N], idx;
    memset(h,-1,sizeof h);//#include<cstring>
    // 向哈希表中插入一个数
    void insert(int x)
    {
        //x>N,所以要先 mod N 再 +N 再 mod N
        int k = (x % N + N) % N;//求哈希值，得到的一定是个正数
        e[idx] = x;
        ne[idx] = h[k];
        h[k] = idx ++ ;
    }

    // 在哈希表中查询某个数是否存在
    bool find(int x)
    {
        int k = (x % N + N) % N;
        for (int i = h[k]; i != -1; i = ne[i])
            if (e[i] == x)
                return true;

        return false;
    }

（2）开放寻址法

蹲坑法：从第 k 个位开始找，如果找到空位就放入 x

    int h[N];//N是数据范围的两到三倍
    const  int null=0x3f3f3f3f;
       
    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    int find(int x)
    {
        int t = (x % N + N) % N;
        while (h[t] != null && h[t] != x)
        {
            t ++ ;
            if (t == N) t = 0;//回看第一个空位
        }
        return t;
    }
    //初始化
    memset(h,0x3f,sizeof h);

字符串哈希

核心思想：将字符串看成 P 进制数，P 的经验值是 131 或 13331，取这两个值的冲突概率低
小技巧：取模的数用 2^64，这样直接用 unsigned long long 存储，溢出的结果就是取模的结果
不能把字母映射 0，A==0 则 AA==0
人品足够牛逼，不考虑哈希冲突

typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64 
char str[N];//原字符串，从下标1开始存储
// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
}

// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
     //把l-1结束的字符哈希值与r结束的字符的哈希值高位对齐
     //然后相减得到的就是l-1到r这一段的哈希值
    return h[r] - h[l - 1] * p[r - l + 1];
}

STL

vector

vector, 变长数组，倍增的思想
    size()  返回元素个数
    empty()  返回是否为空   
    clear()  清空
    front()/back()
    push_back()/pop_back()
    begin()/end()
    []
    支持比较运算，按字典序

pair

pair<int, int>
   first, 第一个元素
   second, 第二个元素
   支持比较运算，以first为第一关键字，以second为第二关键字（字典序）

string

string，字符串
    size()/length()  返回字符串长度
    empty()
    clear()
    substr(起始下标，(子串长度))  返回子串
    c_str()  返回字符串所在字符数组的起始地址

queue

queue, 队列
    size()
    empty()
    push()  向队尾插入一个元素
    front()  返回队头元素
    back()  返回队尾元素
    pop()  弹出队头元素
priority_queue
priority_queue, 优先队列，默认是大根堆
    size()
    empty()
    push()  插入一个元素
    top()  返回堆顶元素
    pop()  弹出堆顶元素
    定义成小根堆的方式：priority_queue<int, vector<int>, greater<int>> q;
    定义成大根堆的方式：priority_queue<int, vector<int>, less<int>> q;
stack
stack, 栈
    size()
    empty()
    push()  向栈顶插入一个元素
    top()  返回栈顶元素
    pop()  弹出栈顶元素

deque

deque, 双端队列
    size()
    empty()
    clear()
    front()/back()
    push_back()/pop_back()
    push_front()/pop_front()
    begin()/end()
    []

hash

set, map, multiset, multimap, 基于平衡二叉树（红黑树），动态维护有序序列
    size()
    empty()
    clear()
    begin()/end()
    ++, -- 返回前驱和后继，时间复杂度 O(logn)

    set/multiset//set不支持重复元素，multiset支持重复元素
        insert()  插入一个数
        find()  查找一个数
        count()  返回某一个数的个数
        erase()
            (1) 输入是一个数x，删除所有x   O(k + logn)
            (2) 输入一个迭代器，删除这个迭代器
        lower_bound()/upper_bound()
            lower_bound(x)  返回大于等于x的最小的数的迭代器
            upper_bound(x)  返回大于x的最小的数的迭代器
    map/multimap
        insert()  插入的数是一个pair
        erase()  输入的参数是pair或者迭代器
        find()
        []  注意multimap不支持此操作。 时间复杂度是 O(logn)
        lower_bound()/upper_bound()
        
    unordered_set, unordered_map, unordered_multiset, unordered_multimap
    哈希表和上面类似，增删改查的时间复杂度是 O(1)
    不支持 lower_bound()/upper_bound()， 迭代器的++，--

bitset

bitset, 圧位
    bitset<10000> s;
    ~, &, |, ^
    >>, <<
    ==, !=
    []

    count()  返回有多少个1

    any()  判断是否至少有一个1
    none()  判断是否全为0

    set()  把所有位置成1
    set(k, v)  将第k位变成v
    reset()  把所有位变成0
    flip()  等价于~
    flip(k) 把第k位取反

树状数组

O(long n)
1. 给某个位的数加上一个数（单点修改）
2. 求某一个前缀和（区间查询）第 0 层：C[1]=A[1]（树状数组的奇数位和原数组的奇数位相等）第 1 层：C[2]=A[2]+C[1]=A[1]+A[2] 第 2 层：C[4]=A[4]+C[2]+C[3]=A[4]+A[3]+A[2]+A[1] 以此类推
C[x]中 x 的②进制有 k 个 0，则在第 k 层
C[x]={x-2^k,x},lowbit(x)=2^k;C[x]左开右闭

int lowbit(int x)return x&-x;

//a
void add(int x,int v)
{
    for(int i=x;i<=n;i+=lowbit(i))c[i]+=v;
}
//b前缀和
int query(int x)
{
    int cnt=0;
    for(int i=x;i;i-=lowbit(i))cnt+=c[i];
    return cnt;
}

线段树

完全二叉树结构

1. 单点修改
2. 区间查询 O（logn）
typedef long long LL;
struct Node{
     int l,r;
     LL sum,add;
 }tree[4*N];
 

 int w[N];//权值
 

//用子节点信息更新当前节点信息
void pushup(int u)
{
   tree[u].sum=tree[u<<1].sum+tree[u<<1|1].sum; 
}


//在一段区间初始化线段树
void build(int u,int l,int r)
{
    if(r==l)tree[u]={l,r,w[r],0};
    else
    {
        tree[u]={l,r};
        int mid=l+r>>1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}
//单点修改
void modify(int u,int x,int d)
{
     if(tree[u].l==x&&tree[u].r==x) tree[u].sum+=d;
     else
     {
         int mid=tree[u].r+tree[u].l>>1;
         if(mid>=x)modify(u>>1,x,d);
         else modify(u>>1|1,x,d);
         pushup(u);
    }
}

//查询
LL query(int u,int l,int r)
{
   if(tree[u].l>=l&&tree[u].r<=r)return tree[u].sum;
   
   int mid=tree[u].r+tree[u].l>>1;
   LL ans=0;
   if(l<=mid)ans+=query(u<<1,l,r);
   if(r>mid)ans+=query(u<<1|1,l,r);
   return ans;
}
3. 区间修改
typedef long long LL;
struct Node{
     int l,r;
     LL sum,add;
 }tree[4*N];
 
 int w[N];//权值
 
//用子节点信息更新当前节点信息
void pushup(int u)
{
   tree[u].sum=tree[u<<1].sum+tree[u<<1|1].sum; 
}

//在一段区间初始化线段树
void build(int u,int l,int r)
{
    if(r==l)tree[u]={l,r,w[r],0};
    else
    {
        tree[u]={l,r};
        int mid=l+r>>1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}

//将当前区间的修改更新到下一层
void pushdown(int u)
{
    auto &righ=tree[u<<1|1],&left=tree[u<<1],&root=tree[u];
    if(root.add)
    {
        righ.add+=root.add,left.add+=root.add;
        righ.sum+=(LL)(righ.r-righ.l+1)*root.add;
        left.sum+=(LL)(left.r-left.l+1)*root.add;
        root.add=0;
    }
}

//区间修改
void modify(int u,int l,int r,int d)
{
    if(tree[u].l>=l&&tree[u].r<=r)
    {
        tree[u].add+=d;
        tree[u].sum+=(LL)(tree[u].r-tree[u].l+1)*d;
    }
    else
    {
        pushdown(u);
        
        int mid=tree[u].l+tree[u].r>>1;
        if(l<=mid)modify(u<<1,l,r,d);
        if(r>mid)modify(u<<1|1,l,r,d);
        
        pushup(u);
    }
}

//查询
LL query(int u,int l,int r)
{
   if(tree[u].l>=l&&tree[u].r<=r)return tree[u].sum;
   
   pushdown(u);
   int mid=tree[u].r+tree[u].l>>1;
   LL ans=0;
   if(l<=mid)ans+=query(u<<1,l,r);
   if(r>mid)ans+=query(u<<1|1,l,r);
   return ans;
}

算法(cpp)-数据结构

链表

单链表

双链表

栈

数组模拟栈

单调栈

队列

普通队列

循环队列

单调队列

KMP（字符串匹配 ）

Trie 树（字典树）

并查集

朴素并查集

维护 size 的并查集

维护到祖宗节点距离的并查集

堆

Hash 表

一般哈希

（1） 拉链法

（2） 开放寻址法

字符串哈希

STL

vector

pair

string

queue

deque

hash

bitset

树状数组

线段树

KMP（字符串匹配）

（1）拉链法

（2）开放寻址法