Home-LxuMzn

表达式求值与二叉树遍历教程

Tue, 13 Oct 2026 00:00:00 GMT

本文从零讲解中缀、前缀、后缀三种表达式，以及它们与二叉树三种遍历的对应关系，并给出双栈法、调度场算法、后缀/前缀求值等经典算法。全文用一个例子贯穿：

中缀：3 + 4 * 2 / (1 - 5)^2
后缀：3 4 2 * 1 5 - 2 ^ / +
前缀：+ 3 / * 4 2 ^ - 1 5 2

最终结果都是 3.5。

1. 三种表达式是什么

1.1 中缀表达式

人最熟悉的写法，运算符在两个操作数中间：

3 + 4 * 2

特点：有优先级、有括号，计算机直接求值麻烦。

1.2 后缀表达式（逆波兰式 RPN）

运算符在操作数后面：

3 4 2 * +

特点：没有括号，运算顺序唯一，计算机最容易求值。

1.3 前缀表达式（波兰式 PN）

运算符在操作数前面：

+ 3 * 4 2

特点：同样没有括号，求值时从右往左扫描即可。

2. 表达式树：三种表达式的统一来源

任何中缀表达式都可以画成一棵二叉树：

叶子节点：数字
内部节点：运算符
左子树、右子树：参与运算的子表达式

以 3 + 4 * 2 / (1 - 5)^2 为例，表达式树为：

2.1 三种遍历对应三种表达式

遍历方式	顺序	得到的表达式	例子
前序遍历	根 → 左 → 右	前缀表达式 PN	`+ 3 / * 4 2 ^ - 1 5 2`
中序遍历	左 → 根 → 右	中缀表达式（需补括号）	`3 + 4 * 2 / (1 - 5)^2`
后序遍历	左 → 右 → 根	后缀表达式 RPN	`3 4 2 * 1 5 - 2 ^ / +`

一句话总结：同一棵表达式树，三种遍历顺序，得到三种表达式。

3. 中缀表达式求值：双栈法

双栈法直接扫描中缀表达式，一边读一边算。

3.1 规则

一个数字栈 num，一个运算符栈 op
从左到右扫描
遇到数字 → 压 num
遇到左括号 → 压 op
遇到右括号 → 弹 op 直到左括号，每弹一个运算符就算一次
遇到运算符 → 比较优先级：
- 栈顶优先级高于当前，或 同级且当前不是 ^，就弹栈顶计算
- 否则当前运算符入 op
扫描完，把 op 里剩下的全部弹出算完

3.2 模拟 `3 + 4 * 2 / (1 - 5)^2`

步骤	读到	动作	num 栈	op 栈
1	`3`	数字入栈	`[3]`	`[]`
2	`+`	入栈	`[3]`	`[+]`
3	`4`	数字入栈	`[3,4]`	`[+]`
4	`*`	`+` 优先级低，不弹；`*` 入栈	`[3,4]`	`[+,*]`
5	`2`	数字入栈	`[3,4,2]`	`[+,*]`
6	`/`	弹 `` 算 `42=8`；`+` 低不弹；`/` 入栈	`[3,8]`	`[+,/]`
7	`(`	入栈	`[3,8]`	`[+,/,(]`
8	`1`	数字入栈	`[3,8,1]`	`[+,/,(]`
9	`-`	栈顶是 `(`，不弹；`-` 入栈	`[3,8,1]`	`[+,/,(,-]`
10	`5`	数字入栈	`[3,8,1,5]`	`[+,/,(,-]`
11	`)`	弹 `-` 算 `1-5=-4`；遇 `(` 弹掉	`[3,8,-4]`	`[+,/]`
12	`^`	`/` 优先级低，不弹；`^` 入栈	`[3,8,-4]`	`[+,/,^]`
13	`2`	数字入栈	`[3,8,-4,2]`	`[+,/,^]`
14	结束	弹 `^` 算 `(-4)^2=16`	`[3,8,16]`	`[+,/]`
15	结束	弹 `/` 算 `8/16=0.5`	`[3,0.5]`	`[+]`
16	结束	弹 `+` 算 `3+0.5=3.5`	`[3.5]`	`[]`

