add java and c++ version

docs/Algorithm_Templates/Java/Compression/README.md

+

docs/Algorithm_Templates/Java/Data_Structure/Graph/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/HashMap/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/HashTable/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/Heqp/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/LinkedList/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/Matrix/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/Queue/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/README.md

+

docs/Algorithm_Templates/Java/Data_Structure/Stack/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Data_Structure/Tree/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Java/Others/NextNodeInOrderTree.md

+``` python
+       8
+      /
+     5
+    / \
+   3   6
+  / \   \
+ 1  4    7
+
+
+class Node {
+  Node parent, lc, rc;
+  int val;
+}
+```
+
+1. 首先判断其自有无右孩子，若有，则取其右子树的最左节点; 若无，则开始2
+
+
+2. 它是其父亲节点的左孩子，则其父亲节点
+
+
+2. 它是其父亲节点的右孩子，则从其父亲开始往上追溯到第一个向右的节点，如果没有这个节点或者说没有父亲节点，则无下一个节点，若有则取之
+                                      
+
+```python
+def nextNode(node):
+    def leftest(node):
+        while node.lc:
+            node = node.lc
+        return node
+    if node.rc:
+        return leftest(node.rc)
+    if not node.parent:
+        return None
+    if node == node.parent.lc:
+        return node.parent
+    elif node == node.parent.rc:
+        while node.parent.parent:
+            if node.parent != node.parent.parent.lc:
+                node = node.parent
+            else:
+                return node.parent.parent
+        return None
+```

docs/Algorithm_Templates/Java/Others/TopKWords.java

