update codes

Author: dunwu

codes/algorithm/src/main/java/io/github/dunwu/algorithm/search/SearchStrategy.java

@@ -16,15 +16,15 @@ public class SearchStrategy {
     private Search search;
 
     public SearchStrategy(Search search) {
-        this.search = search;
+        search = search;
     }
 
     public int find(Integer[] list, int key) {
-        logger.info(this.search.getClass().getSimpleName() + " 查找开始：");
+        logger.info(search.getClass().getSimpleName() + " 查找开始：");
         logger.info("要查找的线性表：{}", ArrayUtil.toString(list));
         logger.info("要查找的 key：{}", key);
 
-        int index = this.search.find(list, key);
+        int index = search.find(list, key);
         logger.info("{} 的位置是：{}", key, index);
         return index;
     }

codes/algorithm/src/main/java/io/github/dunwu/algorithm/trie/Trie.java

@@ -0,0 +1,75 @@
+package io.github.dunwu.algorithm.trie;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Trie {
+
+    private AtomicInteger wordCount = new AtomicInteger(0);
+    private final TrieNode root = new TrieNode('/'); // 存储无意义字符
+
+    // 往 Trie 树中插入一个字符串
+    public void insert(char[] text) {
+        TrieNode p = root;
+        for (int i = 0; i < text.length; ++i) {
+            int index = text[i] - 'a';
+            if (p.children[index] == null) {
+                TrieNode newNode = new TrieNode(text[i]);
+                p.children[index] = newNode;
+            } else {
+                p.children[index].count++;
+            }
+            p = p.children[index];
+        }
+        wordCount.getAndIncrement();
+        p.isEnd = true;
+    }
+
+    // 在 Trie 树中查找一个字符串
+    public boolean find(char[] pattern) {
+        TrieNode p = root;
+        for (int i = 0; i < pattern.length; ++i) {
+            int index = pattern[i] - 'a';
+            if (p.children[index] == null) {
+                return false; // 不存在 pattern
+            }
+            p = p.children[index];
+        }
+        return p.isEnd;
+    }
+
+    public String longest() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 26; i++) {
+            method(root.children[i], sb);
+        }
+        return sb.toString();
+    }
+
+    public void method(TrieNode root, StringBuilder sb) {
+        if (root != null) {
+            if (root.count == wordCount.get()) {
+                sb.append(root.data);
+                if (root.children != null) {
+                    for (int i = 0; i < 26; i++) {
+                        method(root.children[i], sb);
+                    }
+                }
+            }
+        }
+    }
+
+    public class TrieNode {
+
+        public int count;
+        public char data;
+        public boolean isEnd = false;
+        public TrieNode[] children = new TrieNode[26];
+
+        public TrieNode(char data) {
+            this.count = 1;
+            this.data = data;
+        }
+
+    }
+
+}

codes/algorithm/src/main/java/io/github/dunwu/algorithm/trie/实现Trie_前缀树.java

@@ -0,0 +1,76 @@
+package io.github.dunwu.algorithm.trie;
+
+/**
+ * @author <a href="mailto:forbreak@163.com">Zhang Peng</a>
+ * @see <a href="https://leetcode-cn.com/problems/implement-trie-prefix-tree/">208. 实现 Trie (前缀树)</a>
+ * @since 2020-06-15
+ */
+public class 实现Trie_前缀树 {
+
+    public static void main(String[] args) {
+        实现Trie_前缀树 trie = new 实现Trie_前缀树();
+        trie.insert("apple");
+        System.out.println(trie.search("apple")); // 返回 true
+        System.out.println(trie.search("app")); // 返回 false
+        System.out.println(trie.startsWith("app")); // 返回 true
+        trie.insert("app");
+        System.out.println(trie.search("app")); // 返回 true
+    }
+
+    private TrieNode root;
+
+    public 实现Trie_前缀树() {
+        root = new TrieNode('/');
+    }
+
+    public void insert(String word) {
+        TrieNode p = root;
+        for (char c : word.toCharArray()) {
+            int index = c - 'a';
+            if (p.children[index] == null) {
+                TrieNode node = new TrieNode(c);
+                p.children[index] = node;
+            }
+            p = p.children[index];
+        }
+        p.isEnd = true;
+    }
+
+    public boolean search(String word) {
+        TrieNode p = root;
+        for (char c : word.toCharArray()) {
+            int index = c - 'a';
+            if (p.children[index] == null) {
+                return false;
+            }
+            p = p.children[index];
+        }
+        return p.isEnd;
+    }
+
+    public boolean startsWith(String prefix) {
+        TrieNode p = root;
+        for (char c : prefix.toCharArray()) {
+            int index = c - 'a';
+            if (p.children[index] == null) {
+                return false;
+            }
+            p = p.children[index];
+        }
+        return true;
+    }
+
+    public static class TrieNode {
+
+        public boolean isEnd;
+        public char data;
+        public TrieNode[] children;
+
+        public TrieNode(char data) {
+            this.data = data;
+            this.children = new TrieNode[26];
+        }
+
+    }
+
+}

codes/algorithm/src/main/java/io/github/dunwu/algorithm/trie/最长公共前缀.java

@@ -0,0 +1,21 @@
+package io.github.dunwu.algorithm.trie;
+
+/**
+ * @author <a href="mailto:forbreak@163.com">Zhang Peng</a>
+ * @since 2020-06-15
+ */
+public class 最长公共前缀 {
+
+    public static void main(String[] args) {
+        longestCommonPrefix("flower", "flow", "flight");
+    }
+
+    public static String longestCommonPrefix(String... strs) {
+        Trie trie = new Trie();
+        for (String s : strs) {
+            trie.insert(s.toCharArray());
+        }
+        return trie.longest();
+    }
+
+}

docs/linear-list-search.md

@@ -76,9 +76,7 @@ ASL = (N + N-1 + ... + 2 + 1) / N = (N+1) / 2
 
 ## 二分查找
 
-**要点**
-
-二分查找又称**折半查找**，它是一种效率较高的查找方法。
+> **二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0**。
 
 **存储结构**
 
@@ -124,6 +122,13 @@ public int binarySearch(int[] list, int length, int key) {
 
 由此可知，二分查找的**平均查找长度**实际上就是树的高度**O(log<sub>2</sub>N)**。
 
+**二分查找的局限性**
+
+- 二分查找依赖的是顺序表结构，简单点说就是数组
+- 二分查找针对的是有序数据
+- 数据量太小不适合二分查找
+- 数据量太大也不适合二分查找
+
 ## 分块查找
 
 **要点**