算法--数据结构基础

数据结构

单链表

用数组模拟（静态链表）效率比定义Node类（动态链表）效率高些

使用数组模拟单链表，e [ ] 数组中存值，ne [ ] 数组中存下个元素位置下标，定义头指针head，初始时指向-1，定义idx表示用到了哪个下标

栈

定义数组 stk[ ] tt指向栈顶初始为-1，插入时tt++，弹出时tt- - ，查看栈是否为空，只用看tt是否大于0即可，栈顶元素即stk[tt]

表达式求值

前缀表达式

运算符位于操作数之前，求值过程：

1. 从右向左读取表达式
2. 将遇到的数字压入栈中，读到运算符是弹出栈顶操作数并进行计算

中缀表达式

常见的数学表达式，运算符位于操作数之间

后缀表达式

也被称为逆波兰表达式，运算符位于操作数之后，后缀表达式不需要括号，不存在优先级问题

求值过程与前缀表达式相同，不过是从左向右读取

后缀表达式在计算机科学中有广泛的应用，特别是在编译器设计、计算器实现和栈的应用中。它可以方便地用于计算复杂的算术表达式，并且可以通过简单的迭代和栈操作来实现。可以将中缀表达式转换为后缀表达式，使其更适合计算机程序中的求值过程。

队列

定义数组q[ ] ，hh为头下标初始为0，tt为尾，初始为-1，尾部添加元素，添加时，q[++tt] = x，头部删除，删除hh++即可

查看队列是否为空，只用看hh<=tt，如果是，不为空，不是就为空，查看队头元素只用看q[hh]

单调栈

情景：给一个序列，找到一个数左边（右边）满足xx条件，且离他最近的一个数

例如：给一个序列，找到每个数左边离他最近的且比他小的数，不存在的话返回-1

• 暴力：双层for循环，一层逐个遍历，一层从遍历的位置的前一个开始倒着遍历，直到找到比他小的

• 单调栈思路：
  在读数据的同时维护一个栈，如果栈不为空，就比较栈顶元素和当前要加入的元素的大小，如果大于或等于当前元素，就将栈顶元素弹出，直到新的栈顶元素比当前元素小，就停止循环弹出栈顶元素，如果此时栈不为空，那么栈顶元素即答案，栈为空答案为-1，最后将当前元素入栈

  这样维护的栈一定是单调的

单调队列

情景：求滑动窗口中的最大值和最小值

例如：给定一串数字，有个大小为k的滑动窗口，从左边移到右边，求出每个位置的滑动窗口的最大值和最小值

• 普通队列：维护一个队列，当窗口向右走一步，就将新的元素添加进队尾并删掉队头，暴力求窗口中的最大和最小值即可
• 单调队列：
  队列中存元素索引，遍历整个数组，先判断队头元素是否已经被移除窗口，如果是，将队头元素从队列中移除，
  获取窗口最小值：判断队尾元素与当前元素大小，若队尾元素大于当前元素，删除队尾元素，直到队尾元素小于当前元素，再将当前元素添加到队尾，然后判断当前遍历的元素是否达到窗口大小，达到就输出队头（窗口最小值）即可
  获取窗口最大值：和上面一样，只是判断队尾元素与当前元素大小相反

队尾添加元素，添加的过程中保证目前的结果一定在队头，队头取结果即可

KMP

习惯下标从1开始

对模板串处理：对每个点预处理以某点为终点的后缀和前缀相等，相等的长度最大为多少

next[ i ] = j 以 i 为终点的后缀，和从一开始的前缀相等，而且后缀长度最长 ，记录的是最长公共前后缀长度

next[i] = j;
p[1,j] = p[i - j + 1];

Trie

用于高效存储查找字符串

模版：

解释：[0] [1] = 3 表示根节点有个儿子 b ，这个儿子在数组中的下标是3

​ [3] [4] = 7 [3] 表示当前字符的下标，[4] 表示当前字符有个儿子e，下标为7

public class Main{
    final static int N = 100010;
    static int[][]son = new int[N][26]; //这里总共有26个字符
    static int[]cnt = new int[N]; //以某个下标的字符为结尾的字符串个数
    static int idx = 0; //表示下标，自增来生成下标
    
    public static void insert(char[]str) {
        int p = 0;
        for(int i = 0;i < str.length;i++) {
            int u = str[i] - 'a';
            if(son[p][u] == 0) son[p][u] = ++idx;
            p = son[p][u];
        }
        cnt[p]++;
    }
    
