[docs update]统一数据结构部分的手绘图片样式

Author: Snailclimb

docs/cs-basics/data-structure/bloom-filter.md

@@ -1,11 +1,10 @@
 ---
+title: 布隆过滤器
 category: 计算机基础
 tag:
   - 数据结构
 ---
 
-# 布隆过滤器
-
 海量数据处理以及缓存穿透这两个场景让我认识了 布隆过滤器 ，我查阅了一些资料来了解它，但是很多现成资料并不满足我的需求，所以就决定自己总结一篇关于布隆过滤器的文章。希望通过这篇文章让更多人了解布隆过滤器，并且会实际去使用它！
 
 下面我们将分为几个方面来介绍布隆过滤器：

docs/cs-basics/data-structure/graph.md

@@ -1,15 +1,10 @@
 ---
+title: 图
 category: 计算机基础
 tag:
   - 数据结构
 ---
 
-# 图
-
-> 开头还是求点赞，求转发！原创优质公众号，希望大家能让更多人看到我们的文章。
->
-> 图片都是我们手绘的，可以说非常用心了！
-
 图是一种较为复杂的非线性结构。 **为啥说其较为复杂呢？**
 
 根据前面的内容，我们知道：
@@ -23,7 +18,7 @@ tag:
 
 下图所展示的就是图这种数据结构，并且还是一张有向图。
 
