▶ 书中第五章部分程序，包括在加上自己补充的代码，Trie 树类，Trie 集合，三值搜索树（Ternary Search Trie）

● Trie 树类

  1.  package package01;
  2.  
  3.  import edu.princeton.cs.algs4.StdIn;
  4.  import edu.princeton.cs.algs4.StdOut;
  5.  import edu.princeton.cs.algs4.Queue;
  6.  
  7.  public class class01<Value>
  8.  {
  9.      private static final int R = 256;   // 扩展 ASCII
  10.  
  11.      private Node root;
  12.      private int n;                      // 总节点数
  13.  
  14.      private static class Node           // 节点类，含当前节点代表的值，以及 R 路支链
  15.      {
  16.          private Object val;
  17.          private Node[] next = new Node[R];
  18.      }
  19.  
  20.      public class01() {}
  21.  
  22.      public boolean contains(String key)
  23.      {
  24.          if (key == null)
  25.              throw new IllegalArgumentException("\n<contains> key == null.\n");
  26.          return get(key) != null;
  27.      }
  28.  
  29.      public Value get(String key)
  30.      {
  31.          if (key == null)
  32.              throw new IllegalArgumentException("\n<get> key == null.\n");
  33.          Node x = getKernel(root, key, 0);
  34.          return (x == null) ? null : (Value)x.val;       // 找到了就返回，没找到返回 null
  35.      }
  36.  
  37.      private Node getKernel(Node x, String key, int d)   // 注意返回的是节点，与 get 不同
  38.      {
  39.          if (x == null)                                  // 先判断当前节点是否为空，再判断是否到达搜索终点，然后考虑递归
  40.              return null;
  41.          if (d == key.length())
  42.              return x;
  43.          return getKernel(x.next[key.charAt(d)], key, d + 1);
  44.      }
  45.  
  46.      public void put(String key, Value val)
  47.      {
  48.          if (key == null)
  49.              throw new IllegalArgumentException("\n<put> key == null.\n");
  50.          if (val == null)
  51.              delete(key);
  52.          else
  53.              root = putKernel(root, key, val, 0);
  54.      }
  55.  
  56.      private Node putKernel(Node x, String key, Value val, int d)
  57.      {
  58.          if (x == null)                  // 先判断当前节点是否为空，再判断是否到达搜索终点，然后考虑递归
  59.              x = new Node();
  60.          if (d == key.length())
  61.          {
  62.              if (x.val == null)          // 节点为空，节点数 +1
  63.                  n++;
  64.              x.val = val;                // 赋上新值
  65.          }
  66.          else
  67.          {
  68.              char c = key.charAt(d);
  69.              x.next[c] = putKernel(x.next[c], key, val, d + 1);
  70.          }
  71.          return x;
  72.      }
  73.  
  74.      public int size()
  75.      {
  76.          return n;
  77.      }
  78.  
  79.      public boolean isEmpty()
  80.      {
  81.          return size() == 0;
  82.      }
  83.  
  84.      public Iterable<String> keys()                              // 生成所有键的迭代器（遍历）
  85.      {
  86.          return keyPrefix("");
  87.      }
  88.  
  89.      public Iterable<String> keyPrefix(String prefix)            // 生成具有给定前缀的所有键的迭代器
  90.      {
  91.          Queue<String> results = new Queue<String>();
  92.          Node x = getKernel(root, prefix, 0);                    // 先抵达前缀结束时的搜索节点
  93.          collectPrefix(x, new StringBuilder(prefix), results);   // 在此基础上遍历并放入迭代器
  94.          return results;
  95.      }
  96.  
  97.      private void collectPrefix(Node x, StringBuilder prefix, Queue<String> results)   // 遍历 x 为根节点的表，prefix 用来生成结果的，不参与遍历
  98.      {
  99.          if (x == null)
  100.              return;
  101.          if (x.val != null)
  102.              results.enqueue(prefix.toString());                 // 除了给定前缀，没有多余字符的情况
  103.          for (char c = 0; c < R; c++)                            // 每次循环尝试添加一个字符，遍历子节点，然后删掉
  104.          {
  105.              prefix.append(c);
  106.              collectPrefix(x.next[c], prefix, results);
  107.              prefix.deleteCharAt(prefix.length() - 1);
  108.          }
  109.      }
  110.  
  111.      public Iterable<String> keyPattern(String pattern)          // 生成具有给定模式的所有键的迭代器
  112.      {
  113.          Queue<String> results = new Queue<String>();
  114.          collectPattern(root, new StringBuilder(), pattern, results);
  115.          return results;
  116.      }
  117.  
  118.      private void collectPattern(Node x, StringBuilder prefix, String pattern, Queue<String> results)
  119.      {
  120.          if (x == null)
  121.              return;
  122.          int d = prefix.length();
  123.          if (d == pattern.length())                              // 已经到了模式的尽头
  124.          {
  125.              if (x.val != null)
  126.                  results.enqueue(prefix.toString());
  127.              return;
  128.          }
  129.          char c = pattern.charAt(d);
  130.          if (c == '.')
  131.          {
  132.              for (char ch = 0; ch < R; ch++)                     // 模式是 '.'，像 collectPrefix 那样尝试添加每一个字符来遍历子节点，然后删掉
  133.              {
  134.                  prefix.append(ch);
  135.                  collectPattern(x.next[ch], prefix, pattern, results);
  136.                  prefix.deleteCharAt(prefix.length() - 1);
  137.              }
  138.          }
  139.          else                                                    // 否则只添加确定的字符，遍历其子节点，之后也要删掉
  140.          {
  141.              prefix.append(c);
  142.              collectPattern(x.next[c], prefix, pattern, results);
  143.              prefix.deleteCharAt(prefix.length() - 1);
  144.          }
  145.      }
  146.  
  147.      public String longestPrefixOf(String query)                 // 找出与给定串有相同前缀的键的最大长度
  148.      {
  149.          if (query == null)
  150.              throw new IllegalArgumentException("\n<longestPrefixOf> query == null.\n");
  151.          int length = longestPrefixOfKernel(root, query, 0, -1);
  152.          if (length == -1)
  153.              return null;
  154.          return query.substring(0, length);
  155.      }
  156.  
  157.      private int longestPrefixOfKernel(Node x, String query, int d, int length)
  158.      {
  159.          if (x == null)
  160.              return length;
  161.          if (x.val != null)
  162.              length = d;
  163.          if (d == query.length())
  164.              return length;
  165.          return longestPrefixOfKernel(x.next[query.charAt(d)], query, d + 1, length);
  166.      }
  167.  
  168.      public void delete(String key)
  169.      {
  170.          if (key == null)
  171.              throw new IllegalArgumentException("\n<delete> key == null.\n");
  172.          root = deleteKernel(root, key, 0);
  173.      }
  174.  
  175.      private Node deleteKernel(Node x, String key, int d)        // 删除节点
  176.      {
  177.          if (x == null)
  178.              return null;
  179.          if (d == key.length())                                  // 到达对应深度
  180.          {
  181.              if (x.val != null)                                  // 目标节点存在，总结点数 -1
  182.                  n--;
  183.              x.val = null;
  184.          }
  185.          else                                                    // 还没达到对应深度，继续下潜
  186.          {
  187.              char c = key.charAt(d);
  188.              x.next[c] = deleteKernel(x.next[c], key, d + 1);
  189.          }
  190.          if (x.val != null)                                      // 返回途中，发现盖层 x 还没有被删，返回 x
  191.              return x;
  192.          for (int c = 0; c < R; c++)                             // x 已经被删，但是 x 还有子节点
  193.          {
  194.              if (x.next[c] != null)
  195.                  return x;
  196.          }
  197.          return null;                                            // x 已经被删，且没有子节点，返回 null
  198.      }
  199.  
  200.      public static void main(String[] args)
  201.      {
  202.          class01<Integer> st = new class01<Integer>();
  203.          for (int i = 0; !StdIn.isEmpty(); i++)                  // 输入键
  204.              st.put(StdIn.readString(), i);
  205.          if (st.size() < 100)                                    // 输出保存的键
  206.          {
  207.              StdOut.println("keys(\"\"):");
  208.              for (String key : st.keys())
  209.                  StdOut.println(key + " " + st.get(key));
  210.              StdOut.println();
  211.          }
  212.  
  213.          StdOut.println("longestPrefixOf(\"shellsort\"):");
  214.          StdOut.println(st.longestPrefixOf("shellsort"));
  215.          StdOut.println();
  216.  
  217.          StdOut.println("longestPrefixOf(\"quicksort\"):");
  218.          StdOut.println(st.longestPrefixOf("quicksort"));
  219.          StdOut.println();
  220.  
  221.          StdOut.println("keyPrefix(\"shor\"):");
  222.          for (String s : st.keyPrefix("shor"))
  223.              StdOut.println(s);
  224.          StdOut.println();
  225.  
  226.          StdOut.println("keyPattern(\".he.l.\"):");
  227.          for (String s : st.keyPattern(".he.l."))
  228.              StdOut.println(s);
  229.      }
  230.  }