    public static int query(char[]str) {
        int p = 0;
        for(int i = 0;i < str.length;i++) {
            int u = str[i] - 'a';
            if(son[p][u] == 0) return 0;
            p = son[p][u];
        }
        return cnt[p];
    }
}

并查集

用来快速处理 近乎O1

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

实现方式：每个集合用一棵树来表示，树根的编号就是整个集合的编号，每个节点存储他的父节点，p[x] 表示x的父节点

a1：如何判断树根 ：p[x] == x

a2：如何求x的集合编号：while(p[x] != x) x = p[x] (一直向上找他的父节点，直到找到了根)

a3：如何合并两集合：把其中一个集合的集合编号等于另一棵树的集合编号

求集合编号时时间复杂度和树高是成正比的，可能会出现树高过高问题，需要优化
**优化：**路径压缩

在从一个节点不断向上找到根节点时，将走过的所有节点直接指向根节点

模版：

public class Main{
    final static int N = 100010;
    static int[]p = new int[N];
    //找x的根节点 + 路径压缩
    static int find(int x) {
        if(x != p[x]) p[x] = find(p[x]);
        return p[x];
    }
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i = 0;i < n;i++) p[i] = i;//初始化
        int m = sc.nextInt();
        for(int i = 0;i < m;i++) {
            String l = sc.next();
            int a = sc.nextInt();
            int b = sc.nextInt();
            if("M".equals(l)) p[find(a)] = find(b);//合并两集合
            else {
                if(find(a) == find(b)) System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }
}

有些题往往还需要维护别的变量

堆

完全二叉树，最后一层节点从左到右依次排列

用数组存储堆

这里索引从1开始，左儿子为 2x 右儿子为2x + 1 父节点为 x / 2

以最小堆为例，修改根节点元素，需要将新的值下沉，就让根元素和左右孩子比较，与最小的那个交换，一直到没法移了

上浮：和父节点比较，如果小于父节点，和父节点交换位置

插入：在heap[++size] = x，再将这个数不断上浮

删除根节点 ：用堆的最后一个元素覆盖堆的根节点，在将其不断下沉

删除任意一个元素：heap[k] = heap[size] ; size - - ; up(k) || down(k);

修改任意一个元素：heap[k] = x; down(k) || up(k);

将数组转化成堆：

• 可以一个一个往堆里add，复杂度为nlogn
• 也可以从n/2 个元素开始倒着到1不断下沉操作

要修改第k个插入的元素，还需要存个映射关系：

• 第k个插入的元素的索引 ph[ ]
• 索引为x的元素是第几个插入的 hp[ ]

交换堆中元素时，也需要考虑到映射关系的改变：

public static void heapSwap(int x,int y) {
    swap(ph,hp[x],hp[y]);
    swap(hp,x,y);
    swap(a,x,y);
}

交换数组中的元素：

public static void swap(int[]q,int a,int b) {
    int t = q[a];
    q[a] = q[b];
    q[b] = t;
}

哈希表

离散化是一种保序的hash方式（只是其中一种）

情景：把0~10^9映射到 0 ~ 10^5 这些数

• 存储结构
  • 开放寻址法
  • 拉链法
• 字符串哈希方式

a1：hash函数一般怎么写

x mod 10^5（取模的这个数尽可能是质数，且离2整次幂尽可能远）

a2：处理冲突

• 开放寻址法
• 拉链法：将发生冲突的直接接在要插入的位置

在算法中，对哈希表一般只有添加和查找两个操作

算法中，对哈希表就算要删除，往往不会真的删，会再开一个数组，对每个位置打一个标记，标记一下被删除

拉链法：