-![](https://oscimg.oschina.net/oscnet/up-74c4ca0f71209f6f97201519ff85c23e274.png)
+![有向图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/directed-graph.png)
 
 图在我们日常生活中的例子很多！比如我们在社交软件上好友关系就可以用图来表示。
 
@@ -57,7 +52,7 @@ tag:
 
 下图就是一个带权有向图。
 
-![带权有向图](./pictures/图/带权有向图.png)
+![带权有向图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/weighted-directed-graph.png)
 
 ## 图的存储
 ### 邻接矩阵存储
@@ -67,11 +62,11 @@ tag:
 
 在无向图中，我们只关心关系的有无，所以当顶点i和顶点j有关系时，`A[i][j]`=1，当顶点i和顶点j没有关系时，`A[i][j]`=0。如下图所示：
 
-![无向图的邻接矩阵存储](./pictures/图/无向图的邻接矩阵存储.png)
+![无向图的邻接矩阵存储](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/adjacency-matrix-representation-of-undirected-graph.png)
 
 值得注意的是：**无向图的邻接矩阵是一个对称矩阵，因为在无向图中，顶点i和顶点j有关系，则顶点j和顶点i必有关系。**
 
-![有向图的邻接矩阵存储](./pictures/图/有向图的邻接矩阵存储.png)
+![有向图的邻接矩阵存储](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/adjacency-matrix-representation-of-directed-graph.png)
 
 邻接矩阵存储的方式优点是简单直接（直接使用一个二维数组即可），并且，在获取两个定点之间的关系的时候也非常高效（直接获取指定位置的数组元素的值即可）。但是，这种存储方式的缺点也比较明显，那就是比较浪费空间，
 
@@ -81,13 +76,9 @@ tag:
 
 邻接链表使用一个链表来存储某个顶点的所有后继相邻顶点。对于图中每个顶点Vi，把所有邻接于Vi的顶点Vj链成一个单链表，这个单链表称为顶点Vi的 **邻接表**。如下图所示：
 
+![无向图的邻接表存储](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/adjacency-list-representation-of-undirected-graph.png)
 
-
-![无向图的邻接表存储](./pictures/图/无向图的邻接表存储.png)
-
-
-
-![有向图的邻接表存储](./pictures/图/有向图的邻接表存储.png)
+![有向图的邻接表存储](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/adjacency-list-representation-of-directed-graph.png)
 
 大家可以数一数邻接表中所存储的元素的个数以及图中边的条数，你会发现：
 
@@ -98,64 +89,64 @@ tag:
 ### 广度优先搜索
 广度优先搜索就像水面上的波纹一样一层一层向外扩展，如下图所示：
 
-![广度优先搜索图示](./pictures/图/广度优先搜索图示.png)
+![广度优先搜索图示](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search.png)
 
 **广度优先搜索的具体实现方式用到了之前所学过的线性数据结构——队列** 。具体过程如下图所示：
 
 **第1步：**
 
-![广度优先搜索1](./pictures/图/广度优先搜索1.png)
+![广度优先搜索1](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search1.png)
 
 **第2步：**
 
-![广度优先搜索2](./pictures/图/广度优先搜索2.png)
+![广度优先搜索2](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search2.png)
 
 **第3步：**
 
-![广度优先搜索3](./pictures/图/广度优先搜索3.png)
+![广度优先搜索3](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search3.png)
 
 **第4步：**
 
-![广度优先搜索4](./pictures/图/广度优先搜索4.png)
+![广度优先搜索4](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search4.png)
 
 **第5步：**
 
-![广度优先搜索5](./pictures/图/广度优先搜索5.png)
+![广度优先搜索5](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search5.png)
 
 **第6步：**
 
-![广度优先搜索6](./pictures/图/广度优先搜索6.png)
+![广度优先搜索6](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/breadth-first-search6.png)
 
 ### 深度优先搜索
 
 深度优先搜索就是“一条路走到黑”，从源顶点开始，一直走到没有后继节点，才回溯到上一顶点，然后继续“一条路走到黑”，如下图所示：
 
-![深度优先搜索图示](./pictures/图/深度优先搜索图示.png)
+![深度优先搜索图示](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search.png)
 
 
 **和广度优先搜索类似，深度优先搜索的具体实现用到了另一种线性数据结构——栈** 。具体过程如下图所示：
 
 **第1步：**
 
-![深度优先搜索1](./pictures/图/深度优先搜索1.png)
+![深度优先搜索1](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search1.png)
 
 **第2步：**
 
-![深度优先搜索1](./pictures/图/深度优先搜索2.png)
+![深度优先搜索2](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search2.png)
 
 **第3步：**
 
-![深度优先搜索1](./pictures/图/深度优先搜索3.png)
+![深度优先搜索3](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search3.png)
 
 **第4步：**
 
-![深度优先搜索1](./pictures/图/深度优先搜索4.png)
+![深度优先搜索4](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search4.png)
 
 **第5步：**
 
-![深度优先搜索1](./pictures/图/深度优先搜索5.png)
+![深度优先搜索5](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search5.png)
 
 **第6步：**
 
-![深度优先搜索1](./pictures/图/深度优先搜索6.png)
+![深度优先搜索6](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search6.png)
 

docs/cs-basics/data-structure/linear-data-structure.md

@@ -1,15 +1,10 @@
 ---
+title: 线性数据结构
 category: 计算机基础
 tag:
   - 数据结构
 ---
 
-# 线性数据结构 :数组、链表、栈、队列
-
-> 开头还是求点赞，求转发！原创优质公众号，希望大家能让更多人看到我们的文章。
->
-> 图片都是我们手绘的，可以说非常用心了！
-
 ## 1. 数组
 
 **数组（Array）** 是一种很常见的数据结构。它由相同类型的元素（element）组成，并且是使用一块连续的内存来存储。
@@ -25,7 +20,7 @@ tag:
 删除：O（n）//最坏的情况发生在删除数组的开头发生并需要移动第一元素后面所有的元素时
 ```
 
-![数组](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/数组.png)
+![数组](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/array.png)
 
 ## 2. 链表
 
@@ -56,25 +51,25 @@ tag:
 
 **单链表** 单向链表只有一个方向，结点只有一个后继指针 next 指向后面的节点。因此，链表这种数据结构通常在物理内存上是不连续的。我们习惯性地把第一个结点叫作头结点，链表通常有一个不保存任何值的 head 节点(头结点)，通过头结点我们可以遍历整个链表。尾结点通常指向 null。
 
-![单链表](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/单链表2.png)
+![单链表](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/single-linkedlist.png)
 
 #### 2.2.2. 循环链表
 
 **循环链表** 其实是一种特殊的单链表，和单链表不同的是循环链表的尾结点不是指向 null，而是指向链表的头结点。
 
-![循环链表](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/循环链表2.png)
+![循环链表](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/circular-linkedlist.png)
 
 #### 2.2.3. 双向链表
 
 **双向链表** 包含两个指针，一个 prev 指向前一个节点，一个 next 指向后一个节点。
 
-![双向链表](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/双向链表.png)
+![双向链表](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/bidirectional-linkedlist.png)
 
 #### 2.2.4. 双向循环链表
 
 **双向循环链表** 最后一个节点的 next 指向 head，而 head 的 prev 指向最后一个节点，构成一个环。
 
-![双向循环链表](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/双向循环链表.png)
+![双向循环链表](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/bidirectional-circular-linkedlist.png)
 
 ### 2.3. 应用场景
 
@@ -92,7 +87,7 @@ tag:
 
 ### 3.1. 栈简介
 
-**栈** (stack)只允许在有序的线性数据集合的一端（称为栈顶 top）进行加入数据（push）和移除数据（pop）。因而按照 **后进先出（LIFO, Last In First Out）** 的原理运作。**在栈中，push 和 pop 的操作都发生在栈顶。**
+**栈 (Stack)** 只允许在有序的线性数据集合的一端（称为栈顶 top）进行加入数据（push）和移除数据（pop）。因而按照 **后进先出（LIFO, Last In First Out）** 的原理运作。**在栈中，push 和 pop 的操作都发生在栈顶。**
 
 栈常用一维数组或链表来实现，用数组实现的栈叫作 **顺序栈** ，用链表实现的栈叫作 **链式栈** 。
 
@@ -263,7 +258,7 @@ myStack.pop();//报错：java.lang.IllegalArgumentException: Stack is empty.
 
 ### 4.1. 队列简介
 
-**队列** 是 **先进先出( FIFO，First In, First Out)** 的线性表。在具体应用中通常用链表或者数组来实现，用数组实现的队列叫作 **顺序队列** ，用链表实现的队列叫作 **链式队列** 。**队列只允许在后端（rear）进行插入操作也就是 入队 enqueue，在前端（front）进行删除操作也就是出队 dequeue**
+**队列（Queue）** 是 **先进先出( FIFO，First In, First Out)** 的线性表。在具体应用中通常用链表或者数组来实现，用数组实现的队列叫作 **顺序队列** ，用链表实现的队列叫作 **链式队列** 。**队列只允许在后端（rear）进行插入操作也就是 入队 enqueue，在前端（front）进行删除操作也就是出队 dequeue**
 
 队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。
 
@@ -273,7 +268,7 @@ myStack.pop();//报错：java.lang.IllegalArgumentException: Stack is empty.
 插入删除：O（1）//后端插入前端删除元素
 ```
 
-![队列](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/队列.png)
+![队列](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/queue.png)
 
 ### 4.2. 队列分类
 
@@ -287,23 +282,21 @@ myStack.pop();//报错：java.lang.IllegalArgumentException: Stack is empty.
 
 > 为了避免当只有一个元素的时候，队头和队尾重合使处理变得麻烦，所以引入两个指针，front 指针指向对头元素，rear 指针指向队列最后一个元素的下一个位置，这样当 front 等于 rear 时，此队列不是还剩一个元素，而是空队列。——From 《大话数据结构》
 
-![顺序队列假溢出](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/顺序队列假溢出1.png)
+![顺序队列假溢出](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/seq-queue-false-overflow.png)
 
 #### 4.2.2. 循环队列
 
 循环队列可以解决顺序队列的假溢出和越界问题。解决办法就是：从头开始，这样也就会形成头尾相接的循环，这也就是循环队列名字的由来。
 
 还是用上面的图，我们将 rear 指针指向数组下标为 0 的位置就不会有越界问题了。当我们再向队列中添加元素的时候， rear 向后移动。
 
-![循环队列](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/循环队列.png)
+![循环队列](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/circular-queue.png)
 
 顺序队列中，我们说 `front==rear` 的时候队列为空，循环队列中则不一样，也可能为满，如上图所示。解决办法有两种：
 
 1. 可以设置一个标志变量 `flag`,当 `front==rear` 并且 `flag=0` 的时候队列为空，当`front==rear` 并且 `flag=1` 的时候队列为满。
 2. 队列为空的时候就是 `front==rear` ，队列满的时候，我们保证数组还有一个空闲的位置，rear 就指向这个空闲位置，如下图所示，那么现在判断队列是否为满的条件就是： `(rear+1) % QueueSize= front` 。
 
-![循环队列-队满](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-6/循环队列-堆满.png)
-
 ### 4.3. 常见应用场景
 
 当我们需要按照一定顺序来处理数据的时候可以考虑使用队列这个数据结构。