结果 3.5。

3.3 双栈法与后序遍历的关系

双栈法每次弹栈计算，相当于在表达式树中合并一棵小子树：

num 栈存的是已经算完的子树结果
op 栈存的是还没轮到算的子树根
弹出一个运算符，就表示它的左右子树都已完成，可以访问这个根

所以：

双栈法 = 一边隐式建表达式树，一边做后序遍历求值。

4. 中缀转后缀：调度场算法

调度场算法由 Dijkstra 提出，专门用来把中缀转成后缀。

4.1 规则

准备一个输出队列和一个运算符栈：

遇到数字 → 加入输出队列
遇到左括号 → 压入运算符栈
遇到右括号 → 不断弹出运算符栈顶加入输出队列，直到遇到左括号，然后把左括号弹掉
遇到运算符 →
- 只要栈不空，且栈顶不是左括号，且栈顶优先级高于当前，或 同级且当前是左结合，就弹出栈顶加入输出
- 然后把当前运算符压入栈
扫描结束 → 把运算符栈里剩下的全部弹出加入输出

4.2 模拟 `3 + 4 * 2 / (1 - 5)^2`

步骤	读到	动作	输出队列	运算符栈
1	`3`	数字输出	`3`	`[]`
2	`+`	压栈	`3`	`[+]`
3	`4`	数字输出	`3 4`	`[+]`
4	`*`	`+` 低，不弹；压 `*`	`3 4`	`[+,*]`
5	`2`	数字输出	`3 4 2`	`[+,*]`
6	`/`	弹 `*` 输出；`+` 低不弹；压 `/`	`3 4 2 *`	`[+,/]`
7	`(`	压栈	`3 4 2 *`	`[+,/,(]`
8	`1`	数字输出	`3 4 2 * 1`	`[+,/,(]`
9	`-`	栈顶是 `(`，不弹；压 `-`	`3 4 2 * 1`	`[+,/,(,-]`
10	`5`	数字输出	`3 4 2 * 1 5`	`[+,/,(,-]`
11	`)`	弹 `-` 输出；弹掉 `(`	`3 4 2 * 1 5 -`	`[+,/]`
12	`^`	`/` 低，不弹；压 `^`	`3 4 2 * 1 5 -`	`[+,/,^]`
13	`2`	数字输出	`3 4 2 * 1 5 - 2`	`[+,/,^]`
14	结束	弹 `^`、`/`、`+`	`3 4 2 * 1 5 - 2 ^ / +`	`[]`

得到后缀表达式：

3 4 2 * 1 5 - 2 ^ / +

5. 后缀表达式求值

后缀求值只需要一个数字栈。

5.1 规则

从左到右扫描
遇到数字 → 压栈
遇到运算符 → 弹出两个数：
- 先弹出的是 右操作数 b
- 后弹出的是 左操作数 a
- 计算 a op b，结果压回栈
最后栈里只剩一个数，就是结果

5.2 模拟 `3 4 2 * 1 5 - 2 ^ / +`

步骤	读到	动作	栈
1	`3`	压栈	`[3]`
2	`4`	压栈	`[3,4]`
3	`2`	压栈	`[3,4,2]`
4	`*`	弹 `b=2, a=4`，算 `4*2=8`	`[3,8]`
5	`1`	压栈	`[3,8,1]`
6	`5`	压栈	`[3,8,1,5]`
7	`-`	弹 `b=5, a=1`，算 `1-5=-4`	`[3,8,-4]`
8	`2`	压栈	`[3,8,-4,2]`
9	`^`	弹 `b=2, a=-4`，算 `(-4)^2=16`	`[3,8,16]`
10	`/`	弹 `b=16, a=8`，算 `8/16=0.5`	`[3,0.5]`
11	`+`	弹 `b=0.5, a=3`，算 `3+0.5=3.5`	`[3.5]`