● Trie 集合

  1.  package package01;
  2.  
  3.  import java.util.Iterator;
  4.  import edu.princeton.cs.algs4.StdIn;
  5.  import edu.princeton.cs.algs4.StdOut;
  6.  import edu.princeton.cs.algs4.Queue;
  7.  
  8.  public class class01 implements Iterable<String>// 需要 string 的迭代器
  9.  {
  10.      private static final int R = 256;
  11.  
  12.      private Node root;
  13.      private int n;
  14.  
  15.      private static class Node
  16.      {
  17.          private boolean isString;          // 是否存在以当前节点为结尾的键
  18.          private Node[] next = new Node[R];
  19.      }
  20.  
  21.      public class01() {}
  22.  
  23.      public boolean contains(String key)
  24.      {
  25.          if (key == null)
  26.              throw new IllegalArgumentException("\n<contains> key == null.\n");
  27.          Node x = get(root, key, 0);
  28.          return (x == null) ? false : x.isString;// 是否为空的判断方式不同
  29.      }
  30.  
  31.      private Node get(Node x, String key, int d) // 没有 get 和 getKernel 的区分
  32.      {
  33.          if (x == null)
  34.              return null;
  35.          if (d == key.length())
  36.              return x;
  37.          return get(x.next[key.charAt(d)], key, d + 1);
  38.      }
  39.  
  40.      public void put(String key)// 少了 val 参数
  41.      {
  42.          if (key == null)
  43.              throw new IllegalArgumentException("\n<put> key == null.\n");
  44.          root = putKernel(root, key, 0);
  45.      }
  46.  
  47.      private Node putKernel(Node x, String key, int d)
  48.      {
  49.          if (x == null)
  50.              x = new Node();
  51.          if (d == key.length())
  52.          {
  53.              if (!x.isString) // 是否为空的判断条件不同
  54.                  n++;
  55.              x.isString = true;
  56.          }
  57.          else
  58.          {
  59.              char c = key.charAt(d);
  60.              x.next[c] = putKernel(x.next[c], key, d + 1);
  61.          }
  62.          return x;
  63.      }
  64.  
  65.      public int size()
  66.      {
  67.          return n;
  68.      }
  69.  
  70.      public boolean isEmpty()
  71.      {
  72.          return size() == 0;
  73.      }
  74.  
  75.      public Iterator<String> iterator() // 不是 Iterable，Iterator
  76.      {
  77.          return keyPrefix("").iterator();
  78.      }
  79.  
  80.      public Iterable<String> keyPrefix(String prefix)
  81.      {
  82.          Queue<String> results = new Queue<String>();
  83.          Node x = get(root, prefix, 0);
  84.          collectPrefix(x, new StringBuilder(prefix), results);
  85.          return results;
  86.      }
  87.  
  88.      private void collectPrefix(Node x, StringBuilder prefix, Queue<String> results)
  89.      {
  90.          if (x == null)
  91.              return;
  92.          if (x.isString)
  93.              results.enqueue(prefix.toString());
  94.          for (char c = 0; c < R; c++)
  95.          {
  96.              prefix.append(c);
  97.              collectPrefix(x.next[c], prefix, results);
  98.              prefix.deleteCharAt(prefix.length() - 1);
  99.          }
  100.      }
  101.  
  102.      public Iterable<String> keyPattern(String pattern)
  103.      {
  104.          Queue<String> results = new Queue<String>();
  105.          collectPattern(root, new StringBuilder(), pattern, results);
  106.          return results;
  107.      }
  108.  
  109.      private void collectPattern(Node x, StringBuilder prefix, String pattern, Queue<String> results)
  110.      {
  111.          if (x == null)
  112.              return;
  113.          int d = prefix.length();
  114.          if (d == pattern.length())
  115.          {
  116.              if (x.isString)
  117.                  results.enqueue(prefix.toString());
  118.              return;
  119.          }
  120.          char c = pattern.charAt(d);
  121.          if (c == '.')
  122.          {
  123.              for (char ch = 0; ch < R; ch++)
  124.              {
  125.                  prefix.append(ch);
  126.                  collectPattern(x.next[ch], prefix, pattern, results);
  127.                  prefix.deleteCharAt(prefix.length() - 1);
  128.              }
  129.          }
  130.          else
  131.          {
  132.              prefix.append(c);
  133.              collectPattern(x.next[c], prefix, pattern, results);
  134.              prefix.deleteCharAt(prefix.length() - 1);
  135.          }
  136.      }
  137.  
  138.      public String longestPrefixOf(String query)
  139.      {
  140.          if (query == null)
  141.              throw new IllegalArgumentException("\n<longestPrefixOf> query == null.\n");
  142.          int length = longestPrefixOfKernel(root, query, 0, -1);
  143.          if (length == -1)
  144.              return null;
  145.          return query.substring(0, length);
  146.      }
  147.  
  148.      private int longestPrefixOfKernel(Node x, String query, int d, int length)
  149.      {
  150.          if (x == null)
  151.              return length;
  152.          if (x.isString)
  153.              length = d;
  154.          if (d == query.length())
  155.              return length;
  156.          return longestPrefixOfKernel(x.next[query.charAt(d)], query, d+1, length);
  157.      }
  158.  
  159.      public void delete(String key)
  160.      {
  161.          if (key == null)
  162.              throw new IllegalArgumentException("\n<delete> key == null.\n");
  163.          root = deleteKernel(root, key, 0);
  164.      }
  165.  
  166.      private Node deleteKernel(Node x, String key, int d)
  167.      {
  168.          if (x == null)
  169.              return null;
  170.          if (d == key.length())
  171.          {
  172.              if (x.isString)
  173.                  n--;
  174.              x.isString = false;
  175.          }
  176.          else
  177.          {
  178.              char c = key.charAt(d);
  179.              x.next[c] = deleteKernel(x.next[c], key, d+1);
  180.          }
  181.          if (x.isString)
  182.              return x;
  183.          for (int c = 0; c < R; c++)
  184.          {
  185.              if (x.next[c] != null)
  186.                  return x;
  187.          }
  188.          return null;
  189.      }
  190.  
  191.      public static void main(String[] args)
  192.      {
  193.          class01 st = new class01();
  194.          for (; !StdIn.isEmpty(); st.put(StdIn.readString()));
  195.          if (st.size() < 100)
  196.          {
  197.              StdOut.println("keys(\"\"):");
  198.              for (String key : st)
  199.                  StdOut.println(key);
  200.              StdOut.println();
  201.          }
  202.  
  203.          StdOut.println("longestPrefixOf(\"shellsort\"):");
  204.          StdOut.println(st.longestPrefixOf("shellsort"));
  205.          StdOut.println();
  206.  
  207.          StdOut.println("longestPrefixOf(\"xshellsort\"):");
  208.          StdOut.println(st.longestPrefixOf("xshellsort"));
  209.          StdOut.println();
  210.  
  211.          StdOut.println("keyPrefix(\"shor\"):");
  212.          for (String s : st.keyPrefix("shor"))
  213.              StdOut.println(s);
  214.          StdOut.println();
  215.  
  216.          StdOut.println("keyPrefix(\"shortening\"):");
  217.          for (String s : st.keyPrefix("shortening"))
  218.              StdOut.println(s);
  219.          StdOut.println();
  220.  
  221.          StdOut.println("keyPattern(\".he.l.\"):");
  222.          for (String s : st.keyPattern(".he.l."))
  223.              StdOut.println(s);
  224.      }
  225.  }

