update images

Author: dunwu

docs/algorithm/sort.md

@@ -66,7 +66,7 @@
 
 假设有一个大小为 N 的无序序列。冒泡排序就是要每趟排序过程中通过两两比较，找到第 i 个小（大）的元素，将其往上排。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/bubble-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/bubble-sort.png!zp"/></div>
 
 以上图为例，演示一下冒泡排序的实际流程：
 
@@ -209,7 +209,7 @@ public void bubbleSort_2(int[] list) {
 
 详细的图解往往比大堆的文字更有说明力，所以直接上图：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/quick-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/quick-sort.png!zp"/></div>
 
 上图中，演示了快速排序的处理过程：
 
@@ -314,7 +314,7 @@ private void quickSort(int[] list, int left, int right) {
 
 在讲解直接插入排序之前，先让我们脑补一下我们打牌的过程。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/insert-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/insert-sort.png!zp"/></div>
 
 - 先拿一张 5 在手里，
 - 再摸到一张 4，比 5 小，插到 5 前面，
@@ -414,7 +414,7 @@ public void insertSort(int[] list) {
 
 我们来通过演示图，更深入的理解一下这个过程。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/shell-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/shell-sort.png!zp"/></div>
 
 在上面这幅图中：
 
@@ -520,7 +520,7 @@ Donald Shell 最初建议步长选择为 N/2 并且对步长取半直到步长
 
 **核心代码**
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/selection-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/selection-sort.png!zp"/></div>
 
 ### 算法分析
 
@@ -574,7 +574,7 @@ Donald Shell 最初建议步长选择为 N/2 并且对步长取半直到步长
 
 其中 i=1,2,…,n/2 向下取整;
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/heap-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/heap-sort.png!zp"/></div>
 
 如上图所示，序列 R{3, 8,15, 31, 25} 是一个典型的小根堆。
 
@@ -608,13 +608,13 @@ Donald Shell 最初建议步长选择为 N/2 并且对步长取半直到步长
 
 设有一个无序序列 { 1, 3,4, 5, 2, 6, 9, 7, 8, 0 }。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/heap-sort-02.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/heap-sort-02.png!zp"/></div>
 
 构造了初始堆后，我们来看一下完整的堆排序处理：
 
 还是针对前面提到的无序序列 { 1,3, 4, 5, 2, 6, 9, 7, 8, 0 } 来加以说明。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/heap-sort-03.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/heap-sort-03.png!zp"/></div>
 
 相信，通过以上两幅图，应该能很直观的演示堆排序的操作处理。
 
@@ -783,7 +783,7 @@ public void Merge(int[] array, int low, int mid, int high) {
 
 掌握了合并的方法，接下来，让我们来了解**如何分解**。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/merge-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/merge-sort.png!zp"/></div>
 
 在某趟归并中，设各子表的长度为 **gap**，则归并前 R[0...n-1] 中共有 **n/gap** 个有序的子表：`R[0...gap-1]`, `R[gap...2*gap-1]`, ... , `R[(n/gap)*gap ... n-1]`。
 
@@ -877,7 +877,7 @@ public int[] sort(int[] list) {
 
 我们先根据序列的个位数的数字来进行分类，将其分到指定的桶中。例如：R[0] = 50，个位数上是 0，将这个数存入编号为 0 的桶中。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/algorithm/sort/radix-sort.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/algorithm/sort/radix-sort.png!zp"/></div>
 
 分类后，我们在从各个桶中，将这些数按照从编号 0 到编号 9 的顺序依次将所有数取出来。
 

docs/coverpage.md

@@ -1,4 +1,4 @@
-<div align="center"><img width="100px" src="http://dunwu.test.upcdn.net/images/others/zp.png"/></div>
+<div align="center"><img width="100px" src="http://dunwu.test.upcdn.net/cs/others/zp.png"/></div>
 
 # Algorithm Tutorial
 

docs/data-structure/array.md

@@ -26,7 +26,7 @@
 
 这里有一个例子：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/array/一维数组.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/array/一维数组.png!zp"/></div>
 
 在上面的例子中，数组 A 中有 6 个元素。也就是说，A 的长度是 6 。我们可以使用 A[0] 来表示数组中的第一个元素。因此，A[0] = 6 。类似地，A[1] = 3，A[2] = 8，依此类推。
 
@@ -42,15 +42,15 @@
 
 下图显示了*大小为 M \* N 的数组 A* 的实际结构：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/array/C++二维数组.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/array/C++二维数组.png!zp"/></div>
 
 因此，如果我们将 A 定义为也包含 _M \* N_ 个元素的一维数组，那么实际上 A[i][j] 就等于 A[i * N + j]。
 
 **2. 在 Java 中，二维数组实际上是包含着 M 个元素的一维数组，每个元素都是包含有 N 个整数的数组。**
 
 下图显示了 Java 中二维数组 A 的实际结构：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/array/JAVA二维数组.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/array/JAVA二维数组.png!zp"/></div>
 
 二维数组示例：
 

docs/data-structure/graph.md

@@ -2,7 +2,7 @@
 
 在计算机科学中，一个图就是一些*顶点*的集合，这些顶点通过一系列*边*结对（连接）。顶点用圆圈表示，边就是这些圆圈之间的连线。顶点之间通过边连接。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/graph/graph.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/graph/graph.png!zp"/></div>
 
 ## 术语
 

docs/data-structure/hash.md

@@ -36,7 +36,7 @@
 
 ### 哈希函数示例
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/hash/哈希函数.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/hash/哈希函数.png!zp"/></div>
 
 在示例中，我们使用 y = x ％ 5 作为哈希函数。让我们使用这个例子来完成插入和搜索策略：
 
@@ -56,7 +56,7 @@
 
 下面是一些哈希函数的示例：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/hash/哈希函数示例.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/hash/哈希函数示例.png!zp"/></div>
 
 哈希函数的设计是一个开放的问题。其思想是尽可能将键分配到桶中，理想情况下，完美的哈希函数将是键和桶之间的一对一映射。然而，在大多数情况下，哈希函数并不完美，它需要在桶的数量和桶的容量之间进行权衡。
 

docs/data-structure/heap.md

@@ -2,7 +2,7 @@
 
 堆是一种特殊的基于树的满足某些特性的数据结构，整个堆中的所有父子节点的键值都会满足相同的排序条件。堆更准确地可以分为最大堆与最小堆，在最大堆中，父节点的键值永远大于或者等于子节点的值，并且整个堆中的最大值存储于根节点；而最小堆中，父节点的键值永远小于或者等于其子节点的键值，并且整个堆中的最小值存储于根节点。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/heap/heap.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/heap/heap.png!zp"/></div>
 
 时间复杂度:
 

docs/data-structure/list.md

@@ -6,7 +6,7 @@
 
 下面是一个单链表的例子：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/list/单链表.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/list/单链表.png!zp"/></div>
 
 蓝色箭头显示单个链接列表中的结点是如何组合在一起的。
 
@@ -18,6 +18,6 @@
 
 让我们看一个例子：
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/list/双链表.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/list/双链表.png!zp"/></div>
 
 绿色箭头表示我们的“prev”字段是如何工作的。

docs/data-structure/stack.md

@@ -4,7 +4,7 @@
 >
 > 由于堆栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/stack/stack.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/stack/stack.png!zp"/></div>
 
 <!-- TOC depthFrom:2 depthTo:2 -->
 

docs/data-structure/tree/binary-tree.md

@@ -1,6 +1,6 @@
 # 二叉树
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/tree/二叉树.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/tree/二叉树.png!zp"/></div>
 
 <!-- TOC depthFrom:2 depthTo:3 -->
 
@@ -26,12 +26,12 @@
 
 定义：高度为 h，并且由 **2<sup>h</sup>–1** 个结点的二叉树，被称为满二叉树。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/tree/满二叉树.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/tree/满二叉树.png!zp"/></div>
 
 ### 完全二叉树
 
 定义：一棵二叉树中，只有最下面两层结点的度可以小于 2，并且最下一层的叶结点集中在靠左的若干位置上。这样的二叉树称为完全二叉树。
 
 特点：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。显然，一棵满二叉树必定是一棵完全二叉树，而完全二叉树未必是满二叉树。
 
-<div align="center"><img src="http://dunwu.test.upcdn.net/images/data-structure/tree/完全二叉树.png!zp"/></div>
+<div align="center"><img src="http://dunwu.test.upcdn.net/cs/data-structure/tree/完全二叉树.png!zp"/></div>

docs/data-structure/tree/red-black-tree.md

@@ -19,7 +19,7 @@
 5.  从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-01.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-01.png" />
 </div>
 
 这五个性质强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。为什么呢？性质 4 暗示着任何一个简单路径上不能有两个毗连的红色节点，这样，最短的可能路径全是黑色节点，最长的可能路径有交替的红色和黑色节点。同时根据性质 5 知道：所有最长的路径都有相同数目的黑色节点，这就表明了没有路径能多于任何其他路径的两倍长。
@@ -49,7 +49,7 @@
   3.1. 如果父节点 P 和叔父节点 U 二者都是红色
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-insert-01.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-insert-01.png" />
 </div>
 
 如上图所示，我们将 P 和 U 重绘为黑色，并重绘节点 G 为红色(用来保持性质 5)。
@@ -61,15 +61,15 @@
 3.2. 父节点 P 是红色而叔父节点 U 是黑色或缺少，新节点 N 是右孩子节点，而父节点 P 又是其父节点 G 的左孩子节点。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-insert-02.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-insert-02.png" />
 </div>
 
 在这种情形下，我们进行一次左旋转调换新节点和其父节点的角色；接着，我们按情形 3.3 处理以前的父节点 P 以解决仍然失效的性质 4。注意这个改变会导致某些路径通过它们以前不通过的新节点 N（比如图中 1 号叶子节点）或不通过节点 P（比如图中 3 号叶子节点），但由于这两个节点都是红色的，所以性质 5 仍有效。
 
 3.3. 父节点 P 是红色而叔父节点 U 是黑色或缺少，新节点 N 是左孩子节点，而父节点 P 又是其父节点 G 的左孩子节点。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-insert-03.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-insert-03.png" />
 </div>
 
 在这种情形下，我们进行针对祖父节点 G 的一次右旋转；在旋转产生的树中，以前的父节点 P 现在是新节点 N 和以前的祖父节点 G 的父节点。我们知道以前的祖父节点 G 是黑色，否则父节点 P 就不可能是红色（如果 P 和 G 都是红色就违反了性质 4，所以 G 必须是黑色）。我们切换以前的父节点 P 和祖父节点 G 的颜色，结果的树满足性质 4。性质 5 也仍然保持满足，因为通过这三个节点中任何一个的所有路径以前都通过祖父节点 G，现在它们都通过以前的父节点 P。在各自的情形下，这都是三个节点中唯一的黑色节点。
@@ -101,31 +101,31 @@
 此时 P 肯定是红色的。我们对 N 的父节点进行左旋转，然后把红色兄弟转换成 N 的祖父。我们接着对调 N 的父亲和祖父的颜色。尽管所有的路径仍然有相同数目的黑色节点，现在 N 有了一个黑色的兄弟和一个红色的父亲，所以我们可以接下去按 (2)、(3)或(4)情况来处理。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-delete-01.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-delete-01.png" />
 </div>
 
 3.2 S和S的孩子全是黑色的
 
 在这种情况下，P 可能是黑色的或者红色的，我们简单的重绘 S 为红色。结果是通过 S 的所有路径，它们就是以前不通过 N 的那些路径，都少了一个黑色节点。因为删除 N 的初始的父亲使通过 N 的所有路径少了一个黑色节点，这使事情都平衡了起来。但是，通过 P 的所有路径现在比不通过 P 的路径少了一个黑色节点。接下来，要调整以 P 作为 N 递归调整树。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-delete-02.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-delete-02.png" />
 </div>
 
 3.3 S是黑色的，S的左孩子是红色，右孩子是黑色
 
 这种情况下我们在 S 上做右旋转，这样 S 的左儿子成为 S 的父亲和 N 的新兄弟。我们接着交换 S 和它的新父亲的颜色。所有路径仍有同样数目的黑色节点，但是现在 N 有了一个右儿子是红色的黑色兄弟，所以我们进入了情况（4）。N 和它的父亲都不受这个变换的影响。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-delete-03.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-delete-03.png" />
 </div>
 
 3.4 S是黑色的，S的右孩子是红色
 
 在这种情况下我们在 N 的父亲上做左旋转，这样 S 成为 N 的父亲和 S 的右儿子的父亲。我们接着交换 N 的父亲和 S 的颜色，并使 S 的右儿子为黑色。子树在它的根上的仍是同样的颜色，所以属性 3 没有被违反。但是，N 现在增加了一个黑色祖先: 要么 N 的父亲变成黑色，要么它是黑色而 S 被增加为一个黑色祖父。所以，通过 N 的路径都增加了一个黑色节点。
 
 <div align="center">
-<img src="http://dunwu.test.upcdn.net/images/algorithm/tree/red-black-tree-delete-04.png" />
+<img src="http://dunwu.test.upcdn.net/cs/algorithm/tree/red-black-tree-delete-04.png" />
 </div>
 
 ## 示例代码