结果 3.5。

6. 前缀表达式求值

前缀求值同样一个数字栈，但 从右往左扫描。

6.1 规则

从右到左扫描
遇到数字 → 压栈
遇到运算符 → 弹出两个数：
- 先弹出的是 左操作数 a
- 后弹出的是 右操作数 b
- 计算 a op b，结果压回栈
最后栈里只剩一个数，就是结果

6.2 模拟 `+ 3 / * 4 2 ^ - 1 5 2`

从右往左读的顺序是：

2 5 1 - ^ 2 4 * / 3 +

步骤	读到	动作	栈
1	`2`	压栈	`[2]`
2	`5`	压栈	`[2,5]`
3	`1`	压栈	`[2,5,1]`
4	`-`	弹 `a=1, b=5`，算 `1-5=-4`	`[2,-4]`
5	`^`	弹 `a=-4, b=2`，算 `(-4)^2=16`	`[16]`
6	`2`	压栈	`[16,2]`
7	`4`	压栈	`[16,2,4]`
8	`*`	弹 `a=4, b=2`，算 `4*2=8`	`[16,8]`
9	`/`	弹 `a=8, b=16`，算 `8/16=0.5`	`[0.5]`
10	`3`	压栈	`[0.5,3]`
11	`+`	弹 `a=3, b=0.5`，算 `3+0.5=3.5`	`[3.5]`

结果 3.5。

7. 三种求值方法对比

表达式	扫描方向	栈的数量	弹栈顺序	需要优先级	需要括号
中缀	左 → 右	两个栈（数字 + 运算符）	先右后左	需要	需要
后缀	左 → 右	一个数字栈	先右后左	不需要	不需要
前缀	右 → 左	一个数字栈	先左后右	不需要	不需要

记忆口诀：

中缀双栈比优先，后缀从左先弹右，前缀从右先弹左。

8. 递归下降求值（扩展）

递归下降是编译器前端常用的方法，按文法递归解析。

文法示例：

expr   -> term { (+ | -) term }
term   -> factor { (* | /) factor }
factor -> number | '(' expr ')' | '-' factor

代码框架：

double parseExpr(string& s) {
    double val = parseTerm(s);
    while (pos < s.size() && (s[pos] == '+' || s[pos] == '-')) {
        char op = s[pos++];
        double rhs = parseTerm(s);
        if (op == '+') val += rhs;
        else val -= rhs;
    }
    return val;
}

double parseTerm(string& s) {
    double val = parseFactor(s);
    while (pos < s.size() && (s[pos] == '*' || s[pos] == '/')) {
        char op = s[pos++];
        double rhs = parseFactor(s);
        if (op == '*') val *= rhs;
        else val /= rhs;
    }
    return val;
}

double parseFactor(string& s) {
    if (s[pos] == '(') {
        pos++;
        double val = parseExpr(s);
        pos++;
        return val;
    }
    if (s[pos] == '-') {
        pos++;
        return -parseFactor(s);
    }
    double val = 0;
    while (pos < s.size() && isdigit(s[pos])) {
        val = val * 10 + (s[pos] - '0');
        pos++;
    }
    return val;
}

特点：结构清晰，易扩展，但需要处理左递归。

9. 总结

中缀表达式：人熟悉，计算机麻烦，用双栈法求值。
后缀表达式：一个栈，从左到右，先弹右后弹左。
前缀表达式：一个栈，从右到左，先弹左后弹右。
表达式树：三种遍历对应三种表达式。
- 前序 → 前缀
- 中序 → 中缀
- 后序 → 后缀
双栈法：本质是隐式建树 + 后序遍历求值。
调度场算法：中缀转后缀的标准算法。