● 三值搜索树

  1.  package package01;
  2.  
  3.  import edu.princeton.cs.algs4.StdIn;
  4.  import edu.princeton.cs.algs4.StdOut;
  5.  import edu.princeton.cs.algs4.Queue;
  6.  
  7.  public class class01<Value>
  8.  {
  9.      private Node<Value> root;
  10.      private int n;
  11.  
  12.      private static class Node<Value>
  13.      {
  14.          private char c;
  15.          private Node<Value> left, mid, right;
  16.          private Value val;
  17.      }
  18.  
  19.      public class01() {}
  20.  
  21.      public boolean contains(String key)
  22.      {
  23.          if (key == null)
  24.              throw new IllegalArgumentException("\n<contains> key == null.\n");
  25.          return get(key) != null;
  26.      }
  27.  
  28.      public Value get(String key)
  29.      {
  30.          if (key == null || key.length() == 0)
  31.              throw new IllegalArgumentException("\n<get> key == null || key.length() == 0.\n");
  32.          Node<Value> x = getKernel(root, key, 0);
  33.          return (x == null) ? null : x.val;
  34.      }
  35.  
  36.      private Node<Value> getKernel(Node<Value> x, String key, int d)
  37.      {
  38.          if (x == null)
  39.              return null;
  40.          char c = key.charAt(d);
  41.          if (c < x.c)
  42.              return getKernel(x.left, key, d);       // 向左右搜索的时候深度不变
  43.          if (c > x.c)
  44.              return getKernel(x.right, key, d);
  45.          if (d < key.length() - 1)
  46.              return getKernel(x.mid, key, d + 1);    // 向中路搜索的时候深度要变化
  47.          return x;
  48.      }
  49.  
  50.      public void put(String key, Value val)
  51.      {
  52.          if (key == null)
  53.              throw new IllegalArgumentException("\n<put> key == null.\n");
  54.          if (!contains(key))
  55.              n++;
  56.          root = putKernel(root, key, val, 0);
  57.      }
  58.  
  59.      private Node<Value> putKernel(Node<Value> x, String key, Value val, int d)
  60.      {
  61.          char c = key.charAt(d);
  62.          if (x == null)
  63.          {
  64.              x = new Node<Value>();
  65.              x.c = c;
  66.          }
  67.          if (c < x.c)
  68.              x.left = putKernel(x.left, key, val, d);
  69.          else if (c > x.c)
  70.              x.right = putKernel(x.right, key, val, d);
  71.          else if (d < key.length() - 1)
  72.              x.mid = putKernel(x.mid, key, val, d + 1);
  73.          else
  74.              x.val = val;
  75.          return x;
  76.      }
  77.  
  78.      public int size()
  79.      {
  80.          return n;
  81.      }
  82.  
  83.      public boolean isEmpty()
  84.      {
  85.          return size() == 0;
  86.      }
  87.  
  88.      public Iterable<String> keys()  // 需要直接从前缀中去字符参加比较，不能用 keyPrefix("")
  89.      {
  90.          Queue<String> queue = new Queue<String>();
  91.          collectPrefix(root, new StringBuilder(), queue);
  92.          return queue;
  93.      }
  94.  
  95.      public Iterable<String> keyPrefix(String prefix)
  96.      {
  97.          Queue<String> queue = new Queue<String>();
  98.          Node<Value> x = getKernel(root, prefix, 0);
  99.          if (x == null)
  100.              return queue;
  101.          if (x.val != null)
  102.              queue.enqueue(prefix);
  103.          collectPrefix(x.mid, new StringBuilder(prefix), queue);
  104.          return queue;
  105.      }
  106.  
  107.      private void collectPrefix(Node<Value> x, StringBuilder prefix, Queue<String> queue)
  108.      {
  109.          if (x == null)
  110.              return;
  111.          collectPrefix(x.left, prefix, queue);
  112.          if (x.val != null)
  113.              queue.enqueue(prefix.toString() + x.c);
  114.          collectPrefix(x.mid, prefix.append(x.c), queue);
  115.          prefix.deleteCharAt(prefix.length() - 1);
  116.          collectPrefix(x.right, prefix, queue);
  117.      }
  118.  
  119.      public Iterable<String> keyPattern(String pattern)
  120.      {
  121.          Queue<String> queue = new Queue<String>();
  122.          collectPattern(root, new StringBuilder(), 0, pattern, queue);
  123.          return queue;
  124.      }
  125.  
  126.      private void collectPattern(Node<Value> x, StringBuilder prefix, int i, String pattern, Queue<String> queue)
  127.      {
  128.          if (x == null)
  129.              return;
  130.          char c = pattern.charAt(i);
  131.          if (c == '.' || c < x.c)                                // 分解为 c 和 x.c 的三种情况，插上 '.' 的情况
  132.              collectPattern(x.left, prefix, i, pattern, queue);
  133.          if (c == '.' || c == x.c)
  134.          {
  135.              if (i == pattern.length() - 1 && x.val != null)
  136.                  queue.enqueue(prefix.toString() + x.c);
  137.              if (i < pattern.length() - 1)
  138.              {
  139.                  collectPattern(x.mid, prefix.append(x.c), i + 1, pattern, queue);
  140.                  prefix.deleteCharAt(prefix.length() - 1);
  141.              }
  142.          }
  143.          if (c == '.' || c > x.c)
  144.              collectPattern(x.right, prefix, i, pattern, queue);
  145.      }
  146.  
  147.      public String longestPrefixOf(String query)
  148.      {
  149.          if (query == null || query.length() == 0)
  150.              throw new IllegalArgumentException("\n<longestPrefixOf> query == null || query.length() == 0.\n");
  151.          int length = 0;
  152.          Node<Value> x = root;
  153.          for (int i = 0; x != null && i < query.length();)       // i 为当前匹配的长度
  154.          {
  155.              char c = query.charAt(i);
  156.              if (c < x.c)
  157.                  x = x.left;
  158.              else if (c > x.c)
  159.                  x = x.right;
  160.              else
  161.              {
  162.                  i++;
  163.                  if (x.val != null)
  164.                      length = i;
  165.                  x = x.mid;
  166.              }
  167.          }
  168.          return query.substring(0, length);
  169.      }
  170.  
  171.      public static void main(String[] args)
  172.      {
  173.          class01<Integer> st = new class01<Integer>();
  174.          for (int i = 0; !StdIn.isEmpty(); i++)
  175.          {
  176.              String key = StdIn.readString();
  177.              st.put(key, i);
  178.          }
  179.  
  180.          if (st.size() < 100)
  181.          {
  182.              StdOut.println("keys(\"\"):");
  183.              for (String key : st.keys())
  184.                  StdOut.println(key + " " + st.get(key));
  185.              StdOut.println();
  186.          }
  187.  
  188.          StdOut.println("longestPrefixOf(\"shellsort\"):");
  189.          StdOut.println(st.longestPrefixOf("shellsort"));
  190.          StdOut.println();
  191.  
  192.          StdOut.println("longestPrefixOf(\"shell\"):");
  193.          StdOut.println(st.longestPrefixOf("shell"));
  194.          StdOut.println();
  195.  
  196.          StdOut.println("keysWithPrefix(\"shor\"):");
  197.          for (String s : st.keyPrefix("shor"))
  198.              StdOut.println(s);
  199.          StdOut.println();
  200.  
  201.          StdOut.println("keysThatMatch(\".he.l.\"):");
  202.          for (String s : st.keyPattern(".he.l."))
  203.              StdOut.println(s);
  204.      }
  205.  }

