From 56f9733bb82934bf1ecb5e216062b9dd54ec4c25 Mon Sep 17 00:00:00 2001
From: YYF <664033561@qq.com>
Date: Thu, 9 May 2019 19:28:26 +0800
Subject: [PATCH] last confirm

done
---
 zh/6.md | 45 ++++++++++++++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/zh/6.md b/zh/6.md
index 31e9bdf..66cb7e3 100644
--- a/zh/6.md
+++ b/zh/6.md
@@ -16,9 +16,9 @@
 
 键不必是整数。通常，我们可以对key使用任何一种全序关系(total order)来把一组数据添加到BST中，我们用符号\leq表述全序关系，全序关系具有以下属性：
 
-*完备性： 对于任何 x 和 y 要么满足 x \leq y 要么满足 y \leq x 或者二者同时都满足
-*传递性： 如果 x \leq y 而且 y \leq z 那么 x \leq z
-*非对称性 如果 x \leq y 并且 y \leq x 那么 x = y  
+* 完备性： 对于任何 x 和 y 要么满足 x ≤ y 要么满足 y ≤ x 或者二者同时都满足
+* 传递性： 如果 x ≤ y 而且 y ≤ z 那么 x ≤ z
+* 非对称性 如果 x ≤ y 并且 y ≤ x 那么 x = y  
 
 例如，键可以是整数，而且不仅可以是整数，可以有它们通常的含义。或者数据和键可以是字符串，其顺序是字典排序。或者，数据可以是（pairs）一对（A，B），键可以是对的第一项。字典排序就像是按定义的单词排序，而不考虑它们的含义。最后一个排序是一个例子，在这个例子中，人们可能期望在搜索树中有几个具有相同键的不同项。
 