10. 推荐练习

408 真题：2014 年中缀转后缀、2025 年后缀求值入栈次数、括号匹配。
LeetCode：150（逆波兰表达式求值）、224（基本计算器）、227（基本计算器 II）、772（基本计算器 III）、1597（构造二叉表达式树）。
考研机试：上海交通大学 KY102、天津大学 2025 机试、浙大复试机试。
参考书：王道《数据结构考研复习指导》第 3 章栈和队列；《算法竞赛入门经典》表达式求值章节；OI-wiki 表达式求值页面。

本文可作为表达式求值专题的教程笔记，配合代码实践和手写模拟，效果更佳。

KMP 算法详解

Tue, 13 Oct 2026 00:00:00 GMT

1. KMP 算法介绍

KMP 算法：全称叫做「Knuth Morris Pratt 算法」，是由它的三位发明者 Donald Knuth、James H. Morris、Vaughan Pratt 的名字来命名的。KMP 算法是他们三人在 1977 年联合发表的。

KMP 算法思想：对于给定文本串 T 与模式串 p，当发现文本串 T 的某个字符与模式串 p 不匹配的时候，可以利用匹配失败后的信息，尽量减少模式串与文本串的匹配次数，避免文本串位置的回退，以达到快速匹配的目的。

1.1 朴素匹配算法的缺陷

在朴素匹配算法的匹配过程中，我们分别用指针 i 和指针 j 指示文本串 T 和模式串 p 中当前正在对比的字符。当发现文本串 T 的某个字符与模式串 p 不匹配的时候，j 回退到开始位置，i 回退到之前匹配开始位置的下一个位置上，然后开启新一轮的匹配，如图所示。

图1-1：朴素匹配算法示意图（失配时 i 回退、j 归 0，从头重新匹配）

这样，在 Brute Force 算法中，如果从文本串 T[i] 开始的这一趟字符串比较失败了，算法会直接开始尝试从 T[i + 1] 开始比较。如果 i 已经比较到了后边位置，则该操作相当于将指针 i 进行了回退操作。

那么有没有哪种算法，可以让 i 不发生回退，一直向右移动呢？

1.2 KMP 算法的改进

如果我们可以通过每一次的失配而得到一些「信息」，并且这些「信息」可以帮助我们跳过那些不可能匹配成功的位置，那么我们就能大大减少模式串与文本串的匹配次数，从而达到快速匹配的目的。

每一次失配所告诉我们的信息是：主串的某一个子串等于模式串的某一个前缀。

这个信息的意思是：如果文本串 T[i: i + m] 与模式串 p 的失配是下标位置 j 上发生的，那么文本串 T 从下标位置 i 开始连续的 j - 1 个字符，一定与模式串 p 的前 j - 1 个字符一模一样。

以刚才图中的例子来说，文本串的子串与模式串 p 的失配是在第 5 个位置发生的，那么：

文本串 T 从下标位置 i 开始连续的 5 个字符，一定与模式串 p 的前 5 个字符一模一样，即 "ABCAB" == "ABCAB"。

而模式串的前 5 个字符中，前 2 位前缀和后 2 位后缀又是相同的，即 "AB" == "AB"。

所以根据上面的信息，我们可以推出：文本串子串的后 2 位后缀和模式串子串的前 2 位是相同的，即这部分是之前已经比较过的，不需要再比较了，可以直接跳过。那么我们就可以将文本串中的失配字符直接对准模式串中对应前缀的下一个字符，继续进行对比。这样 i 就不再需要回退了，可以一直向右移动匹配下去。在这个过程中，我们只需要将模式串 j 进行回退操作即可。

KMP 匹配算法

KMP 算法就是使用了这样的思路，对模式串 p 进行了预处理，计算出一个「部分匹配表」，用一个数组 next 来记录。然后在每次失配发生时，不回退文本串的指针 i，而是根据「部分匹配表」来决定模式串可以向右移动的位数。