+import java.io.*;
+import java.util.*;
+
+/* display the most frequent K words in the file and the times it appear
+    in the file – shown in order (ignore case and periods) */
+
+public class TopKWords {
+    static class CountWords {
+        private String fileName;
+
+        public CountWords(String fileName) {
+            this.fileName = fileName;
+        }
+
+        public Map<String, Integer> getDictionary() {
+            Map<String, Integer> dictionary = new HashMap<>();
+            FileInputStream fis = null;
+
+            try {
+
+                fis = new FileInputStream(fileName);  // open the file
+                int in = 0;
+                String s = "";  // init a empty word
+                in = fis.read();  // read one character
+
+                while (-1 != in) {
+                    if (Character.isLetter((char)in)) {
+                        s += (char)in;  //if get a letter, append to s
+                    } else {
+                        // this branch means an entire word has just been read
+                        if (s.length() > 0) {
+                            // see whether word exists or not
+                            if (dictionary.containsKey(s)) {
+                                // if exist, count++
+                                dictionary.put(s, dictionary.get(s) + 1);
+                            } else {
+                                // if not exist, initiate count of this word with 1
+                                dictionary.put(s, 1);
+                            }
+                        }
+                        s = ""; // reInit a empty word
+                    }
+                    in = fis.read();
+                }
+                return dictionary;
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                try {
+                    // you always have to close the I/O streams
+                    fis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return null;
+        }
+    }
+    public static void main(String[] args) {
+        // you can replace the filePath with yours, e.g.
+        // CountWords cw = new CountWords("/Users/lisanaaa/Desktop/words.txt");
+        CountWords cw = new CountWords("/words.txt");
+        Map<String, Integer> dictionary = cw.getDictionary();  // get the words dictionary: {word: frequency}
+
+        // we change the map to list for convenient sort
+        List<Map.Entry<String, Integer>> list = new ArrayList<>(dictionary.entrySet());
+
+        // sort by lambda valueComparator
+        list.sort(Comparator.comparing(
+                m -> m.getValue())
+        );
+
+        Scanner input = new Scanner(System.in);
+        int k = input.nextInt();
+        while (k > list.size()) {
+            System.out.println("Retype a number, your number is too large");
+            input = new Scanner(System.in);
+            k = input.nextInt();
+        }
+        for (int i = 0; i < k; i++) {
+            System.out.println(list.get(list.size() - i - 1));
+        }
+    }
+}
+
+

docs/Algorithm_Templates/Java/Others/words.txt

+
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam non pharetra purus. Quisque non tristique risus. Nulla ultricies eget nunc a volutpat. Aliquam semper, eros sit amet semper pellentesque, elit magna auctor ligula, sit amet vulputate nunc arcu sit amet ipsum. Aenean efficitur, felis ut tincidunt semper, sem sapien facilisis felis, et elementum ipsum risus sit amet metus. Pellentesque et orci at odio hendrerit lobortis vitae non felis. Phasellus nunc eros, ultricies sed dolor vel, ultricies mattis neque. Mauris placerat fringilla libero id efficitur. Donec nec imperdiet augue. Sed sit amet risus in turpis scelerisque rutrum. Ut sed pretium dolor. Donec metus nisl, blandit quis augue et, interdum suscipit metus. Morbi rutrum eros vel lacus aliquet, et maximus erat dapibus. Vivamus est justo, sagittis a augue id, vulputate vehicula nunc. Praesent mattis eros sapien, ac sagittis urna accumsan sit amet. Proin non dui tincidunt, tristique nisi in, vestibulum lorem.
+
+Quisque fermentum justo lacus, sit amet tempus lectus congue eu. Nulla sed quam nec nulla consequat tincidunt. Sed sed nunc diam. Integer ex ante, accumsan id fermentum a, interdum eu sapien. Aliquam justo dui, luctus vel ligula in, lacinia ornare turpis. Praesent leo purus, fringilla ut lobortis et, porta ac urna. Mauris id velit porta, iaculis felis non, sagittis nunc. Quisque non condimentum nisl, vitae venenatis urna. Nam commodo euismod felis, ac efficitur turpis scelerisque nec. Phasellus sagittis nec lacus eu bibendum. Suspendisse finibus vestibulum quam, quis volutpat ante. Duis nibh ligula, dapibus at est sed, tincidunt convallis augue. Pellentesque non consequat mi. Curabitur consequat imperdiet efficitur.
+
+Mauris ipsum arcu, fermentum in urna ultricies, venenatis vehicula nisl. Donec viverra non tellus sit amet porta. Phasellus ornare magna eget condimentum mollis. In hac habitasse platea dictumst. Proin in nibh venenatis, fermentum neque nec, commodo urna. In eget condimentum risus, ac interdum dolor. Sed ut neque sapien. Proin nulla diam, lobortis sed ultrices eget, blandit ut libero.
+
+Fusce at varius dui. Quisque viverra vulputate consectetur. Quisque sagittis id ante a vestibulum. Phasellus vel lobortis lectus. Duis vestibulum, quam vel congue elementum, lacus nibh efficitur odio, consectetur dapibus ipsum velit at diam. Duis eu nunc id diam tempor vestibulum sed luctus arcu. Nunc eu luctus ex. Morbi et commodo eros, non suscipit enim. Ut fringilla odio nec tincidunt scelerisque. Nam quis elit cursus, ullamcorper lorem id, convallis dui. Mauris elementum tortor odio, nec imperdiet nisl bibendum eget. Suspendisse potenti.
+
+Cras ut efficitur enim. Sed consequat non ante id euismod. Ut at magna viverra, aliquam purus a, lobortis mi. Donec hendrerit odio eu nunc imperdiet, quis pharetra sapien volutpat. Morbi leo libero, egestas vitae tortor eget, dictum volutpat augue. Donec arcu lacus, tristique eu posuere ac, pharetra vel ante. Nunc efficitur arcu elit, quis semper risus vestibulum eu. 

docs/Algorithm_Templates/Java/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) | [RadixSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/RadixSort.py) |
+

docs/Algorithm_Templates/Java/Sort/BubbleSort.py

+# coding:utf-8
+
+
+# 冒泡排序
+def bubble_sort(l):
+    length = len(l)
+    # 外层循环 length遍，内层循环少一遍
+    while length:
+        for j in range(length - 1):
+            # 找出最大值，然后交换位置到最后
+            if l[j] > l[length - 1]:
+                l[j], l[length - 1] = l[length - 1], l[j]
+        length -= 1
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    bubble_sort(l)
+    print l

docs/Algorithm_Templates/Java/Sort/InsertSort.py

+# coding:utf8
+"""
+插入排序和冒泡排序的区别在于：
+
+插入排序的前提是：左边是有序的数列
+而冒泡排序：相邻的值进行交换，一共进行n次交换
+"""
+
+
+def insert_sort(l):
+    # 循环  除第一个数字组成的有序数组 以外的数字
+    for i in range(1, len(l)):
+        # 每一个数字，依次和有序数组进行比较
+        print l[:i]
+        for j in range(len(l[:i])):
+            if l[i] < l[j]:
+                l[i], l[j] = l[j], l[i]
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    print l
+    insert_sort(l)
+    print("result: " + str(l))

docs/Algorithm_Templates/Java/Sort/MergeSort.py

+# coding: utf-8
+
+
+def MergeSort(lists):
+    if len(lists) <= 1:
+        return lists
+    num = int(len(lists) / 2)
+    # 从中间，进行数据的拆分, 递归的返回数据进行迭代排序
+    left = MergeSort(lists[:num])
+    right = MergeSort(lists[num:])
+    print left
+    print "*" * 20
+    print right
+    print "_" * 20
+    return Merge(left, right)
+
+
+def Merge(left, right):
+    r, l = 0, 0
+    result = []
+    while l < len(left) and r < len(right):
+        if left[l] < right[r]:
+            result.append(left[l])
+            l += 1
+        else:
+            result.append(right[r])
+            r += 1
+    result += right[r:]
+    result += left[l:]
+    print 'result:', result
+    return result
+
+
+if __name__ == "__main__":
+    print MergeSort([1, 2, 3, 4, 5, 6, 7, 90, 21, 23, 45])

docs/Algorithm_Templates/Java/Sort/QuickSort.py

+#!/usr/bin/python
+# coding:utf8
+
+
+def quick_sort(l, start, end):
+    i = start
+    j = end
+    # 结束排序
+    if i >= j:
+        return
+    # 保存首个数值
+    key = l[i]
+    # 一次排序，i和j的值不断的靠拢，然后最终停止，结束一次排序
+    while i < j:
+        # 和最右边的比较，如果>=key,然后j-1，慢慢的和前一个值比较;如果值<key，那么就交换位置
+        while i < j and key <= l[j]:
+            print key, l[j], '*' * 30
+            j -= 1
+        l[i] = l[j]
+        # 交换位置后，然后在和最左边的值开始比较，如果<=key,然后i+1，慢慢的和后一个值比较;如果值>key，那么就交换位置
+        while i < j and key >= l[i]:
+            print key, l[i], '*' * 30
+            i += 1
+        l[j] = l[i]
+    l[i] = key
+    # 左边排序
+    quick_sort(l, start, j-1)
+    # 右边排序
+    quick_sort(l, i+1, end)
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    quick_sort(l, 0, len(l) - 1)
+    print l

docs/Algorithm_Templates/Java/Sort/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) | [RadixSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/RadixSort.py) |
+

