remove workaround for multilingual shared-files since gitbook 3.0

LANGS.md

@@ -1,4 +1,3 @@
 * [English](en/)
 * [繁體中文](zh-tw/)
 * [简体中文](zh-hans/)
-* [Shared Files](shared-files/)

zh-hans/basics_data_structure/binary_tree.md

@@ -60,7 +60,7 @@ public class TreeNode {
 
 如果已知中序遍历和前序遍历或者后序遍历，那么就可以完全恢复出原二叉树结构。其中最为关键的是前序遍历中第一个一定是根，而后序遍历最后一个一定是根，中序遍历在得知根节点后又可进一步递归得知左右子树的根节点。但是这种方法也是有适用范围的：元素不能重复！否则无法完成定位。
 
-![Binary Tree Traversal](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/binary_tree_traversal.png)
+![Binary Tree Traversal](../../shared-files/images/binary_tree_traversal.png)
 
 ### Python
 

zh-hans/basics_data_structure/heap.md

@@ -21,7 +21,7 @@
 
 其中步骤1是给步骤2和3用的。
 
-![Heapsort-example](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/Heapsort-example.gif)
+![Heapsort-example](../../shared-files/images/Heapsort-example.gif)
 
 ## Python
 

zh-hans/basics_data_structure/huffman_compression.md

@@ -13,7 +13,7 @@
 
 则对各符号进行霍夫曼编码的动态演示如下图所示。基本步骤是将出现频率由小到大排列，组成子树后频率相加作为整体再和其他未加入二叉树中的节点频率比较。加权路径长为节点的频率乘以树的深度。
 
-![Huffman](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/huffman_algorithm.gif)
+![Huffman](../../shared-files/images/huffman_algorithm.gif)
 
 
 ### Python 实现

zh-hans/basics_sorting/bubble_sort.md

@@ -2,7 +2,7 @@
 
 核心：**冒泡**，持续比较相邻元素，大的挪到后面，因此大的会逐步往后挪，故称之为冒泡。
 
-![Bubble Sort](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/bubble_sort.gif)
+![Bubble Sort](../../shared-files/images/bubble_sort.gif)
 
 ## Implementation
 

zh-hans/basics_sorting/heap_sort.md

@@ -12,7 +12,7 @@
 
 其中步骤1是给步骤2和3用的。
 
-![Heapsort-example](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/Heapsort-example.gif)
+![Heapsort-example](../../shared-files/images/Heapsort-example.gif)
 
 建堆时可以自顶向下，也可以采取自底向上，以下先采用自底向上的思路分析。我们可以将数组的后半部分节点想象为堆的最下面的那些节点，由于是单个节点，故显然满足二叉堆的定义，于是乎我们就可以从中间节点向上逐步构建二叉堆，每前进一步都保证其后的节点都是二叉堆，这样一来前进到第一个节点时整个数组就是一个二叉堆了。下面用 C++/Java 实现一个堆的类。C++/Java 中推荐使用 PriorityQueue 来使用堆。
 

zh-hans/basics_sorting/insertion_sort.md

@@ -18,7 +18,7 @@
 - 最坏情况下需要~N^2/2次比较和~N^2/2次交换，最好情况下需要N-1次比较和0次交换。
 - 平均情况下需要~N^2/4次比较和~N^2/4次交换
 
-![Insertion Sort](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/insertion_sort.gif)
+![Insertion Sort](../../shared-files/images/insertion_sort.gif)
 
 
 ## Implementation

zh-hans/basics_sorting/merge_sort.md

@@ -4,7 +4,7 @@
 
 先来看看动图，归并排序是一种典型的分治应用。
 
-![Merge Sort](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/merge_sort.gif)
+![Merge Sort](../../shared-files/images/merge_sort.gif)
 
 ### Python
 

zh-hans/basics_sorting/quick_sort.md

@@ -60,15 +60,15 @@ $$\sum _{i=0} ^{} \frac {n}{2^i} = 2n$$
 
 $$\sum_{i=0}^n (n-i+1) = O(n^2)$$
 
-![Quicksort Recursive](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/qsort1.png)
+![Quicksort Recursive](../../shared-files/images/qsort1.png)
 
 ## in-place - 原地快排
 
 ### one index for partition
 
 先来看一种简单的 in-place 实现，仍然以`[6, 5, 3, 1, 8, 7, 2, 4]`为例，结合下图进行分析。以下标 $$l$$ 和 $$u$$ 表示数组待排序部分的下界(lower bound)和上界(upper bound)，下标 $$m$$ 表示遍历到数组第 $$i$$ 个元素时当前 partition 的索引，基准元素为 $$t$$, 即图中的 target.
 
-![Quick Sort one index for partition](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/qsort2.png)
+![Quick Sort one index for partition](../../shared-files/images/qsort2.png)
 
 在遍历到第 $$i$$ 个元素时，$$x[i]$$ 有两种可能，第一种是 $$x[i] \geq t$$, $$i$$ 自增往后遍历；第二种是 $$x[i] < t$$, 此时需要将 $$x[i]$$ 置于前半部分，比较简单的实现为 `swap(x[++m], x[i])`. 直至 `i == u` 时划分阶段结束，分两截递归进行快排。既然说到递归，就不得不提递归的终止条件，容易想到递归的终止步为 `l >= u`, 即索引相等或者交叉时退出。使用 Python 的实现如下所示：
 
@@ -164,7 +164,7 @@ public class Sort {
 
 先来一张动图看看使用两个索引进行 partition 的过程。
 
-![Quick Sort two index for partition](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/qsort3.gif)
+![Quick Sort two index for partition](../../shared-files/images/qsort3.gif)
 
 1. 选中`3`作为基准
 2. `lo`指针指向元素`6`, `hi`指针指向`4`, 移动`lo`直至其指向的元素大于等于`3`, 移动`hi`直至其指向的元素小于`3`。找到后交换`lo`和`hi`指向的元素——交换元素`6`和`2`。
@@ -293,5 +293,5 @@ Robert Sedgewick 在其网站上对 [Quicksort](http://algs4.cs.princeton.edu/23
 - [快速排序 - 维基百科，自由的百科全书](http://zh.wikipedia.org/wiki/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F)
 - [Quicksort |  Robert Sedgewick](http://algs4.cs.princeton.edu/23quicksort/)
 - Programming Pearls Column 11 Sorting - 深入探讨了插入排序和快速排序
-- [Quicksort Analysis](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/docs/quicksort_analysis.pdf)
+- [Quicksort Analysis](../../shared-files/docs/quicksort_analysis.pdf)
 - [^programming_pearls]: Programming Pearls(第二版修订版) 一书中第11章排序中注明需要 $$n\log2n$$ 次比较，翻译有误？

zh-hans/basics_sorting/selection_sort.md

@@ -14,7 +14,7 @@
 
 下图来源为 [File:Selection-Sort-Animation.gif - IB Computer Science](http://wiki.ibcsstudent.org/index.php?title=File:Selection-Sort-Animation.gif)
 
-![Selection Sort](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/selection_sort.gif)
+![Selection Sort](../../shared-files/images/selection_sort.gif)
 
 ## Implementation
 

zh-hans/binary_search/find_minimum_in_rotated_sorted_array.md

@@ -26,7 +26,7 @@ You may assume no duplicate exists in the array.
 
 如前节所述，对于旋转数组的分析可使用画图的方法，如下图所示，升序数组经旋转后可能为如下两种形式。
 
-![Rotated Array](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/rotated_array.png)
+![Rotated Array](../../shared-files/images/rotated_array.png)
 
 最小值可能在上图中的两种位置出现，如果仍然使用数组首部元素作为target去比较，则需要考虑图中右侧情况。**使用逆向思维分析，如果使用数组尾部元素分析，则无需图中右侧的特殊情况。**不过考虑在内的话也算是一种优化。
 

zh-hans/binary_search/search_in_rotated_sorted_array.md

@@ -30,7 +30,7 @@ O(logN) time
 
 对于旋转数组的分析可使用画图的方法，如下图所示，升序数组经旋转后可能为如下两种形式。
 
-![Rotated Array](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/rotated_array.png)
+![Rotated Array](../../shared-files/images/rotated_array.png)
 
 对于有序数组，使用二分搜索比较方便。分析题中的数组特点，旋转后初看是乱序数组，但仔细一看其实里面是存在两段有序数组的。刚开始做这道题时可能会去比较`target`和`A[mid]`, 但分析起来异常复杂。**该题较为巧妙的地方在于如何找出旋转数组中的局部有序数组，并使用二分搜索解之。**结合实际数组在纸上分析较为方便。
 

zh-hans/binary_tree/README.md

@@ -7,5 +7,5 @@ Maximum Depth of Binary Tree# Binary Tree - 二叉树
 
 下图是把本章中所有出现的题目归类总结了一下，便于记忆
 
-![二叉树](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/images/binary_tree_summary.png)
+![二叉树](../images/binary_tree_summary.png)
 

zh-hans/binary_tree/diameter_of_a_binary_tree.md

@@ -13,7 +13,7 @@ the leaves that form the ends of a longest path are shaded
 but no path longer than nine nodes).
 ```
 
-![Diameter of a Binary Tree](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/tree_diameter.gif)
+![Diameter of a Binary Tree](../../shared-files/images/tree_diameter.gif)
 
 ## 题解
 

zh-hans/exhaustive_search/README.md

@@ -31,7 +31,7 @@ BFS 从某个状态开始，搜索**所有可以到达的状态**，转移顺序
 ## Reference
 
 - 《挑战程序设计竞赛》Chaper 2.1 p26 最基础的“穷竭搜索”
-- [Steven Skiena: Lecture15 - Backtracking](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/docs/lecture15-backtracking.pdf)
+- [Steven Skiena: Lecture15 - Backtracking](../../shared-files/docs/lecture15-backtracking.pdf)
 - [全面解析回溯法：算法框架与问题求解 - 五岳 - 博客园](http://www.cnblogs.com/wuyuegb2312/p/3273337.html)
 - [五大常用算法之四：回溯法 - 红脸书生 - 博客园](http://www.cnblogs.com/steven_oyj/archive/2010/05/22/1741376.html)
 - [演算法筆記 - Backtracking](http://www.csie.ntnu.edu.tw/~u91029/Backtracking.html)

zh-hans/exhaustive_search/permutations.md

@@ -506,7 +506,7 @@ class Solution {
 
 ## Reference
 
-- [Permutation Generation](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/docs/permutation_generation.pdf) - Robert Sedgewick 的大作，总结了诸多 Permutation 的产生方法。
+- [Permutation Generation](../../shared-files/docs/permutation_generation.pdf) - Robert Sedgewick 的大作，总结了诸多 Permutation 的产生方法。
 - [Next lexicographical permutation algorithm](http://www.nayuki.io/page/next-lexicographical-permutation-algorithm) - 此题非递归方法更为详细的解释。
 - [Permutation - Wikipedia, the free encyclopedia](https://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographic_order) - 字典序实现。
 - [Programming Interview Questions 11: All Permutations of String | Arden DertatArden Dertat](http://www.ardendertat.com/2011/10/28/programming-interview-questions-11-all-permutations-of-string/)

zh-hans/exhaustive_search/subsets.md

@@ -184,7 +184,7 @@ Java 和 Python 的代码中在将临时list 添加到最终结果时新生成
 
 回溯法可用图示和函数运行的堆栈图来理解，强烈建议**使用图形和递归的思想**分析，以数组`[1, 2, 3]`进行分析。下图所示为`list`及`result`动态变化的过程，箭头向下表示`list.add`及`result.add`操作，箭头向上表示`list.remove`操作。
 
-![Subsets运行递归调用图](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/subsets.jpg)
+![Subsets运行递归调用图](../../shared-files/images/subsets.jpg)
 
 ### 复杂度分析
 

zh-hans/faq/README.md

@@ -64,7 +64,7 @@ Gitbook 虽然也有 star 和 subscribe 功能，但目前来看还是非常鸡
 
 ### 支付宝打赏
 
-![alipay-billryan](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/images/alipay_billryan_qr15x15.png)
+![alipay-billryan](../images/alipay_billryan_qr15x15.png)
 
 金额随意。
 

zh-hans/faq/guidelines_for_contributing.md

@@ -34,7 +34,7 @@ Gitbook 中使用`SUMMARY.md`这个文件控制生成目录，添加新内容时
 
 推荐的 markdown 编辑器为 Gitbook 自家的 [editor](https://www.gitbook.com/editor), 目前新版的 bug 太多，而且是自动 commit 的，不便于版本控制，希望他们后续能改进。所以目前推荐老版，老版的见 [editor-lagecy](https://github.com/GitbookIO/editor-legacy/releases), 支持 Windows/Linux/MAC 三大平台，业界良心！但是实测在Arch Linux/OSX 下可能会出现占用内存/CPU过高的情况... 编辑界面如下图所示，最左边为章节预览，中间为 markdown 编辑框，右边为实时渲染页面，可选择使用全屏模式。
 
-![Gitbook Editor](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/gitbook_editor.png)
+![Gitbook Editor](../../shared-files/images/gitbook_editor.png)
 
 使用其他如 Mou/Vim/Emacs/Sublime Text也不错，但是在新增Chapter/Section时就比较闹心了，嗯，你也可以新建 Section 后再使用其他编辑器编辑。
 
@@ -75,6 +75,6 @@ Part II为leetcode/lintcode题解，这部分的风格相对容易统一，感
 
 ### 附件及图片引用
 
-图片统一存放在`images`目录下，其他附件存放在`docs`目录下。引用图片链接一般可以通过`![Caption](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/xxx.png)`声明。
+图片统一存放在`images`目录下，其他附件存放在`docs`目录下。引用图片链接一般可以通过`![Caption](../../shared-files/images/xxx.png)`声明。
 
 图片体积太大不利于页面加载，建议先压缩后再放入，如果是png图片可考虑使用 [TinyPNG – Compress PNG images while preserving transparency](https://tinypng.com/)

zh-hans/graph/bipartial_graph_part_i.md

@@ -26,7 +26,7 @@ OK，让我们愉快的**暴力搜索**吧！
 
 对于拿到的相亲情况表，我们不妨将其转化成一个图。将每一个人作为一个点**(编号1..N)**，若两个人之间有一场相亲，则在对应的点之间连接一条无向边。(如下图)
 
-![img1](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/bipatial_graph_part_i_1.png)
+![img1](../../shared-files/images/bipatial_graph_part_i_1.png)
 
 因为相亲总是在男女之间进行的，所以每一条边的两边对应的人总是不同性别。假设表示男性的节点染成白色，女性的节点染色黑色。对于得到的无向图来说，即每一条边的两端
 一定是一白一黑。如果存在一条边两端同为白色或者黑色，则表示这一条边所表示的记录有误。
@@ -36,7 +36,7 @@ OK，让我们愉快的**暴力搜索**吧！
 那么，我们不妨将所有的点初始为未染色的状态。随机选择一个点，将其染成白色。再以它为起点，将所有相邻的点染成黑色。再以这些黑色的点为起点，将所有与其相邻未染色
 的点染成白色。不断重复直到整个图都染色完成。(如下图)
 
-![img2](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/bipatial_graph_part_i_2.png)
+![img2](../../shared-files/images/bipatial_graph_part_i_2.png)
 
 
 在染色的过程中，我们应该怎样发现错误的记录呢？相信你一定发现了吧。对于一个已经染色的点，如果存在一个与它相邻的已染色点和它的颜色相同，那么就一定存在一条错误

zh-hans/graph/topological_sorting.md

@@ -15,7 +15,7 @@ Find any topological order for the given graph.
 Example
 For graph as follow:
 
-![Topological Sorting](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/topological_sorting.jpeg)
+![Topological Sorting](../../shared-files/images/topological_sorting.jpeg)
 
 ```
 The topological order can be:

zh-hans/linked_list/README.md

@@ -7,5 +7,5 @@
 
 下图是把本章中所有出现的题目归类总结了一下，便于记忆 
 
-![链表](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/images/linked_list_summary.png)
+![链表](../images/linked_list_summary.png)
 

zh-hans/linked_list/copy_list_with_random_pointer.md

@@ -39,7 +39,7 @@ Return a deep copy of the list.
 
 一图胜千文
 
-![Hashtable](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/copy_list_with_random_pointer.jpg)
+![Hashtable](../../shared-files/images/copy_list_with_random_pointer.jpg)
 
 ### Python
 

zh-hans/linked_list/insertion_sort_list.md

@@ -266,7 +266,7 @@ public class Solution {
 3. 由于已经确认链表逆序，故仅需将较小值(`cur->next`而不是`cur`)的节点插入到链表的合适位置。
 4. 将`cur->next`插入到`pre`之后，这里需要四个步骤，需要特别小心！
 
-![Insertion Sort](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/insertion_sort_list.png)
+![Insertion Sort](../../shared-files/images/insertion_sort_list.png)
 
 如上图所示，将`cur->next`插入到`pre`节点后大致分为3个步骤。
 

zh-hans/linked_list/linked_list_cycle.md

@@ -22,7 +22,7 @@ Can you solve it without using extra space?
 
 快指针走到`NULL`退出循环即可确定此链表一定无环这个很好理解。那么带环的链表快慢指针一定会相遇吗？先来看看下图。
 
-![Linked List Cycle](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/linked_list_cycle.png)
+![Linked List Cycle](../../shared-files/images/linked_list_cycle.png)
 
 在有环的情况下，最终快慢指针一定都走在环内，加入第`i`次遍历时快指针还需要`k`步才能追上慢指针，由于快指针比慢指针每次多走一步。那么每遍历一次快慢指针间的间距都会减少1，直至最终相遇。故快慢指针相遇一定能确定该链表有环。
 

zh-hans/linked_list/linked_list_cycle_ii.md

@@ -25,7 +25,7 @@ Can you solve it without using extra space?
 
 从以上两个容易得到的特性可知，在仅仅知道第一次相遇时的节点还不够，相遇后如果不改变既有策略则必然找不到环的入口。接下来我们分析下如何从第一次相遇的节点走到环的入口节点。还是让我们先从实际例子出发，以下图为例。
 
-![Linked List Cycle II](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/linked_list_cycle_ii.png)
+![Linked List Cycle II](../../shared-files/images/linked_list_cycle_ii.png)
 
 `slow`和`fast`节点分别初始化为节点`1`和`2`，假设快慢指针第一次相遇的节点为`0`, 对应于环中的第`i`个节点 $$C_i$$, 那么此时慢指针正好走了 $$n - r - 1 + i$$ 步，快指针则走了 $$2 \cdot (n - r - 1 + i)$$ 步，且存在[^1]: $$n - r - 1 + i + 1= l \cdot r$$. (之所以在`i`后面加1是因为快指针初始化时多走了一步) 快慢指针第一次相遇时慢指针肯定没有走完整个环，且慢指针走的步数即为整数个环节点个数，由性质1和性质2可联合推出。
 

zh-hans/linked_list/merge_k_sorted_lists.md

@@ -237,4 +237,4 @@ private:
 
 ## Reference
 
-- [^soulmachine]: [soulmachine的LeetCode 题解](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/docs/leetcode-cpp.pdf)
+- [^soulmachine]: [soulmachine的LeetCode 题解](../../shared-files/docs/leetcode-cpp.pdf)

zh-hans/linked_list/remove_duplicates_from_sorted_list_ii.md

@@ -90,7 +90,7 @@ public:
 1. 节点dummy的初始化有问题，对类的初始化应该使用`new`
 2. 在else语句中`node->next = node->next->next;`改写了`dummy-next`中的内容，返回的`dummy-next`不再是队首元素，而是队尾元素。原因很微妙，应该使用`node = node->next;`，node代表节点指针变量，而node->next代表当前节点所指向的下一节点地址。具体分析可自行在纸上画图分析，可对指针和链表的理解又加深不少。
 
-![remove_duplicates_from_sorted_listd内存分析](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/remove_duplicates_from_sorted_list.jpg)
+![remove_duplicates_from_sorted_listd内存分析](../../shared-files/images/remove_duplicates_from_sorted_list.jpg)
 
 图中上半部分为ListNode的内存示意图，每个框底下为其内存地址。`dummy`指针变量本身的地址为ox7fff5d0d2500，其保存着指针变量值为0x7fbe7bc04c50. `head`指针变量本身的地址为ox7fff5d0d2508，其保存着指针变量值为0x7fbe7bc04c00.
 

zh-hans/linked_list/reverse_linked_list.md

@@ -28,7 +28,7 @@ head = temp;
 
 要点在于维护两个指针变量`prev`和`head`, 翻转相邻两个节点之前保存下一节点的值，分析如下图所示：
 
-![Reverse Linked List](https://raw.githubusercontent.com/billryan/algorithm-exercise/master/shared-files/images/reverse_linked_list_i.jpg)
+![Reverse Linked List](../../shared-files/images/reverse_linked_list_i.jpg)
 
 1. 保存head下一节点
 2. 将head所指向的下一节点改为prev