update index 💄

note/README.md

@@ -27,28 +27,29 @@
 - [🔖 java-8-collectors](java/stream/collectors.md)   
 - [🔖 java-8-Stream 讲解与示例](java/stream/stream.md)   
 - [🔖 JDK15的重大更新](https://blog.csdn.net/weixin_38937840/article/details/109191674)   
-## [🔖 二.数据结构与算法](java/datastructureAlgorithm/README.md)
-#### [🔖 2.1数据结构篇](java/datastructureAlgorithm/README.md)
-- [🔖 二维数组](java/datastructureAlgorithm/book/datastructure/SparseArray.md)
-- [🔖 栈](java/datastructureAlgorithm/book/datastructure/Stack.md)
-- [🔖 队列](java/datastructureAlgorithm/book/datastructure/Queue.md)
-- [🔖 位置](java/datastructureAlgorithm/book/datastructure/Position.md)
-- [🔖 链表](java/datastructureAlgorithm/book/datastructure/Linkend.md)
-- [🔖 双端队列](java/datastructureAlgorithm/book/datastructure/Deque.md)
-- [🔖 向量与数组](java/datastructureAlgorithm/book/datastructure/VectorOrArrayList.md)
-- [🔖 列表](java/datastructureAlgorithm/book/datastructure/List.md)
-- [🔖 树](java/datastructureAlgorithm/book/datastructure/Tree.md)
-- [🔖  跳表](java/datastructureAlgorithm/book/datastructure/skipList.md)
-#### [🔖 2.2 算法篇](java/datastructureAlgorithm/README.md)
-##### [🔖 排序算法](java/datastructureAlgorithm/README.md)
-- [🔖 冒泡排序](java/datastructureAlgorithm/book/algorithm/sort/BubbleSort.md)
-- [🔖 递归排序](java/datastructureAlgorithm/book/algorithm/sort/Recursion.md)
-- [🔖 快速排序](java/datastructureAlgorithm/book/algorithm/sort/QuickSort.md)
-- [🔖 选择排序](java/datastructureAlgorithm/book/algorithm/sort/SelectSort.md)
-- [🔖 插入排序](java/datastructureAlgorithm/book/algorithm/sort/InsertSort.md)
-- [🔖 希尔排序](java/datastructureAlgorithm/book/algorithm/sort/DonaldShell.md)
-##### [查找算法](java/datastructureAlgorithm/README.md)
-- [🔖 线性查找](java/datastructureAlgorithm/book/algorithm/search/SeqSearch.md)
+## [🔖 二.数据结构与算法](datastructureAlgorithm/README.md)
+#### [🔖 2.1数据结构篇](datastructureAlgorithm/README.md)
+- [🔖 二维数组](datastructureAlgorithm/book/datastructure/SparseArray.md)
+- [🔖 栈](datastructureAlgorithm/book/datastructure/Stack.md)
+- [🔖 队列](datastructureAlgorithm/book/datastructure/Queue.md)
+- [🔖 位置](datastructureAlgorithm/book/datastructure/Position.md)
+- [🔖 链表](datastructureAlgorithm/book/datastructure/Linkend.md)
+- [🔖 双端队列](datastructureAlgorithm/book/datastructure/Deque.md)
+- [🔖 向量与数组](datastructureAlgorithm/book/datastructure/VectorOrArrayList.md)
+- [🔖 列表](datastructureAlgorithm/book/datastructure/List.md)
+- [🔖 树](datastructureAlgorithm/book/datastructure/Tree.md)
+- [🔖  跳表](datastructureAlgorithm/book/datastructure/skipList.md)
+#### [🔖 2.2 算法篇](datastructureAlgorithm/README.md)
+##### [🔖 排序算法](datastructureAlgorithm/README.md)
+- [🔖 冒泡排序](datastructureAlgorithm/book/algorithm/sort/BubbleSort.md)
+- [🔖 递归排序](datastructureAlgorithm/book/algorithm/sort/Recursion.md)
+- [🔖 快速排序](datastructureAlgorithm/book/algorithm/sort/QuickSort.md)
+- [🔖 选择排序](datastructureAlgorithm/book/algorithm/sort/SelectSort.md)
+- [🔖 插入排序](datastructureAlgorithm/book/algorithm/sort/InsertSort.md)
+- [🔖 希尔排序](datastructureAlgorithm/book/algorithm/sort/DonaldShell.md)
+##### [查找算法](datastructureAlgorithm/README.md)
+- [🔖 线性查找](datastructureAlgorithm/book/algorithm/search/SeqSearch.md)
+- [🔖 二分查找](datastructureAlgorithm/book/algorithm/search/BinarySearch.md)
 ## [🔖 三.Java 并发实战与并发设计模式](java/concurrency/README.md)
 - [🔖 Util](java/concurrency/README.md)
   - [🔖 ExecutorService指南](java/concurrency/util/ExecutorService指南.md)  

note/java/datastructureAlgorithm/book/datastructure/Deque.md → note/datastructureAlgorithm/book/datastructure/Deque.md

@@ -11,15 +11,15 @@
 ### 双端队列的ADT
 相比于栈和队列，双端队列的抽象数据类型要复杂很多，其中基本的方法如下：
 
-![deque01](../../../../../doc/java/datastructure/deque/deque01.png)
+![deque01](img/deque/deque01.png)
 
 此外，还可能支持以下方法：
 
-![deque02](../../../../../doc/java/datastructure/deque/deque02.png)
+![deque02](img/deque/deque02.png)
 
 给出了从一个空双端队列开始，在依次执行一系列操作的过程中，队列中内容的相应变化。
 
-![deque03](../../../../../doc/java/datastructure/deque/deque03.png)
+![deque03](img/deque/deque03.png)
 
 ### 双端队列的接口
 双端队列接口如代码所示
@@ -174,7 +174,7 @@ public class Node<E> implements Position<E> {
 
 ### 基于双向链表实现的双端队列
 
-![deque04](../../../../../doc/java/datastructure/deque/deque04.png)
+![deque04](img/deque/deque04.png)
 
 在基于Node类实现双向链表的时候，为了使编程更加简洁，通常我们都要在最前端和最后
 端各设置一个哑元节点（Dummy node）。这两个节点分别称作头节点（Header node）和尾节点
@@ -183,17 +183,17 @@ public class Node<E> implements Position<E> {
 结构，如上图所示。
 - 首、末节点的插入
 对双端队列的插入操作，与单链表类似。图 给出了在链表前端插入节点的过程。
-![deque05](../../../../../doc/java/datastructure/deque/deque05.png)
+![deque05](img/deque/deque05.png)
 
 - 首、末节点的删除
 更重要的是，我们可以在O(1)时间内删除双向链表任何一端的节点。如图 所示的，就是
 删除末节点的过程。首节点的删除过程是对称的，请读者自行给出。
-![deque06](../../../../../doc/java/datastructure/deque/deque06.png)
+![deque06](img/deque/deque06.png)
 需要特别指出的是，与单链表不同，这里能够在常数时间内删除末节点。之所以能够这样，是
 因为可以直接通过末节点的prev 引用找到它的直接前驱（新的末节点），而无需遍历整个链表。
 
 - 一般节点的插入与删除
-![deque07](../../../../../doc/java/datastructure/deque/deque07.png)
+![deque07](img/deque/deque07.png)
 
 一般地，若要在相邻的一对节点p 和q 之间插入新元素e，我们只需生成一个新节点t，将e
 存放至其中，然后将t 的prev 和next 引用分别指向p 和q，然后让p（q）的next（prev）引用指向t。

note/java/datastructureAlgorithm/book/datastructure/Linkend.md → note/datastructureAlgorithm/book/datastructure/Linkend.md

@@ -14,7 +14,7 @@
 所谓链表（Linked list），就是按线性次序排列的一组数据节点。如图 所示，每个节点都是
 一个对象，它通过一个引用element指向对应的数据元素，同时还通过一个引用next指向下一节点。
 
-###### ![linked01](../../../../../doc/java/datastructure/linked/linked01.png)
+###### ![linked01](img/linked/linked01.png)
 
 节点间这种相互指向的关系，乍看起来有循环引用之嫌，然而实际上却完全可行，而且不难实
 现。每个节点的next 引用都相当于一个链接或指针，指向另一节点。借助于这些next 引用，我们
@@ -91,21 +91,21 @@ public class Node<E> implements Position<E> {
 对于如图(a)所示的单链表，为了插入一个节点，我们首先要创建该节点，然后将其next
 引用指向当前的首节点（图二(b)），然后将队列的head引用指向新插入的节点（图二(c)）。
 
-![linked02](../../../../../doc/java/datastructure/linked/linked02.png)
+![linked02](img/linked/linked02.png)
 
 - 首节点的删除
 反之，对于如图二(a)所示的单链表，为了删除首节点，我们首先将首节点的next引用复制一
 份，然后才删除该节点（图二(b)），最后将表头引用设置为先前复制的引用（图二(c)）。
 
-![linked03](../../../../../doc/java/datastructure/linked/linked03.png)
+![linked03](img/linked/linked03.png)
 
 - 末节点的插入
 假定我们借助一个引用tail始终指向的末节点，则在表尾插入新节点也只需O(1)时间。对于如图
 二(a)所示的单链表，为了将一个新节点作为末节点插入，我们首先要创建该节点，将其next引用
 置为空，并将当前末节点的next引用指向该新节点（图二(b)），最后将tail引用指向新节点（图
 二(c)）。需要特别提醒的是，上述操作的次序很有讲究，不能随意调换。
 
-![linked04](../../../../../doc/java/datastructure/linked/linked04.png)
+![linked04](img/linked/linked04.png)
 
 ### 基于单链表实现栈
 

note/java/datastructureAlgorithm/book/datastructure/List.md → note/datastructureAlgorithm/book/datastructure/List.md

@@ -38,7 +38,7 @@ obj)方法替换为新方法 insertAfterNode(v, obj)，即可将 obj 插入到
 在引入位置概念对列表“节点”进行封装之后，就可以得到一个新的序列 ADT，称作列表（List）。
 该 ADT 支持对列表 S 的以下方法：
 
-![list01](../../../../../doc/java/datastructure/list/list01.png)
+![list01](img/list/list01.png)
 
 通过以上方法，才可以谈论并使用相对于列表前端或末端的位置概念，并且顺次访问列表的各
 个元素。尽管这一位置概念可以直观地与列表中的节点对应起来，但一定要注意：这里并没有通过
@@ -48,12 +48,12 @@ obj)方法替换为新方法 insertAfterNode(v, obj)，即可将 obj 插入到
 - 修改列表的方法
 除了通常都提供的 size()和 isEmpty()以及上面给出的方法，为了对列表做修改与更新，列
 表 ADT 还需支持以下方法。这些方法的共同点在于，它们都以位置为参数或（和）返回值。
-![list02](../../../../../doc/java/datastructure/list/list02.png)
-![list03](../../../../../doc/java/datastructure/list/list03.png)
+![list02](img/list/list02.png)
+![list03](img/list/list03.png)
 
 有了列表ADT，我们就可以从位置的角度来看待一组按序存放的对象，而不必考虑它们的位置的具体表示
 
-![list04](../../../../../doc/java/datastructure/list/list04.png)
+![list04](img/list/list04.png)
 
 有的读者或许已经注意到，在上述列表 ADT 的定义中，有些操作的功能是重复的。比如，
 insertBefore(first(), e) 的效果与 insertFirst(e)完全相同，insertAfter(last(), e) 的效果与 insertLast(e)
@@ -152,8 +152,8 @@ v插入至要求的位置，最后调整其直接前驱与后继的next和prev
 ```
 则给出了一次insertBefore()操作实例
 
-![list05](../../../../../doc/java/datastructure/list/list05.png)
-![list06](../../../../../doc/java/datastructure/list/list06.png)
+![list05](img/list/list05.png)
+![list06](img/list/list06.png)
 
 方法 insertAfter()、insertFirst()和 insertLast()都可以仿照这一算法来实现。
 
@@ -178,7 +178,7 @@ v插入至要求的位置，最后调整其直接前驱与后继的next和prev
 
 remove()操作的一个实例。
 
-![list07](../../../../../doc/java/datastructure/list/list07.png)
+![list07](img/list/list07.png)
 
 - 代码实现
 

note/java/datastructureAlgorithm/book/datastructure/Position.md → note/datastructureAlgorithm/book/datastructure/Position.md

@@ -5,7 +5,7 @@
 ### 位置ADT
 所谓“位置”，就是支持以下方法的一种数据类型
 
-![linked01](../../../../../doc/java/datastructure/position/position01.png)
+![linked01](img/position/position01.png)
 
 按线性次序排列的一组位置，就构成了一个列表。在列表中，各个位置都是相对而言的⎯⎯相
 对于它的前、后邻居。在列表中，除第一个（最后一个）位置外，每个位置都有唯一的前驱（后继）

note/java/datastructureAlgorithm/book/datastructure/Queue.md → note/datastructureAlgorithm/book/datastructure/Queue.md

@@ -20,15 +20,15 @@
 插入的对象首先被删除（FIFO）。
 队列ADT 首先支持下面的两个基本方法：
 
-![queue01](../../../../../doc/java/datastructure/queue/queue01.png)
+![queue01](img/queue/queue01.png)
 
 此外，与栈ADT 类似地，队列ADT 还支持如下的方法：
 
-![queue02](../../../../../doc/java/datastructure/queue/queue02.png)
+![queue02](img/queue/queue02.png)
 
 给出了从一个空队列开始，在依次执行一系列操作的过程中，队列中内容的相应变化。
 
-![queue03](../../../../../doc/java/datastructure/queue/queue03.png)
+![queue03](img/queue/queue03.png)
 
 队列的应用十分广泛，无论是商店、剧院、机场还是银行、医院，凡是按照“先到的客户优先
 接受服务”原则的场合，都可以利用队列这一数据结构来编排相应的服务。

note/java/datastructureAlgorithm/book/datastructure/SparseArray.md → note/datastructureAlgorithm/book/datastructure/SparseArray.md

@@ -4,17 +4,17 @@
 因此造成内存空间的浪费，为了解决这问题，并且不影响数组中原 有的元素值，我们采用了一种压缩的方式来 表示稀疏数组的内容。 
 如图二维数组所示，有大部分的空间是无用的。
 
-![img](../../../../../doc/java/datastructure/array01.png) |
+![img](img/array01.png) |
 
 在这里可以使用稀疏数组进行压缩。其中在稀疏数组中第一部分所记录的是原数组的列数和行数以及元素使用的个数、第二部分所记录的是原数组中元素的位置和内容。
 经过压缩之后，原来需要声明大小为63的数组，而使用压缩后，只需要声明大小为6*3的数组，仅需18个存储空间。
 
-![img](../../../../../doc/java/datastructure/array02.png) |
+![img](img/array02.png) |
 
 
 ### 一个实际的需求
 
-![img](../../../../../doc/java/datastructure/qipan.jpg) |
+![img](img/qipan.jpg) |
 
 编写的五子棋程序中，有存盘退出和续上盘的功能。
 
@@ -27,7 +27,7 @@
     2)	把稀疏数组存盘，并且可以从新恢复原来的二维数组数
     3)	整体思路分析
 
-     ![img](../../../../../doc/java/datastructure/fenxi.jpg) |
+     ![img](img/fenxi.jpg) |
 
 - 代码 实战
 

note/java/datastructureAlgorithm/book/datastructure/Stack.md → note/datastructureAlgorithm/book/datastructure/Stack.md

@@ -12,7 +12,7 @@ LIFO）的原则⎯⎯也就是说，对象可以任意插入栈中，但每次
 比如一摞椅子（如图二.1 所示），只能将最顶端的椅子移出，也只能将新椅子放到最顶端⎯⎯这两
 种操作分别称作入栈（Push）和退栈（Pop）。
 
-![由椅子构成的栈](../../../../../doc/java/datastructure/stack/yizi.jpg)
+![由椅子构成的栈](img/stack/yizi.jpg)
 由椅子构成的栈
 
 栈是最基本的数据结构之一，在实际应用中几乎无所不在。例如，网络浏览器会将用户最近访
@@ -25,15 +25,15 @@ LIFO）的原则⎯⎯也就是说，对象可以任意插入栈中，但每次
 
 作为一种抽象数据类型，栈必须支持以下方法：
 
-![adt01](../../../../../doc/java/datastructure/stack/adt01.png)
+![adt01](img/stack/adt01.png)
 
 此外，还可以定义如下的方法：
 
-![adt02](../../../../../doc/java/datastructure/stack/adt02.png)
+![adt02](img/stack/adt02.png)
 
 给出了从一个空栈开始，在依次执行一系列操作的过程中，栈中内容的相应变化
 
-![adt03](../../../../../doc/java/datastructure/stack/adt03.png)
+![adt03](img/stack/adt03.png)
 
 ### Stack
 由于其重要性，在Java 的java.util 包中已经专门为栈结构内建了一个类⎯⎯java.util.Stack。
@@ -93,7 +93,7 @@ public interface Stack<E> {
 - 思路
 为了实现栈接口，我们可以用一个数组来存放其中的元素。具体来说，就是使用一个容量为N的数组S，再加上一个变量top 来只是当前栈顶的位置。
 
-![arrayStack](../../../../../doc/java/datastructure/stack/arrayStack.png)
+![arrayStack](img/stack/arrayStack.png)
 
 由于Java数组的元素都是从0 开始编号，所以top必须初始化为-1；反过来，只要top = -1，就
 说明栈为空。另一方面，由于数组的容量固定，因此有可能会出现栈溢出的情况。为此，我们专门
@@ -220,7 +220,7 @@ JVM 还会通过Java 栈将参数传递给被调用的方法。具体来说，Ja
 果将x 作为参数传递给方法N，实际上传递的是对象o 的内存地址。这个地址被复制给N 的某个局
 部变量y 之后，y 也将和x 一样地指向对象o。
 
-![java_stack](../../../../../doc/java/datastructure/stack/java_stack.png)
+![java_stack](img/stack/java_stack.png)
 
 java方法栈的实例：方法main调用方法N，方法N再调用方法M
 

note/java/datastructureAlgorithm/book/datastructure/Tree.md → note/datastructureAlgorithm/book/datastructure/Tree.md

@@ -21,7 +21,7 @@
 ### 树ADT 
 树抽象类型要支持以下的基本方法：
 
-![tree ADT](../../../../../doc/java/datastructure/tree/tree01.png)
+![tree ADT](img/tree/tree01.png)
 
 不同的应用问题会要求树结构提供不同方法。这方面的差异太大，我
 们无法在树 ADT 中定义出通用的更新操作。在后续章节的讨论中，我们将结合各种应用问题，陆续
@@ -221,7 +221,7 @@ public class TreeLinkedList<E> implements Tree<E> {
  }
 } 
 ```
-![tree PreorderTraversal](../../../../../doc/java/datastructure/tree/tree02.png)
+![tree PreorderTraversal](img/tree/tree02.png)
 
 对称地，对任一（子）树的后序遍历将首先递归地对根节点下的各棵子树进行后序遍历，最后
 才访问根节点。由后序遍历生成的节点序列，称作后序遍历序列。
@@ -240,7 +240,7 @@ public class TreeLinkedList<E> implements Tree<E> {
  }
 } 
 ```
-![tree PostorderTraversal](../../../../../doc/java/datastructure/tree/tree03.png)
+![tree PostorderTraversal](img/tree/tree03.png)
 
 #### 层次遍历
 
@@ -270,7 +270,7 @@ public class TreeLinkedList<E> implements Tree<E> {
 } 
 ```
 
-![tree LevelorderTraversal](../../../../../doc/java/datastructure/tree/tree04.png)
+![tree LevelorderTraversal](img/tree/tree04.png)
 
 #### 树迭代器
 ```java
@@ -356,7 +356,7 @@ public class IteratorTree<E> implements Iterator<E> {
 
 二叉树抽象类型需要支持以下的基本方法：
 
-![二叉树ADT ](../../../../../doc/java/datastructure/tree/tree05.png)
+![二叉树ADT ](img/tree/tree05.png)
 
 与普通的树一样，不同的应用问题可能会在上述操作之外要求二叉树结构提供更多的方法。这
 些操作多属更新类操作，而且具体功能差异极大。在此，我们只能在二叉树 ADT 中定义相对通用的
@@ -965,7 +965,7 @@ O(1)时间内返回相应的变量，即可实现相应的功能。
 前节点及其祖先的规模记录，以便后续的查询，`updateSize()`方法的功能正在于此。请注意，在这里，
 我们允许直接对任何节点执行这一操作。
 
-![updateSize](../../../../../doc/java/datastructure/tree/tree06.png)
+![updateSize](img/tree/tree06.png)
 
 > 若节点 v 的左、右孩子分别为 lc 和 rc，则 size(v) = 1 + size(lc) + size(rc)
 

note/java/datastructureAlgorithm/book/datastructure/VectorOrArrayList.md → note/datastructureAlgorithm/book/datastructure/VectorOrArrayList.md

@@ -17,7 +17,7 @@
 ### 向量ADT
 向量 ADT 定义了如下方法:
 
-![vector01](../../../../../doc/java/datastructure/vector/vector01.png)
+![vector01](img/vector/vector01.png)
 
 请注意其中的 insertAtRank()方法，该方法之所以要返回被插入的元素，是为了使程序员可以链式编程。
 
@@ -26,8 +26,8 @@
 现，就可以通过广义的“下标”直接访问序列中对应的元素。如 表三.2 所示，随着序列的更新，其
 中元素的秩也会不断变化。
 
-![vector02](../../../../../doc/java/datastructure/vector/vector02.png)
-![vector03](../../../../../doc/java/datastructure/vector/vector03.png)
+![vector02](img/vector/vector02.png)
+![vector03](img/vector/vector03.png)
 
 - 意外错
 当作为参数的秩越界时，对应的意外错为ExceptionBoundaryViolation
@@ -94,7 +94,7 @@ public interface Vector<E> {
 向量提供的以上方法似乎不多，但如图 所示，通过这些方法，完全可以实现之前定
 义的双端队列ADT中的所有方法。
 
-![vector04](../../../../../doc/java/datastructure/vector/vector04.png)
+![vector04](img/vector/vector04.png)
 
 ### 基于数组的简单实现
 基于数组，可以直接实现向量 ADT。我们借用一个数组 A[]，其中 A[i]分别存放一个引用，指向
@@ -196,7 +196,7 @@ insertAtRank()方法就会做如下处理：
 大时，就会蜕去原来的外壳，换上一身更大的外壳。具体过程如图所示。不必担心原先的数组，
 它占用的空间将被内存回收器自动回收   
 
-![vector05](../../../../../doc/java/datastructure/vector/vector05.png) 
+![vector05](img/vector/vector05.png) 
 
 ```java
 public class ExtArrayVector<E> implements Vector<E>{