Update the format of the Q&As (#1031)

docs/chapter_array_and_linkedlist/summary.md

@@ -13,7 +13,7 @@
 
 ### Q & A
 
-!!! question "数组存储在栈上和存储在堆上，对时间效率和空间效率是否有影响？"
+**Q**：数组存储在栈上和存储在堆上，对时间效率和空间效率是否有影响？
 
 存储在栈上和堆上的数组都被存储在连续内存空间内，数据操作效率基本一致。然而，栈和堆具有各自的特点，从而导致以下不同点。
 
@@ -21,7 +21,7 @@
 2. 大小限制：栈内存相对较小，堆的大小一般受限于可用内存。因此堆更加适合存储大型数组。
 3. 灵活性：栈上的数组的大小需要在编译时确定，而堆上的数组的大小可以在运行时动态确定。
 
-!!! question "为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？"
+**Q**：为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？
 
 链表由节点组成，节点之间通过引用（指针）连接，各个节点可以存储不同类型的数据，例如 `int`、`double`、`string`、`object` 等。
 
@@ -31,38 +31,38 @@
 # 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
 ```
 
-!!! question "删除节点后，是否需要把 `P.next` 设为 `None` 呢？"
+**Q**：删除节点后，是否需要把 `P.next` 设为 `None` 呢？
 
 不修改 `P.next` 也可以。从该链表的角度看，从头节点遍历到尾节点已经不会遇到 `P` 了。这意味着节点 `P` 已经从链表中删除了，此时节点 `P` 指向哪里都不会对该链表产生影响。
 
 从垃圾回收的角度看，对于 Java、Python、Go 等拥有自动垃圾回收机制的语言来说，节点 `P` 是否被回收取决于是否仍存在指向它的引用，而不是 `P.next` 的值。在 C 和 C++ 等语言中，我们需要手动释放节点内存。
 
-!!! question "在链表中插入和删除操作的时间复杂度是 $O(1)$ 。但是增删之前都需要 $O(n)$ 的时间查找元素，那为什么时间复杂度不是 $O(n)$ 呢？"
+**Q**：在链表中插入和删除操作的时间复杂度是 $O(1)$ 。但是增删之前都需要 $O(n)$ 的时间查找元素，那为什么时间复杂度不是 $O(n)$ 呢？
 
 如果是先查找元素、再删除元素，时间复杂度确实是 $O(n)$ 。然而，链表的 $O(1)$ 增删的优势可以在其他应用上得到体现。例如，双向队列适合使用链表实现，我们维护一个指针变量始终指向头节点、尾节点，每次插入与删除操作都是 $O(1)$ 。
 
-!!! question "图“链表定义与存储方式”中，浅蓝色的存储节点指针是占用一块内存地址吗？还是和节点值各占一半呢？"
+**Q**：图“链表定义与存储方式”中，浅蓝色的存储节点指针是占用一块内存地址吗？还是和节点值各占一半呢？
 
 该示意图只是定性表示，定量表示需要根据具体情况进行分析。
 
 - 不同类型的节点值占用的空间是不同的，比如 `int`、`long`、`double` 和实例对象等。
 - 指针变量占用的内存空间大小根据所使用的操作系统及编译环境而定，大多为 8 字节或 4 字节。
 
-!!! question "在列表末尾添加元素是否时时刻刻都为 $O(1)$ ？"
+**Q**：在列表末尾添加元素是否时时刻刻都为 $O(1)$ ？
 
 如果添加元素时超出列表长度，则需要先扩容列表再添加。系统会申请一块新的内存，并将原列表的所有元素搬运过去，这时候时间复杂度就会是 $O(n)$ 。
 
-!!! question "“列表的出现极大地提高了数组的实用性，但可能导致部分内存空间浪费”，这里的空间浪费是指额外增加的变量如容量、长度、扩容倍数所占的内存吗？"
+**Q**：“列表的出现极大地提高了数组的实用性，但可能导致部分内存空间浪费”，这里的空间浪费是指额外增加的变量如容量、长度、扩容倍数所占的内存吗？
 
 这里的空间浪费主要有两方面含义：一方面，列表都会设定一个初始长度，我们不一定需要用这么多；另一方面，为了防止频繁扩容，扩容一般会乘以一个系数，比如 $\times 1.5$ 。这样一来，也会出现很多空位，我们通常不能完全填满它们。
 
-!!! question "在 Python 中初始化 `n = [1, 2, 3]` 后，这 3 个元素的地址是相连的，但是初始化 `m = [2, 1, 3]` 会发现它们每个元素的 id 并不是连续的，而是分别跟 `n` 中的相同。这些元素的地址不连续，那么 `m` 还是数组吗？"
+**Q**：在 Python 中初始化 `n = [1, 2, 3]` 后，这 3 个元素的地址是相连的，但是初始化 `m = [2, 1, 3]` 会发现它们每个元素的 id 并不是连续的，而是分别跟 `n` 中的相同。这些元素的地址不连续，那么 `m` 还是数组吗？
 
 假如把列表元素换成链表节点 `n = [n1, n2, n3, n4, n5]` ，通常情况下这 5 个节点对象也分散存储在内存各处。然而，给定一个列表索引，我们仍然可以在 $O(1)$ 时间内获取节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。
 
 与许多语言不同，Python 中的数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址无须连续。
 
-!!! question "C++ STL 里面的 `std::list` 已经实现了双向链表，但好像一些算法书上不怎么直接使用它，是不是因为有什么局限性呢？"
+**Q**：C++ STL 里面的 `std::list` 已经实现了双向链表，但好像一些算法书上不怎么直接使用它，是不是因为有什么局限性呢？
 
 一方面，我们往往更青睐使用数组实现算法，而只在必要时才使用链表，主要有两个原因。
 
@@ -71,10 +71,10 @@
 
 另一方面，必要使用链表的情况主要是二叉树和图。栈和队列往往会使用编程语言提供的 `stack` 和 `queue` ，而非链表。
 
-!!! question "初始化列表 `res = [0] * self.size()` 操作，会导致 `res` 的每个元素引用相同的地址吗？"
+**Q**：初始化列表 `res = [0] * self.size()` 操作，会导致 `res` 的每个元素引用相同的地址吗？
 
 不会。但二维数组会有这个问题，例如初始化二维列表 `res = [[0] * self.size()]` ，则多次引用了同一个列表 `[0]` 。
 
-!!! question "在删除节点中，需要断开该节点与其后继节点之间的引用指向吗？"
+**Q**：在删除节点中，需要断开该节点与其后继节点之间的引用指向吗？
 
 从数据结构与算法（做题）的角度看，不断开没有关系，只要保证程序的逻辑是正确的就行。从标准库的角度看，断开更加安全、逻辑更加清晰。如果不断开，假设被删除节点未被正常回收，那么它会影响后继节点的内存回收。

docs/chapter_backtracking/summary.md

@@ -15,7 +15,7 @@
 
 ### Q & A
 
-!!! question "怎么理解回溯和递归的关系？"
+**Q**：怎么理解回溯和递归的关系？
 
 总的来看，回溯是一种“算法策略”，而递归更像是一个“工具”。
 

docs/chapter_computational_complexity/summary.md

@@ -26,11 +26,11 @@
 
 ### Q & A
 
-!!! question "尾递归的空间复杂度是 $O(1)$ 吗？"
+**Q**：尾递归的空间复杂度是 $O(1)$ 吗？
 
 理论上，尾递归函数的空间复杂度可以优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java、Python、C++、Go、C# 等）不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。
 
-!!! question "函数和方法这两个术语的区别是什么？"
+**Q**：函数和方法这两个术语的区别是什么？
 
 「函数 function」可以被独立执行，所有参数都以显式传递。「方法 method」与一个对象关联，被隐式传递给调用它的对象，能够对类的实例中包含的数据进行操作。
 
@@ -40,7 +40,7 @@
 - Java 和 C# 是面向对象的编程语言，代码块（方法）通常作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
 - C++ 和 Python 既支持过程式编程（函数），也支持面向对象编程（方法）。
 
-!!! question "图解“常见的空间复杂度类型”反映的是否是占用空间的绝对大小？"
+**Q**：图解“常见的空间复杂度类型”反映的是否是占用空间的绝对大小？
 
 不是，该图展示的是空间复杂度，其反映的是增长趋势，而不是占用空间的绝对大小。
 

docs/chapter_data_structure/summary.md

@@ -15,19 +15,20 @@
 
 ### Q & A
 
-!!! question "为什么哈希表同时包含线性数据结构和非线性数据结构？"
+**Q**：为什么哈希表同时包含线性数据结构和非线性数据结构？
 
 哈希表底层是数组，而为了解决哈希冲突，我们可能会使用“链式地址”（后续“哈希冲突”章节会讲）：数组中每个桶指向一个链表，当链表长度超过一定阈值时，又可能被转化为树（通常为红黑树）。
+
 从存储的角度来看，哈希表的底层是数组，其中每一个桶槽位可能包含一个值，也可能包含一个链表或一棵树。因此，哈希表可能同时包含线性数据结构（数组、链表）和非线性数据结构（树）。
 
-!!! question "`char` 类型的长度是 1 字节吗？"
+**Q**：`char` 类型的长度是 1 字节吗？
 
 `char` 类型的长度由编程语言采用的编码方法决定。例如，Java、JavaScript、TypeScript、C# 都采用 UTF-16 编码（保存 Unicode 码点），因此 `char` 类型的长度为 2 字节。
 
-!!! question "基于数组实现的数据结构也称“静态数据结构” 是否有歧义？栈也可以进行出栈和入栈等操作，这些操作都是“动态”的。"
+**Q**：基于数组实现的数据结构也称“静态数据结构” 是否有歧义？栈也可以进行出栈和入栈等操作，这些操作都是“动态”的。
 
 栈确实可以实现动态的数据操作，但数据结构仍然是“静态”（长度不可变）的。尽管基于数组的数据结构可以动态地添加或删除元素，但它们的容量是固定的。如果数据量超出了预分配的大小，就需要创建一个新的更大的数组，并将旧数组的内容复制到新数组中。
 
-!!! question "在构建栈（队列）的时候，未指定它的大小，为什么它们是“静态数据结构”呢？"
+**Q**：在构建栈（队列）的时候，未指定它的大小，为什么它们是“静态数据结构”呢？
 
 在高级编程语言中，我们无须人工指定栈（队列）的初始容量，这个工作由类内部自动完成。例如，Java 的 `ArrayList` 的初始容量通常为 10。另外，扩容操作也是自动实现的。详见后续的“列表”章节。

docs/chapter_graph/summary.md

@@ -16,15 +16,16 @@
 
 ### Q & A
 
-!!! question "路径的定义是顶点序列还是边序列？"
+**Q**：路径的定义是顶点序列还是边序列？
 
 维基百科上不同语言版本的定义不一致：英文版是“路径是一个边序列”，而中文版是“路径是一个顶点序列”。以下是英文版原文：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.
+
 在本文中，路径被视为一个边序列，而不是一个顶点序列。这是因为两个顶点之间可能存在多条边连接，此时每条边都对应一条路径。
 
-!!! question "非连通图中是否会有无法遍历到的点？"
+**Q**：非连通图中是否会有无法遍历到的点？
 
 在非连通图中，从某个顶点出发，至少有一个顶点无法到达。遍历非连通图需要设置多个起点，以遍历到图的所有连通分量。
 
-!!! question "在邻接表中，“与该顶点相连的所有顶点”的顶点顺序是否有要求？"
+**Q**：在邻接表中，“与该顶点相连的所有顶点”的顶点顺序是否有要求？
 
 可以是任意顺序。但在实际应用中，可能需要按照指定规则来排序，比如按照顶点添加的次序，或者按照顶点值大小的顺序等，这样有助于快速查找“带有某种极值”的顶点。

docs/chapter_hashing/summary.md

@@ -18,15 +18,15 @@
 
 ### Q & A
 
-!!! question "哈希表的时间复杂度在什么情况下是 $O(n)$ ？"
+**Q**：哈希表的时间复杂度在什么情况下是 $O(n)$ ？
 
 当哈希冲突比较严重时，哈希表的时间复杂度会退化至 $O(n)$ 。当哈希函数设计得比较好、容量设置比较合理、冲突比较平均时，时间复杂度是 $O(1)$ 。我们使用编程语言内置的哈希表时，通常认为时间复杂度是 $O(1)$ 。
 
-!!! question "为什么不使用哈希函数 $f(x) = x$ 呢？这样就不会有冲突了"
+**Q**：为什么不使用哈希函数 $f(x) = x$ 呢？这样就不会有冲突了。
 
 在 $f(x) = x$ 哈希函数下，每个元素对应唯一的桶索引，这与数组等价。然而，输入空间通常远大于输出空间（数组长度），因此哈希函数的最后一步往往是对数组长度取模。换句话说，哈希表的目标是将一个较大的状态空间映射到一个较小的空间，并提供 $O(1)$ 的查询效率。
 
-!!! question "哈希表底层实现是数组、链表、二叉树，但为什么效率可以比它们更高呢？"
+**Q**：哈希表底层实现是数组、链表、二叉树，但为什么效率可以比它们更高呢？
 
 首先，哈希表的时间效率变高，但空间效率变低了。哈希表有相当一部分内存未使用。
 
@@ -34,14 +34,14 @@
 
 最后，哈希表的时间复杂度可能发生劣化。例如在链式地址中，我们采取在链表或红黑树中执行查找操作，仍然有退化至 $O(n)$ 时间的风险。
 
-!!! question "多次哈希有不能直接删除元素的缺陷吗？标记为已删除的空间还能再次使用吗？"
+**Q**：多次哈希有不能直接删除元素的缺陷吗？标记为已删除的空间还能再次使用吗？
 
 多次哈希是开放寻址的一种，开放寻址法都有不能直接删除元素的缺陷，需要通过标记删除。标记为已删除的空间可以再次使用。当将新元素插入哈希表，并且通过哈希函数找到标记为已删除的位置时，该位置可以被新元素使用。这样做既能保持哈希表的探测序列不变，又能保证哈希表的空间使用率。
 
-!!! question "为什么在线性探测中，查找元素的时候会出现哈希冲突呢？"
+**Q**：为什么在线性探测中，查找元素的时候会出现哈希冲突呢？
 
 查找的时候通过哈希函数找到对应的桶和键值对，发现 `key` 不匹配，这就代表有哈希冲突。因此，线性探测法会根据预先设定的步长依次向下查找，直至找到正确的键值对或无法找到跳出为止。
 
-!!! question "为什么哈希表扩容能够缓解哈希冲突？"
+**Q**：为什么哈希表扩容能够缓解哈希冲突？
 
 哈希函数的最后一步往往是对数组长度 $n$ 取模（取余），让输出值落在数组索引范围内；在扩容后，数组长度 $n$ 发生变化，而 `key` 对应的索引也可能发生变化。原先落在同一个桶的多个 `key` ，在扩容后可能会被分配到多个桶中，从而实现哈希冲突的缓解。

docs/chapter_heap/summary.md

@@ -12,6 +12,6 @@
 
 ### Q & A
 
-!!! question "数据结构的“堆”与内存管理的“堆”是同一个概念吗？"
+**Q**：数据结构的“堆”与内存管理的“堆”是同一个概念吗？
 
 两者不是同一个概念，只是碰巧都叫“堆”。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄漏。相较于栈内存，堆内存的管理和使用需要更谨慎，使用不当可能会导致内存泄漏和野指针等问题。

docs/chapter_sorting/summary.md

@@ -16,13 +16,13 @@
 
 ### Q & A
 
-!!! question "排序算法稳定性在什么情况下是必需的？"
+**Q**：排序算法稳定性在什么情况下是必需的？
 
 在现实中，我们有可能基于对象的某个属性进行排序。例如，学生有姓名和身高两个属性，我们希望实现一个多级排序：先按照姓名进行排序，得到 `(A, 180) (B, 185) (C, 170) (D, 170)` ；再对身高进行排序。由于排序算法不稳定，因此可能得到 `(D, 170) (C, 170) (A, 180) (B, 185)` 。
 
 可以发现，学生 D 和 C 的位置发生了交换，姓名的有序性被破坏了，而这是我们不希望看到的。
 
-!!! question "哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？"
+**Q**：哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？
 
 不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。
 
@@ -32,16 +32,16 @@
 
 再深入思考一下，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。
 
-!!! question "关于尾递归优化，为什么选短的数组能保证递归深度不超过 $\log n$ ？"
+**Q**：关于尾递归优化，为什么选短的数组能保证递归深度不超过 $\log n$ ？
 
 递归深度就是当前未返回的递归方法的数量。每轮哨兵划分我们将原数组划分为两个子数组。在尾递归优化后，向下递归的子数组长度最大为原数组长度的一半。假设最差情况，一直为一半长度，那么最终的递归深度就是 $\log n$ 。
 
 回顾原始的快速排序，我们有可能会连续地递归长度较大的数组，最差情况下为 $n$、$n - 1$、$\dots$、$2$、$1$ ，递归深度为 $n$ 。尾递归优化可以避免这种情况出现。
 
-!!! question "当数组中所有元素都相等时，快速排序的时间复杂度是 $O(n^2)$ 吗？该如何处理这种退化情况？"
+**Q**：当数组中所有元素都相等时，快速排序的时间复杂度是 $O(n^2)$ 吗？该如何处理这种退化情况？
 
 是的。对于这种情况，可以考虑通过哨兵划分将数组划分为三个部分：小于、等于、大于基准数。仅向下递归小于和大于的两部分。在该方法下，输入元素全部相等的数组，仅一轮哨兵划分即可完成排序。
 
-!!! question "桶排序的最差时间复杂度为什么是 $O(n^2)$ ？"
+**Q**：桶排序的最差时间复杂度为什么是 $O(n^2)$ ？
 
 最差情况下，所有元素被分至同一个桶中。如果我们采用一个 $O(n^2)$ 算法来排序这些元素，则时间复杂度为 $O(n^2)$ 。

docs/chapter_stack_and_queue/summary.md

@@ -10,19 +10,19 @@
 
 ### Q & A
 
-!!! question "浏览器的前进后退是否是双向链表实现？"
+**Q**：浏览器的前进后退是否是双向链表实现？
 
 浏览器的前进后退功能本质上是“栈”的体现。当用户访问一个新页面时，该页面会被添加到栈顶；当用户点击后退按钮时，该页面会从栈顶弹出。使用双向队列可以方便地实现一些额外操作，这个在“双向队列”章节有提到。
 
-!!! question "在出栈后，是否需要释放出栈节点的内存？"
+**Q**：在出栈后，是否需要释放出栈节点的内存？
 
 如果后续仍需要使用弹出节点，则不需要释放内存。若之后不需要用到，`Java` 和 `Python` 等语言拥有自动垃圾回收机制，因此不需要手动释放内存；在 `C` 和 `C++` 中需要手动释放内存。
 
-!!! question "双向队列像是两个栈拼接在了一起，它的用途是什么？"
+**Q**：双向队列像是两个栈拼接在了一起，它的用途是什么？
 
 双向队列就像是栈和队列的组合，或两个栈拼在了一起。它表现的是栈 + 队列的逻辑，因此可以实现栈与队列的所有应用，并且更加灵活。
 
-!!! question "撤销（undo）和反撤销（redo）具体是如何实现的？"
+**Q**：撤销（undo）和反撤销（redo）具体是如何实现的？
 
 使用两个栈，栈 `A` 用于撤销，栈 `B` 用于反撤销。
 

docs/chapter_tree/summary.md

@@ -16,31 +16,31 @@
 
 ### Q & A
 
-!!! question "对于只有一个节点的二叉树，树的高度和根节点的深度都是 $0$ 吗？"
+**Q**：对于只有一个节点的二叉树，树的高度和根节点的深度都是 $0$ 吗？
 
 是的，因为高度和深度通常定义为“经过的边的数量”。
 
-!!! question "二叉树中的插入与删除一般由一套操作配合完成，这里的“一套操作”指什么呢？可以理解为资源的子节点的资源释放吗？"
+**Q**：二叉树中的插入与删除一般由一套操作配合完成，这里的“一套操作”指什么呢？可以理解为资源的子节点的资源释放吗？
 
 拿二叉搜索树来举例，删除节点操作要分三种情况处理，其中每种情况都需要进行多个步骤的节点操作。
 
-!!! question "为什么 DFS 遍历二叉树有前、中、后三种顺序，分别有什么用呢？"
+**Q**：为什么 DFS 遍历二叉树有前、中、后三种顺序，分别有什么用呢？
 
-    与顺序和逆序遍历数组类似，前序、中序、后序遍历是三种二叉树遍历方法，我们可以使用它们得到一个特定顺序的遍历结果。例如在二叉搜索树中，由于节点大小满足 `左子节点值 < 根节点值 < 右子节点值` ，因此我们只要按照 `左 $\rightarrow$ 根 $\rightarrow$ 右` 的优先级遍历树，就可以获得有序的节点序列。
+与顺序和逆序遍历数组类似，前序、中序、后序遍历是三种二叉树遍历方法，我们可以使用它们得到一个特定顺序的遍历结果。例如在二叉搜索树中，由于节点大小满足 `左子节点值 < 根节点值 < 右子节点值` ，因此我们只要按照“左 $\rightarrow$ 根 $\rightarrow$ 右”的优先级遍历树，就可以获得有序的节点序列。
 
-!!! question "右旋操作是处理失衡节点 `node`、`child`、`grand_child` 之间的关系，那 `node` 的父节点和 `node` 原来的连接不需要维护吗？右旋操作后岂不是断掉了？"
+**Q**：右旋操作是处理失衡节点 `node`、`child`、`grand_child` 之间的关系，那 `node` 的父节点和 `node` 原来的连接不需要维护吗？右旋操作后岂不是断掉了？
 
 我们需要从递归的视角来看这个问题。右旋操作 `right_rotate(root)` 传入的是子树的根节点，最终 `return child` 返回旋转之后的子树的根节点。子树的根节点和其父节点的连接是在该函数返回后完成的，不属于右旋操作的维护范围。
 
-!!! question "在 C++ 中，函数被划分到 `private` 和 `public` 中，这方面有什么考量吗？为什么要将 `height()` 函数和 `updateHeight()` 函数分别放在 `public` 和 `private` 中呢？"
+**Q**：在 C++ 中，函数被划分到 `private` 和 `public` 中，这方面有什么考量吗？为什么要将 `height()` 函数和 `updateHeight()` 函数分别放在 `public` 和 `private` 中呢？
 
 主要看方法的使用范围，如果方法只在类内部使用，那么就设计为 `private` 。例如，用户单独调用 `updateHeight()` 是没有意义的，它只是插入、删除操作中的一步。而 `height()` 是访问节点高度，类似于 `vector.size()` ，因此设置成 `public` 以便使用。
 
-!!! question "如何从一组输入数据构建一棵二叉搜索树？根节点的选择是不是很重要？"
+**Q**：如何从一组输入数据构建一棵二叉搜索树？根节点的选择是不是很重要？
 
 是的，构建树的方法已在二叉搜索树代码中的 `build_tree()` 方法中给出。至于根节点的选择，我们通常会将输入数据排序，然后将中点元素作为根节点，再递归地构建左右子树。这样做可以最大程度保证树的平衡性。
 
-!!! question "在 Java 中，字符串对比是否一定要用 `equals()` 方法？"
+**Q**：在 Java 中，字符串对比是否一定要用 `equals()` 方法？
 
 在 Java 中，对于基本数据类型，`==` 用于对比两个变量的值是否相等。对于引用类型，两种符号的工作原理是不同的。
 
@@ -49,6 +49,6 @@
 
 因此，如果要对比值，我们应该使用 `equals()` 。然而，通过 `String a = "hi"; String b = "hi";` 初始化的字符串都存储在字符串常量池中，它们指向同一个对象，因此也可以用 `a == b` 来比较两个字符串的内容。
 
-!!! question "广度优先遍历到最底层之前，队列中的节点数量是 $2^h$ 吗？"
+**Q**：广度优先遍历到最底层之前，队列中的节点数量是 $2^h$ 吗？
 
 是的，例如高度 $h = 2$ 的满二叉树，其节点总数 $n = 7$ ，则底层节点数量 $4 = 2^h = (n + 1) / 2$ 。