docs/Algorithm_Templates/Java/Sort/RadixSort.py

+#************************基数排序****************************
+#确定排序的次数
+#排序的顺序跟序列中最大数的位数相关
+def radix_sort_nums(L):
+    maxNum = L[0]
+#寻找序列中的最大数
+    for x in L:
+        if maxNum < x:
+            maxNum = x
+#确定序列中的最大元素的位数
+    times = 0
+    while (maxNum > 0):
+        maxNum = int((maxNum/10))
+        times += 1
+    return times
+#找到num从低到高第pos位的数据
+def get_num_pos(num, pos):
+    return (int((num/(10**(pos-1))))) % 10
+#基数排序
+def radix_sort(L):
+    count = 10 * [None]       #存放各个桶的数据统计个数
+    bucket = len(L) * [None]  #暂时存放排序结果
+#从低位到高位依次执行循环
+    for pos in range(1, radix_sort_nums(L)+1):
+        #置空各个桶的数据统计
+        for x in range(0, 10):
+            count[x] = 0
+        #统计当前该位(个位，十位，百位....)的元素数目
+        for x in range(0, len(L)):
+            #统计各个桶将要装进去的元素个数
+            j = get_num_pos(int(L[x]), pos)
+            count[j] += 1
+        #count[i]表示第i个桶的右边界索引
+        for x in range(1,10):
+            count[x] += count[x-1]
+        #将数据依次装入桶中
+        for x in range(len(L)-1, -1, -1):
+            #求出元素第K位的数字
+            j = get_num_pos(L[x], pos)
+            #放入对应的桶中，count[j]-1是第j个桶的右边界索引
+            bucket[count[j]-1] = L[x]
+            #对应桶的装入数据索引-1
+            count[j] -= 1
+        # 将已分配好的桶中数据再倒出来，此时已是对应当前位数有序的表
+        for x in range(0, len(L)):
+            L[x] = bucket[x]