@@ -143,7 +143,8 @@ static BST insert(BST T, int L){
   此外，由于它是第一个按顺序排列的节点，其左子节点将为空。因此，我们可以用其正确的子节点替换该节点，并将
   其key移动到要删除的节点，如图6.3（c）所示
 
-![avatar](/img/6.2.png)
+
+![6.3](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.3.png)
 
 三个可能的删除，每个从图6.1中的树开始
 
@@ -256,7 +257,8 @@ public static BST remove(BST T, int L) {
 图6.1（b）中的树是按升序将节点插入到树中的结果（显然，同样的树可以从更大的树中进行适当的删除操作得到）
 您可以看到在树上执行搜索或插入就像在链接列表上执行搜索或插入。它像一个链接列表，但在每个元素中都有多余的指针，这些指针始终为空
 这棵树是不平衡的：它包含子树，在其中，左、右子树有不同的高度。在进行进一步学习后，我们将在第9章中回到这个问题
-![avatar](/img/6.1.png)
+
+![6.1](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.1.png)
 
 
 ## 6.2 实现SortedSet接口   Implementing the SortedSet interface
@@ -345,7 +347,8 @@ private BSTSet (BSTSet<T> set, T low, T high) {
 
 *continued: Private nested classes used in implementation*
 
-![avatar](/img/6.1.png)
+![6.8](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.8.png)
+
 *表示的BST部分在动物群和子集之间共享。三角形表示整个子树，圆形矩形表示单个节点。每个集合包含一个指向列表根的指针（一个sentinel节点，其标签被认为大于树中的任何值）、值的上下限（空表示未绑定）和比较器（在本例中为空，表示自然顺序）。迭代器包含一个指向子集的指针（它正在迭代），一个指向按顺序包含next label的节点的指针（next）（“duck”），另一个指向按i.next（）最后传递的序列包含标签的节点的指针（last）。BST的虚线区域完全由迭代器进行sk ipped。迭代器不返回“hartebeest”节点，但迭代器必须通过它才能到达它返回的节点。*
 
 
@@ -368,7 +371,7 @@ private BSTSet (BSTSet<T> set, T low, T high) {
 任何一个区域都可以根据若干内部分界点划分为西北、东北、东南和西南的矩形分区，这些分区由与分界点对应的树节点的子节点表示。
 对于pr四叉树，这些分界点是矩形的中心，而对于点四叉树，它们是从数据点中选择的，就像二进制搜索树中的分界值是从存储在树中的数据中选择的一样。
 
-![avatar](/img/6.9.png)
+![6.9](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.8.png)
 
 *同一组数据的两种四叉树的图解*
 对于pr四叉树，树的每个级别都包含表示具有相同边大小的正方形的节点（如右图所示）。
@@ -403,13 +406,15 @@ interface PriorityQueue<T extends Comparable<T>> {
 用于表示优先级队列的数据结构是堆（由于命名冲突，注意不要与新分配内存的大容量存储区混淆）。 
 堆只是一个满足以下属性的位置树（通常是二叉树）。
 
-*堆属性：树中任何节点上的标签大于或等于该节点的任何后代的标签。
+* 堆属性：树中任何节点上的标签大于或等于该节点的任何后代的标签。
 
 
 由于叶子节点的顺序无关紧要，所以在如何排列堆中的值方面有更多的操作空间，这使得保持堆的茂密变得容易。
 因此，当我们在此上下文中使用术语“heap”时，我们将表示具有heap属性的完整树。
 这加快了对堆的所有操作，因为插入和删除所需的时间与堆的高度成正比。图6.11显示了一个典型的堆
-![avatar](/img/6.11.png)
+
+![6.11](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.11.png)
+
 *序列（b）–（d）显示删除最大项的步骤。最后一个（最底部，最右侧）标签首先向上移动以覆盖根的标签。
 它被“筛选”直到堆属性被存储。阴影节点显示在进程中违反堆属性的位置。*
 
@@ -510,7 +515,9 @@ protected void heapify() { ... }
 *continued*
 
 过程图解：
-![avatar](/img/6.13.png)
+
+![6.13](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.13.png)
+
 *堆排序示例。原始数组在（a）中；（b）是setheap的结果；（c）–（h）是连续迭代的结果。
 每个都显示堆数组的活动部分和输出数组的已排序部分，由间隙分隔*
 
@@ -542,7 +549,7 @@ protected void heapify(){
  接下来的$\sqrt[2]{k-1}$个元素保持 **K-1**，以此类推。
  因此，花费在提取项目上的总时间是：
 
-![avatar](/img/heap1.png)
+![heap1](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/heap1.png)
 
 现在让我们考虑一下堆积n元素的成本。
 如果我们通过逐个插入n个元素并执行reHapifyUp来完成此操作，
@@ -553,18 +560,22 @@ protected void heapify(){
 *等等
 
 
-![avatar](/img/heap2.png)
+![heap2](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/heap2.png)
+
 上面公式结果最坏的情况是，N个数据通过重复执行reHapifyDown来完成生成堆的操作。
 这和刚刚给出的公式一样
-![avatar](/img/heap3.png)
+![heap3](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/heap3.png)
 
 但假设我们在第6.4节结尾处执行第二个算法，
 对数组中所有项（从n/2−1开始一直到0）进行重新计算，从而进行堆积。
 reHapifyDown的开销取决于到最深处的距离。
 对于堆中的最后$\sqrt[2]{k}$个数据，这个成本是0（这就是为什么要跳过它们）。对于前面的$\sqrt[2]{k-1}$，成本为1
-![avatar](/img/heap4.png)
+
+![heap4](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/heap4.png)
+
 使用和之前一样的方法计算：
-![avatar](/img/heap5.png)
+
+![heap5](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/heap5.png)
 
 
 因此，第二种生成堆的方法比明显的重复插入方法运行得更快（渐进）。
@@ -605,7 +616,7 @@ reHapifyDown的开销取决于到最深处的距离。
 在不断增加的深度重复搜索，直到达到某个时间限制，并采用迄今为止发现的最佳结果
 
 
-![avatar](/img/6.14.png)
+![6.14](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.14.png)
 图6.14：来计算得分。
 节点是位置(positions)，线是决策(moves)，数字是为您估计每个位置的“优势”的分数。
 星星表示根据优势分析应该选择的子节点。
@@ -632,7 +643,7 @@ reHapifyDown的开销取决于到最深处的距离。
 alpha-beta修剪绝不是加速搜索博弈树的唯一方法。
 更复杂的搜索策略可以去参考AI相关算法。
 
-![avatar](/img/6.15.png)
+![6.15](https://github.com/yongfengyan/cs61b-textbook-zh/blob/master/zh/img/6.15.png)
 
 ### 6.5.2 博弈树搜索算法   A game-tree search algorithm
 
-- 
GitLab