《算法》第五章部分程序 part 4的更多相关文章

  1. 《算法》第五章部分程序 part 3

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,字符串高位优先排序(美国国旗排序) ● 美国国旗排序 package package01; import edu.princeton.cs.algs4 ...

  2. 《算法》第五章部分程序 part 8

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,适用于基因序列的 2-Bit 压缩算法,行程长压缩算法,Huffman 压缩算法,LZW 压缩算法 ● 适用于基因序列的 2-Bit 压缩算法 pac ...

  3. 《算法》第五章部分程序 part 7

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,字符串的二进制表示.十六进制表示.图形表示 ● 二进制表示 package package01; import edu.princeton.cs.al ...

  4. 《算法》第五章部分程序 part 6

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,非确定性有穷自动机(NFA),grep 命令(利用 NFA 匹配) ● 非确定性有穷自动机(NFA) package package01; impor ...

  5. 《算法》第五章部分程序 part 5

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,Knuth-Morris-Pratt 无回溯匹配,Boyer - Moore 无回溯匹配,Rabin - Karp 指纹匹配 ● Knuth-Morr ...

  6. 《算法》第五章部分程序 part 2

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,字符串高位优先排序(计数 + 插排),(原地排序),(三路快排,与前面的三路归并排序相同) ● 计数 + 插排 package package01; ...

  7. 《算法》第五章部分程序 part 1

    ▶ 书中第五章部分程序,包括在加上自己补充的代码,字母表类,字符串低位优先排序(桶排) ● 字母表类 package package01; import edu.princeton.cs.algs4. ...

  8. Gradle 1.12用户指南翻译——第四十五章. 应用程序插件

    本文由CSDN博客貌似掉线翻译,其他章节的翻译请参见: http://blog.csdn.net/column/details/gradle-translation.html 翻译项目请关注Githu ...

  9. 《算法》第一章部分程序 part 1

    ▶ 书中第一章部分程序,加上自己补充的代码,包括若干种二分搜索,寻找图上连通分量数的两种算法 ● 代码,二分搜索 package package01; import java.util.Arrays; ...