docs/Algorithm_Templates/Java/Sort/SelectionSort.py

+# coding:utf8
+"""
+选择排序和冒泡排序的区别在于：
+
+选择排序的前提是：找到最大值的位置，最后才进行1次交换
+而冒泡排序：相邻的值进行交换，一共进行n次交换
+"""
+
+
+def selection_sort(l):
+    length = len(l) - 1
+
+    while length:
+        index = length
+        # 第一个数字，和后面每一个数字进行对比，找出最大值，放到最后！！
+        for j in range(length):
+            if l[j] > l[index]:
+                index = j
+        l[length], l[index] = l[index], l[length]
+        print len(l) - length, l
+        length -= 1
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    print l
+    selection_sort(l)
+    print("result: " + str(l))
\ No newline at end of file

docs/Algorithm_Templates/Java/Sort/ShellSort.py

+# coding: utf8
+
+def insert_sort(l, start, increment):
+    for i in range(start+increment, len(l), increment):
+        for j in range(start, len(l[:i]), increment):
+            if l[i] < l[j]:
+                l[i], l[j] = l[j], l[i]
+    print increment, '--',l
+    return l
+
+def shell_sort(l, increment):
+    # 依次进行分层
+    while increment:
+        # 每一层，都进行n次插入排序
+        for i in range(0, increment):
+            insert_sort(l, i, increment)
+        increment -= 1
+    return l
+
+if __name__ == "__main__":
+    l = [5, 2, 9, 8, 1, 10, 3, 4, 7]
+    increment = len(l)/3+1 if len(l)%3 else len(l)/3
+    print "开始", l
+    l = shell_sort(l, increment)
+    print "结束", l
\ No newline at end of file

docs/Algorithm_Templates/Python/Compression/README.md

+

docs/Algorithm_Templates/Python/Data_Structure/Graph/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/HashMap/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/HashTable/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/Heqp/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/LinkedList/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/Matrix/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/Queue/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/README.md

+

docs/Algorithm_Templates/Python/Data_Structure/Stack/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Data_Structure/Tree/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](/opt/git/LeetCode/docs/Algorithm\ Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](/opt/git/LeetCode/docs/src/py2.x/SortingAlgorithm/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) |  |

docs/Algorithm_Templates/Python/Others/NextNodeInOrderTree.md