2. 前缀与后缀

在正式讲解 next 数组之前，需要先清楚「前缀」与「后缀」的定义。

真前缀（前缀）：从第 0 位开始、到任意位置结束的子串，不包括最后一个字符。
真后缀（后缀）：从任意位置开始、到最后一位结束的子串，不包括第一个字符。
最长公共前后缀：前缀集合 $\cap$ 后缀集合中最长的那一个。

举个例子：对字符串 "aabaa" 来说：

前缀集合：{a, aa, aab, aaba}
后缀集合：{a, aa, baa, abaa}
公共前后缀：{a, aa}，最长公共前后缀是 "aa"，长度为 2。

小练习（建议先自己手算再看答案）：

"ababa" → 最长公共前后缀 "aba"，长度 3。
"aaaaa" → 最长公共前后缀 "aaaa"（真前缀/真后缀），长度 4。
"abcabcab" → 最长公共前后缀 "abcab"，长度 5。

3. next 数组

3.1 概念与人为规定

next[j] 代表模式串 0 到 j - 1 这段子串的最长公共前后缀的长度。也就是说，next[j] 记录的是：模式串第 j 个字符之前的子串中，最长相等的前缀与后缀的长度。

人为规定：next[0] = -1（因为 0 之前没有子串），next[1] = 0（因为只有一个字符时，真前缀集合为空）。

注意：有些题目或教材（如严蔚敏版《数据结构》）里的 next 数组下标从 1 开始，此时人为规定 next[1] = 0。两种写法本质相同：从 1 开始的数组，就是从 0 开始的数组整体加 1（下标同步平移），见 3.2 的对照表。做题前必须看清题目用的是哪一种约定。

3.2 两种 next 数组约定（重点）

「从 0 开始」和「从 1 开始」是两种常见的 next 数组写法，它们的本质含义相同，只是下标起点和数值相差 1。下面讲清楚两者的区别。

项目	约定一：从 0 开始（本讲义采用）	约定二：从 1 开始
数组下标起点	下标从 0 开始	下标从 1 开始
人为规定	`next[0] = -1`, `next[1] = 0`	`next[1] = 0`
`next[j]` 含义	模式串 `[0, j-1]` 的最长相等前后缀长度	模式串前 `j-1` 个字符（`[0, j-2]`）的最长相等前后缀长度 + 1
失配时怎么跳	`i2 = next[i2];` 若 `i2 == 0`，则换主串开头	`j = next[j];` 若 `j == 1`，则换主串开头
与约定一的关系	—	`next1[j] = next0[j-1] + 1 (j >= 2)`

对照关系举例："abaabac" 中，约定一的 next0[5] = 2，约定二的 next1[6] = 3 = 2 + 1。整体平移后，约定二的 next1[j] 从 0 开始的数组各元素 +1 即可得到，例如 [-1, 0, 0, ...] → [0, 1, 1, ...]。

next 数组的长度等于模式串长度 m：匹配过程中失配时 i2 最大只到 m - 1，用到的 next[i2] 下标都在 0..m-1 范围内，因此不需要求 next[m]。

为什么会有这两种写法？约定一（从 0 开始）配合 0 下标数组直接用，写代码最自然；约定二（从 1 开始）常见于教材（如严蔚敏版《数据结构》）中用 1 下标表示的串。两者在匹配时失配跳转的公式不同（一个是 i2 = next[i2]，一个是 j = next[j]），但只要和对应的匹配代码配套使用，结果完全一致。

3.3 手算 next 数组

以模式串 "abaabac" 为例，逐位手算 next 数组（采用约定一，下标从 0 开始）：

j	0	1	2	3	4	5	6	7
字符	a	b	a	a	b	c	a	c
子串 `[0, j-1]`	—	a	ab	aba	abaa	abaab	abaabc	abaabca
最长公共前后缀长度	-1	0	0	1	1	2	0	1
`next[j]`	-1	0	0	1	1	2	0	1