随机推荐

  1. eval 日期对象

    js中,eval相当于python中的eval(表达式)和exec(代码)的集合. var d = new Date();    #申明一个新的日期对象,方便之后调用,它的方法getDate();ge ...

  2. HMM（隐马尔科夫模型）与分词、词性标注、命名实体识别

    转载自 http://www.cnblogs.com/skyme/p/4651331.html HMM(隐马尔可夫模型)是用来描述隐含未知参数的统计模型,举一个经典的例子:一个东京的朋友每天根据天气{ ...

  3. Base64 转 图片

    static void Main(string[] args) { string s = "iVBORw0KGgoAAAANSUhEUgAAAFAAAABQCAIAAAABc2X6AAAAC ...

  4. html框内文字垂直居中的方法

    由于无法知道框内文字的高度,很难确定垂直空间的位置.vertical-align:middle仅对td元素有效,无论单行和多行均可实现垂直居中.

  5. 【事务隔离级别】数据库事务隔离级别-UNDERSTANDING ISOLATION LEVELS

    参考链接:ISOLATION LEVELS ISOLATION LEVELS In a database system, concurrent transactions are processed i ...

  6. vue之v-model

    上一篇文章总结了v-bind的用法,我们发现v-bind实现了数据的单向绑定,将vue实例中的数据同元素属性值进行绑定,今天我们将总结vue中的数据双向绑定v-model. v-model实现双向绑定 ...

  7. flume使用之httpSource

    flume自带很长多的source,如:exe.kafka...其中有一个非常简单的source——httpsource,使用httpSource,flume启动后会拉起一个web服务来监听指定的ip ...

  8. 廖雪峰Java5集合-3Map-Properties的使用

    Properties用于读取配置 properties文件只能使用ASCII码 #表示注释 可以从文件系统读取.properties文件 Properties props = new Properti ...

  9. JQuery中Ajax的Post提交在IE下中文乱码的解决方法

    原文地址:http://www.bitscn.com/pdb/ajax/316671.html 引言: 在JQuery的Ajax POST请求中,进行请求,其中的中文在后台,显示为乱码,该如何解决呢? ...

  10. [UE4]UE4是单线程的吗？

    并行与串行 并行是同时在执行,串行是一个接一个地执行 进程与线程 笼统的说,进程是游戏的一次运行,线程是进程里面分配CPU资源的最小单位 类比 1.把世界看成一台计算机 2.世界里面的人可以看成是一个 ...