import java.util.Scanner;
import java.util.Arrays;
public class Main{
    final static int N = 100003;
    static int[]h = new int[N];//哈希表的槽
    static int[]e = new int[N];//链表存值
    static int[]ne = new int[N];//链表存下一个元素位置
    static int idx;//链表当前用到的索引
    static int hash(int x) {
        return (x%N+N) % N;//计算hash值，即该存入位置索引，这样写目的是防止负数出现
    }
    //头插
    static void insert(int x) {
         int k = hash(x);
         e[idx] = x;
         ne[idx] = h[k]; //h[k]就是每个链表的头指针
         h[k] = idx++;
    }
    static boolean find(int x) {
        int k = hash(x);
        for(int i = h[k];i != -1;i = ne[i]) {
            if(e[i] == x) return true;
        }
        return false;
    }
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        Arrays.fill(h,-1);//相当于初始化每条链表头结点为-1
        int n = sc.nextInt();
        for(int i = 0;i < n;i++) {
            String l = sc.next();
            int x = sc.nextInt();
            if(l.equals("I")) insert(x);
            else {
                if(find(x)) System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }
}

开放寻址法：

只用一个一维数组，数组长度一般是题目要求的2~3倍（经验值）

添加：

先用hash得到该存入的索引，若该索引已有元素，依次找下一个位置，直到找到空的位置，将元素插入

查找：

用hash得到对应索引，若对应索引元素不是要查找的元素，依次往后找，直到找到空的位置，那么这个元素不存在

删除：

先查找x，然后对x打一个标记，表示他被删除了

0x3f3f3f3f的十进制为1061109567，和INT_MAX一个数量级，即10^9 数量级，而一般场合下的数据都是小于10^9的。
0x3f3f3f3f * 2 = 2122219134，无穷大相加依然不会溢出。

public class Main{
    static final int nem = 0x3f3f3f3f;//定义一个数据范围之外的数，表示当前位置为空
    static final int N = 200003;
    static int[]h = new int[N];
    static int hash(int x) {
        return (x%N+N) % N;
    }
    //核心
    //如果是添加，返回的就是该添加的位置，如果是查找，返回位置要么就是这个元素的位置，要么为空位置
    static int find(int x) {
        int k = hash(x);
        while(h[k] != nem && h[k] != x) {
            k++;
            if(k == N) k = 0;
        }
        return k;
    }
    public static void main(String[]args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        Arrays.fill(h,nem);
        while(n --> 0) {
            String[]rr = br.readLine().split(" ");
            int x = Integer.parseInt(rr[1]);
            int we = find(x);
            if(rr[0].equals("I")) {
                h[we] = x;
            }else {
                if(h[we] == x) System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }
}

字符串哈希

当我们需要快速判断两个字符串是否相等时，可以使用

字符串前缀哈希法：先预处理出字符串每个前缀的hash值

如何求字符串的hash值：

• p进制法：
  对于“ABCD”，使用p进制表示，可以表示成，（A * p^3 + B * p^2 + C * p^1 + D * p^0）mod Q，其中，将A映射成1，B - - > 2，C - - > 3，D - - > 4
  结果可能比较大，故给他模上一个Q，使结果在 0 ~ Q - 1的范围内
  • 不能映射成0，如果A映射成0，那么AA也是0，AAA也是0……，可以将他们映射成对应的ASII值
  • 当p取131或13331，Q取2^64（经验值），在这种情况下，我们可以不考虑冲突

我们可以利用预先求得的hash值，可以根据公式求得所有子串的hash值。

例如：

aabbaabb，要求3 ~ 7（L ~ R）位置的子串和hash值，即bbaab，需要知道hash[2] (aa) 和 hash[7] (aabbaab)，转化为p进制就是 （11）p和（1122112）p，要求bbaab的hash值，就是求（22112）p

可以将（11）p左移成（1100000）p，即左移R - L + 1位（位运算理解），即乘以 p^R - L + 1

要求子串的hash值就可以表示为 hash[R] - hash[L - 1] * p^R - L + 1

示例：

public class Main{
    static final int N = 100010;
    static int[]h = new int[N];//预处理的前缀子串hash值
    static int[]p = new int[N];//p[i]表示p的i次方，将p的i次方预先算出来存到数组中
    static final int P = 131;
    public static void main(String[]args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[]ro1 = br.readLine().split(" ");
        int n = Integer.parseInt(ro1[0]);
        int m = Integer.parseInt(ro1[1]);
        String s = br.readLine();
        p[0] = 1;
        for(int i = 1;i <= n;i++) {
            h[i] = h[i - 1] * P + s.charAt(i - 1);//求前缀子串hash值
            p[i] = p[i - 1] * P;
        }
        while(m --> 0) {
            String[]ro2 = br.readLine().split(" ");
            int l1 = Integer.parseInt(ro2[0]);
            int r1 = Integer.parseInt(ro2[1]);
            int l2 = Integer.parseInt(ro2[2]);
            int r2 = Integer.parseInt(ro2[3]);
            if(h[r1] - h[l1 - 1] * p[r1 - l1 + 1] == h[r2] - h[l2 - 1] * p[r2 - l2 + 1]) System.out.println("Yes");
            else System.out.println("No");
        }
    }
}