+``` python
+       8
+      /
+     5
+    / \
+   3   6
+  / \   \
+ 1  4    7
+
+
+class Node {
+  Node parent, lc, rc;
+  int val;
+}
+```
+
+1. 首先判断其自有无右孩子，若有，则取其右子树的最左节点; 若无，则开始2
+
+
+2. 它是其父亲节点的左孩子，则其父亲节点
+
+
+2. 它是其父亲节点的右孩子，则从其父亲开始往上追溯到第一个向右的节点，如果没有这个节点或者说没有父亲节点，则无下一个节点，若有则取之
+                                      
+
+```python
+def nextNode(node):
+    def leftest(node):
+        while node.lc:
+            node = node.lc
+        return node
+    if node.rc:
+        return leftest(node.rc)
+    if not node.parent:
+        return None
+    if node == node.parent.lc:
+        return node.parent
+    elif node == node.parent.rc:
+        while node.parent.parent:
+            if node.parent != node.parent.parent.lc:
+                node = node.parent
+            else:
+                return node.parent.parent
+        return None
+```

docs/Algorithm_Templates/Python/Others/TopKWords.java

+import java.io.*;
+import java.util.*;
+
+/* display the most frequent K words in the file and the times it appear
+    in the file – shown in order (ignore case and periods) */
+
+public class TopKWords {
+    static class CountWords {
+        private String fileName;
+
+        public CountWords(String fileName) {
+            this.fileName = fileName;
+        }
+
+        public Map<String, Integer> getDictionary() {
+            Map<String, Integer> dictionary = new HashMap<>();
+            FileInputStream fis = null;
+
+            try {
+
+                fis = new FileInputStream(fileName);  // open the file
+                int in = 0;
+                String s = "";  // init a empty word
+                in = fis.read();  // read one character
+
+                while (-1 != in) {
+                    if (Character.isLetter((char)in)) {
+                        s += (char)in;  //if get a letter, append to s
+                    } else {
+                        // this branch means an entire word has just been read
+                        if (s.length() > 0) {
+                            // see whether word exists or not
+                            if (dictionary.containsKey(s)) {
+                                // if exist, count++
+                                dictionary.put(s, dictionary.get(s) + 1);
+                            } else {
+                                // if not exist, initiate count of this word with 1
+                                dictionary.put(s, 1);
+                            }
+                        }
+                        s = ""; // reInit a empty word
+                    }
+                    in = fis.read();
+                }
+                return dictionary;
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                try {
+                    // you always have to close the I/O streams
+                    fis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return null;
+        }
+    }
+    public static void main(String[] args) {
+        // you can replace the filePath with yours, e.g.
+        // CountWords cw = new CountWords("/Users/lisanaaa/Desktop/words.txt");
+        CountWords cw = new CountWords("/words.txt");
+        Map<String, Integer> dictionary = cw.getDictionary();  // get the words dictionary: {word: frequency}
+
+        // we change the map to list for convenient sort
+        List<Map.Entry<String, Integer>> list = new ArrayList<>(dictionary.entrySet());
+
+        // sort by lambda valueComparator
+        list.sort(Comparator.comparing(
+                m -> m.getValue())
+        );
+
+        Scanner input = new Scanner(System.in);
+        int k = input.nextInt();
+        while (k > list.size()) {
+            System.out.println("Retype a number, your number is too large");
+            input = new Scanner(System.in);
+            k = input.nextInt();
+        }
+        for (int i = 0; i < k; i++) {
+            System.out.println(list.get(list.size() - i - 1));
+        }
+    }
+}
+
+

docs/Algorithm_Templates/Python/Others/words.txt

+
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam non pharetra purus. Quisque non tristique risus. Nulla ultricies eget nunc a volutpat. Aliquam semper, eros sit amet semper pellentesque, elit magna auctor ligula, sit amet vulputate nunc arcu sit amet ipsum. Aenean efficitur, felis ut tincidunt semper, sem sapien facilisis felis, et elementum ipsum risus sit amet metus. Pellentesque et orci at odio hendrerit lobortis vitae non felis. Phasellus nunc eros, ultricies sed dolor vel, ultricies mattis neque. Mauris placerat fringilla libero id efficitur. Donec nec imperdiet augue. Sed sit amet risus in turpis scelerisque rutrum. Ut sed pretium dolor. Donec metus nisl, blandit quis augue et, interdum suscipit metus. Morbi rutrum eros vel lacus aliquet, et maximus erat dapibus. Vivamus est justo, sagittis a augue id, vulputate vehicula nunc. Praesent mattis eros sapien, ac sagittis urna accumsan sit amet. Proin non dui tincidunt, tristique nisi in, vestibulum lorem.
+
+Quisque fermentum justo lacus, sit amet tempus lectus congue eu. Nulla sed quam nec nulla consequat tincidunt. Sed sed nunc diam. Integer ex ante, accumsan id fermentum a, interdum eu sapien. Aliquam justo dui, luctus vel ligula in, lacinia ornare turpis. Praesent leo purus, fringilla ut lobortis et, porta ac urna. Mauris id velit porta, iaculis felis non, sagittis nunc. Quisque non condimentum nisl, vitae venenatis urna. Nam commodo euismod felis, ac efficitur turpis scelerisque nec. Phasellus sagittis nec lacus eu bibendum. Suspendisse finibus vestibulum quam, quis volutpat ante. Duis nibh ligula, dapibus at est sed, tincidunt convallis augue. Pellentesque non consequat mi. Curabitur consequat imperdiet efficitur.
+
+Mauris ipsum arcu, fermentum in urna ultricies, venenatis vehicula nisl. Donec viverra non tellus sit amet porta. Phasellus ornare magna eget condimentum mollis. In hac habitasse platea dictumst. Proin in nibh venenatis, fermentum neque nec, commodo urna. In eget condimentum risus, ac interdum dolor. Sed ut neque sapien. Proin nulla diam, lobortis sed ultrices eget, blandit ut libero.
+
+Fusce at varius dui. Quisque viverra vulputate consectetur. Quisque sagittis id ante a vestibulum. Phasellus vel lobortis lectus. Duis vestibulum, quam vel congue elementum, lacus nibh efficitur odio, consectetur dapibus ipsum velit at diam. Duis eu nunc id diam tempor vestibulum sed luctus arcu. Nunc eu luctus ex. Morbi et commodo eros, non suscipit enim. Ut fringilla odio nec tincidunt scelerisque. Nam quis elit cursus, ullamcorper lorem id, convallis dui. Mauris elementum tortor odio, nec imperdiet nisl bibendum eget. Suspendisse potenti.
+
+Cras ut efficitur enim. Sed consequat non ante id euismod. Ut at magna viverra, aliquam purus a, lobortis mi. Donec hendrerit odio eu nunc imperdiet, quis pharetra sapien volutpat. Morbi leo libero, egestas vitae tortor eget, dictum volutpat augue. Donec arcu lacus, tristique eu posuere ac, pharetra vel ante. Nunc efficitur arcu elit, quis semper risus vestibulum eu. 

docs/Algorithm_Templates/Python/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) | [RadixSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/RadixSort.py) |
+

docs/Algorithm_Templates/Python/Sort/BubbleSort.py

+# coding:utf-8
+
+
+# 冒泡排序
+def bubble_sort(l):
+    length = len(l)
+    # 外层循环 length遍，内层循环少一遍
+    while length:
+        for j in range(length - 1):
+            # 找出最大值，然后交换位置到最后
+            if l[j] > l[length - 1]:
+                l[j], l[length - 1] = l[length - 1], l[j]
+        length -= 1
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    bubble_sort(l)
+    print l

docs/Algorithm_Templates/Python/Sort/InsertSort.py

+# coding:utf8
+"""
+插入排序和冒泡排序的区别在于：
+
+插入排序的前提是：左边是有序的数列
+而冒泡排序：相邻的值进行交换，一共进行n次交换
+"""
+
+
+def insert_sort(l):
+    # 循环  除第一个数字组成的有序数组 以外的数字
+    for i in range(1, len(l)):
+        # 每一个数字，依次和有序数组进行比较
+        print l[:i]
+        for j in range(len(l[:i])):
+            if l[i] < l[j]:
+                l[i], l[j] = l[j], l[i]
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    print l
+    insert_sort(l)
+    print("result: " + str(l))

docs/Algorithm_Templates/Python/Sort/MergeSort.py

+# coding: utf-8
+
+
+def MergeSort(lists):
+    if len(lists) <= 1:
+        return lists
+    num = int(len(lists) / 2)
+    # 从中间，进行数据的拆分, 递归的返回数据进行迭代排序
+    left = MergeSort(lists[:num])
+    right = MergeSort(lists[num:])
+    print left
+    print "*" * 20
+    print right
+    print "_" * 20
+    return Merge(left, right)
+
+
+def Merge(left, right):
+    r, l = 0, 0
+    result = []
+    while l < len(left) and r < len(right):
+        if left[l] < right[r]:
+            result.append(left[l])
+            l += 1
+        else:
+            result.append(right[r])
+            r += 1
+    result += right[r:]
+    result += left[l:]
+    print 'result:', result
+    return result
+
+
+if __name__ == "__main__":
+    print MergeSort([1, 2, 3, 4, 5, 6, 7, 90, 21, 23, 45])

docs/Algorithm_Templates/Python/Sort/QuickSort.py

+#!/usr/bin/python
+# coding:utf8
+
+
+def quick_sort(l, start, end):
+    i = start
+    j = end
+    # 结束排序
+    if i >= j:
+        return
+    # 保存首个数值
+    key = l[i]
+    # 一次排序，i和j的值不断的靠拢，然后最终停止，结束一次排序
+    while i < j:
+        # 和最右边的比较，如果>=key,然后j-1，慢慢的和前一个值比较;如果值<key，那么就交换位置
+        while i < j and key <= l[j]:
+            print key, l[j], '*' * 30
+            j -= 1
+        l[i] = l[j]
+        # 交换位置后，然后在和最左边的值开始比较，如果<=key,然后i+1，慢慢的和后一个值比较;如果值>key，那么就交换位置
+        while i < j and key >= l[i]:
+            print key, l[i], '*' * 30
+            i += 1
+        l[j] = l[i]
+    l[i] = key
+    # 左边排序
+    quick_sort(l, start, j-1)
+    # 右边排序
+    quick_sort(l, i+1, end)
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    quick_sort(l, 0, len(l) - 1)
+    print l

docs/Algorithm_Templates/Python/Sort/README.md

+# Some algorithm templates for better understanding!
+
+## 八大排序算法
+
+![](/images/SortingAlgorithm/八大排序算法性能.png)
+
+| 名称 | 动图 | 代码 |
+| --- | --- | --- |
+| 冒泡排序 | ![](/images/SortingAlgorithm/冒泡排序.gif) | [BubbleSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/BubbleSort.py) |
+| 插入排序 | ![](/images/SortingAlgorithm/直接插入排序.gif) | [InsertSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/InsertSort.py) |
+| 选择排序 | ![](/images/SortingAlgorithm/简单选择排序.gif) | [SelectionSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/SelectionSort.py) |
+| 快速排序 | ![](/images/SortingAlgorithm/快速排序.gif) | [QuickSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/QuickSort.py) |
+| 希尔排序 | ![](/images/SortingAlgorithm/希尔排序.png) | [ShellSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/ShellSort.py) |
+| 归并排序 | ![](/images/SortingAlgorithm/归并排序.gif) | [MergeSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/MergeSort.py) |
+| 基数排序 | ![](/images/SortingAlgorithm/基数排序.gif) | [RadixSort.py](https://github.com/apachecn/LeetCode/blob/master/docs/Algorithm_Templates/Sort/RadixSort.py) |
+

docs/Algorithm_Templates/Python/Sort/RadixSort.py

+#************************基数排序****************************
+#确定排序的次数
+#排序的顺序跟序列中最大数的位数相关
+def radix_sort_nums(L):
+    maxNum = L[0]
+#寻找序列中的最大数
+    for x in L:
+        if maxNum < x:
+            maxNum = x
+#确定序列中的最大元素的位数
+    times = 0
+    while (maxNum > 0):
+        maxNum = int((maxNum/10))
+        times += 1
+    return times
+#找到num从低到高第pos位的数据
+def get_num_pos(num, pos):
+    return (int((num/(10**(pos-1))))) % 10
+#基数排序
+def radix_sort(L):
+    count = 10 * [None]       #存放各个桶的数据统计个数
+    bucket = len(L) * [None]  #暂时存放排序结果
+#从低位到高位依次执行循环
+    for pos in range(1, radix_sort_nums(L)+1):
+        #置空各个桶的数据统计
+        for x in range(0, 10):
+            count[x] = 0
+        #统计当前该位(个位，十位，百位....)的元素数目
+        for x in range(0, len(L)):
+            #统计各个桶将要装进去的元素个数
+            j = get_num_pos(int(L[x]), pos)
+            count[j] += 1
+        #count[i]表示第i个桶的右边界索引
+        for x in range(1,10):
+            count[x] += count[x-1]
+        #将数据依次装入桶中
+        for x in range(len(L)-1, -1, -1):
+            #求出元素第K位的数字
+            j = get_num_pos(L[x], pos)
+            #放入对应的桶中，count[j]-1是第j个桶的右边界索引
+            bucket[count[j]-1] = L[x]
+            #对应桶的装入数据索引-1
+            count[j] -= 1
+        # 将已分配好的桶中数据再倒出来，此时已是对应当前位数有序的表
+        for x in range(0, len(L)):
+            L[x] = bucket[x]

docs/Algorithm_Templates/Python/Sort/SelectionSort.py

+# coding:utf8
+"""
+选择排序和冒泡排序的区别在于：
+
+选择排序的前提是：找到最大值的位置，最后才进行1次交换
+而冒泡排序：相邻的值进行交换，一共进行n次交换
+"""
+
+
+def selection_sort(l):
+    length = len(l) - 1
+
+    while length:
+        index = length
+        # 第一个数字，和后面每一个数字进行对比，找出最大值，放到最后！！
+        for j in range(length):
+            if l[j] > l[index]:
+                index = j
+        l[length], l[index] = l[index], l[length]
+        print len(l) - length, l
+        length -= 1
+
+
+if __name__ == "__main__":
+    l = [5, 1, 9, 3, 2, 7]
+    print l
+    selection_sort(l)
+    print("result: " + str(l))
\ No newline at end of file

docs/Algorithm_Templates/Python/Sort/ShellSort.py

+# coding: utf8
+
+def insert_sort(l, start, increment):
+    for i in range(start+increment, len(l), increment):
+        for j in range(start, len(l[:i]), increment):
+            if l[i] < l[j]:
+                l[i], l[j] = l[j], l[i]
+    print increment, '--',l
+    return l
+
+def shell_sort(l, increment):
+    # 依次进行分层
+    while increment:
+        # 每一层，都进行n次插入排序
+        for i in range(0, increment):
+            insert_sort(l, i, increment)
+        increment -= 1
+    return l
+
+if __name__ == "__main__":
+    l = [5, 2, 9, 8, 1, 10, 3, 4, 7]
+    increment = len(l)/3+1 if len(l)%3 else len(l)/3
+    print "开始", l
+    l = shell_sort(l, increment)
+    print "结束", l
\ No newline at end of file