手算方法：对每个 j，只看模式串的前 j 个字符（下标 0 到 j - 1），找到它们的最长公共前后缀长度即可。例如 j = 5 时子串为 "abaab"，前缀与后缀最长相等的是 "ab"，所以 next[5] = 2。其中 next[0] = -1、next[1] = 0 是人为规定：0 之前没有子串，而只有一个字符时其前缀集合为空。

3.4 递推计算 next 数组

手算理解含义，但代码要用递推。递推过程中用一个变量 cn 记录「当前前缀的长度信息」（即 next[i-1]），从 i = 2 开始填表。递推规则只有三条：

① 相等分支：若 ms[i-1] == ms[cn]，则 next[i] = cn + 1，i、cn 同时前进（等价写法：next[i++] = ++cn）。
② 回退分支：若不等且 cn > 0，则 cn = next[cn]（cn 往前跳，跳到更短的前缀继续比）。
③ 结束分支：若 cn 已经跳不动了（cn == 0 且仍不等），则 next[i] = 0，i 前进。

// 递推计算 next 数组（约定一：next[0] = -1，next[1] = 0）
int i = 2;   // 当前要填 next[i] 的位置
int cn = 0;  // 前缀长度信息，等价于 next[i-1]
while (i < ms.length) {
    if (ms[i-1] == ms[cn]) {          // ① 相等：i 处信息 = cn + 1
        next[i] = cn + 1;
        i++;
        cn = next[i-1];               // 等价于 ++cn
    } else if (cn > 0) {              // ② 不等且还能跳：cn 回退到 next[cn]
        cn = next[cn];
    } else {                          // ③ 跳不动：next[i] = 0
        next[i] = 0;
    }
}

回退的本质：当 i-1 处字符与 cn 处字符不等时，说明以当前前缀长度无法延伸，就退而求其次，去尝试更短的前缀——而“更短的候选”恰好就是 next[cn]（最长公共前后缀的前缀部分）。

为什么递推的复杂度是 $O(M)$？因为 i 最多前进 M 次，cn 最多回退 M 次，总体是常数倍的操作次数。

4. 完整代码 (C++)

下面的代码采用「从 0 开始」的 next 约定（next[0] = -1），和上面第 3 章的叙述完全对应。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

// 求模式串 ms 的 next 数组
// next[j] = 模式串 ms[0..j-1] 的最长公共前后缀长度
// 人为规定：next[0] = -1，next[1] = 0
vector<int> getNextArray(const string& ms) {
    if (ms.size() <= 1) return ms.empty() ? vector<int>() : vector<int>{-1};
    vector<int> next(ms.size());
    next[0] = -1;
    next[1] = 0;
    int i = 2;   // 当前要填 next[i] 的位置
    int cn = 0;  // 前缀长度信息，等价于 next[i-1]
    while (i < (int)ms.size()) {
        if (ms[i-1] == ms[cn]) {          // ① i-1 处字符与 cn 处字符相等
            next[i++] = ++cn;             // 经典写法：next[i] = cn + 1，然后 i、cn 同时前进
        } else if (cn > 0) {              // ② 不等，cn 回退到 next[cn]
            cn = next[cn];
        } else {                          // ③ cn 跳不动，next[i] = 0
            next[i++] = 0;
        }
    }
    return next;
}

// KMP 匹配：返回 m 在 s 中第一次出现的位置，找不到返回 -1
// 约定：s.length() >= m.length()
int getIndexOf(const string& s, const string& m) {
    if (s.length() <= m.length()) return -1;
    if (m.length() == 0) return 0; // 空串按常理返回 0
    vector<int> next = getNextArray(m);
    int i1 = 0, i2 = 0; // i1 指向主串，i2 指向模式串
    while (i1 < (int)s.length() && i2 < (int)m.length()) {
        if (s[i1] == m[i2]) {         // ① 相等，同时前进
            i1++;
            i2++;
        } else if (i2 == 0) {         // ② 连开头都匹配不上，换主串开头
            i1++;
        } else {                      // ③ 失配，模式串前推（主串指针不回退）
            i2 = next[i2];
        }
    }
    return (i2 == (int)m.length()) ? i1 - i2 : -1;
}

测试用例及运行结果（已实际编译运行验证）：

调用	结果
`getIndexOf("abbcfddddbdcdaddebc", "ABCABCD")`	-1
`getIndexOf("abbcfddddbdcdaddebc", "bcf")`	2
`getIndexOf("aaaa", "bba")`	-1

5. 小结：时间复杂度

KMP 的时间复杂度要分两个阶段看：

预处理阶段：构造 next 数组。i 最多前进 M 次，cn 最多回退 M 次（M 是模式串长度），所以是 $O(M)$。
匹配阶段：主串指针 i 全程不后退、最多前进 N 次（N 是主串长度）；失配时模式串指针每次最多回退 M 次，所以匹配阶段是 $O(N)$。

总复杂度：$O(M) + O(N) = O(N + M)$，远优于暴力的 $O(N \times M)$。

6. nextval 数组优化

标准 KMP 已经很快了，但还存在一种「多余的跳转」：失配时跳到 next[j] 的位置后，如果该位置的字符和失配时的字符一样，那就还会再失配一次，白白浪费一次跳转。nextval 数组就是为了消除这种多余跳转而生的。

6.1 优化思路：找出「跳过去还是失配」的坑

先看一个具体例子：模式串 $p =$ "aaaabab"，主串为 "aaaacaaaab"。匹配到主串第 4 个字符 c 时失配，此时 $j = 4$（模式串指向第 5 个字符「a」）。按照 next 数组跳转：

next[4] = 3，跳到 $j = 3$：p[3] = 「a」，和失配字符（主串的 c）不一样？——不对，仔细看：

注意：失配发生在 p[j] 与主串字符比较时。若 p[j] == p[next[j]]，那么跳到 next[j] 后，主串那个字符仍然不匹配，又会失配一次，然后又要跳到 next[next[j]]...

主串字符是 c，p 全是 a，所以无论 j 跳到哪，只要 p[j] == 「a」，就必然再次失配。

优化思路：与其跳到一个「已知字符相同、必然再次失配」的位置，不如一次跳到「字符真正不同」的位置（或者直接跳无可跳）。把这种压缩后的跳转表叫做 nextval。

6.2 怎么计算：手算 nextval

手算规则一句话：nextval[j] = next[j]，但若 p[j] == p[next[j]]，则 nextval[j] = nextval[next[j]]。也就是说：看 next 跳过去的那个字符和当前失配字符是否相同，相同就继续向前压缩（取 nextval），不同就直接用 next。

仍以 "abaabacc" 为例，next = [-1, 0, 0, 1, 1, 2, 0, 1]，逐位计算 nextval：

j	0	1	2	3	4	5	6	7
`p[j]`	a	b	a	a	b	c	a	c
`next[j]`	-1	0	0	1	1	2	0	1
`p[next[j]]`	—	a	a	b	b	a	a	b
比较	—	b ≠ a 不同	a = a 相同	a ≠ b 不同	b = b 相同	c ≠ a 不同	a = a 相同	c ≠ b 不同
`nextval[j]`	-1	0	-1	1	0	2	-1	1

对照结论：nextval = [-1, 0, -1, 1, 0, 2, -1, 1]。可以看到 $j = 2$、4、6 三处的值被压缩了：因为跳过去的字符和失配字符相同（都是 a/b/a），干脆再往前取。

6.3 递推计算 nextval（O(M)）

递推时并不需要先求完 next 再求 nextval，可以一遍递推同时得到 next 与 nextval：

// 求模式串 ms 的 next 与 nextval（约定一：next[0] = -1）
vector<int> getNextValArray(const string& ms) {
    int m = ms.size();
    if (m == 0) return {};
    vector<int> next(m);
    int i = 0, cn = -1; // cn 初始为 -1（对应 next[0]）
    next[0] = -1;
    // 原文此处代码不完整
}

这个写法直接产出 nextval（因为 ms[i] != ms[cn] 时存 cn，相同则存 nxt[cn]）。如果把关键行改成 nxt[i] = cn，得到的就是普通 next 数组。

复杂度同样是 $O(M)$：i 最多前进 M 次，cn 最多回退 M 次。

6.4 匹配阶段怎么用 nextval

匹配代码几乎不用改，只需把失配分支的跳转数组换成 nextval：

// 匹配阶段：仅将 i2 = next[i2] 换成 i2 = nextval[i2]
} else {
    i2 = nextval[i2]; // 一跳到位，避免重复失配
}

好处：最坏情况下（如 "aaaaab" 这种大量相同字符的模式串），nextval 让跳转一步到位，匹配过程从「可能多次回退」变成「几乎不回退」，常数因子更小。复杂度量级不变（仍为 $O(N + M)$），但实际速度更快。

6.5 next 与 nextval 对比

	`next`	`nextval`
含义	最长相等前后缀长度（跳转候选）	压缩多余跳转后的最终跳转位置
失配跳转	`i2 = next[i2]`	`i2 = nextval[i2]`
可能问题	跳过去字符若相同会再次失配	一跳到位，字符必不同或已跳无可跳
例 `"abaabcac"`	`[-1, 0, 0, 1, 1, 2, 0, 1]`	`[-1, 0, -1, 1, 0, 2, -1, 1]`
适用场景	概念讲解、基础 KMP	追求常数速度优化

nextval 是 next 的「压缩版」：跳过去的字符如果和失配字符相同，就继续往前压缩，直到字符不同或跳无可跳为止。

Home-LxuMzn

表达式求值与二叉树遍历教程

1. 三种表达式是什么

1.1 中缀表达式

1.2 后缀表达式（逆波兰式 RPN）

1.3 前缀表达式（波兰式 PN）

2. 表达式树：三种表达式的统一来源

2.1 三种遍历对应三种表达式

3. 中缀表达式求值：双栈法

3.1 规则

3.2 模拟 3 + 4 * 2 / (1 - 5)^2

3.3 双栈法与后序遍历的关系

4. 中缀转后缀：调度场算法

4.1 规则

4.2 模拟 3 + 4 * 2 / (1 - 5)^2

5. 后缀表达式求值

5.1 规则

5.2 模拟 3 4 2 * 1 5 - 2 ^ / +

6. 前缀表达式求值

6.1 规则

6.2 模拟 + 3 / * 4 2 ^ - 1 5 2

7. 三种求值方法对比

8. 递归下降求值（扩展）

9. 总结

10. 推荐练习

KMP 算法详解

1. KMP 算法介绍

1.1 朴素匹配算法的缺陷

1.2 KMP 算法的改进

2. 前缀与后缀

3. next 数组

3.1 概念与人为规定

3.2 两种 next 数组约定（重点）

3.3 手算 next 数组

3.4 递推计算 next 数组

4. 完整代码 (C++)

5. 小结：时间复杂度

6. nextval 数组优化

6.1 优化思路：找出「跳过去还是失配」的坑

6.2 怎么计算：手算 nextval

6.3 递推计算 nextval（O(M)）

6.4 匹配阶段怎么用 nextval

6.5 next 与 nextval 对比

3.2 模拟 `3 + 4 * 2 / (1 - 5)^2`

4.2 模拟 `3 + 4 * 2 / (1 - 5)^2`

5.2 模拟 `3 4 2 * 1 5 - 2 ^ / +`

6.2 模拟 `+ 3 / * 4 2 ^ - 1 5 2`