Arthur's Blog

  Trie树本身就是一个很迷人的数据结构，何况是其改进的方案。

  在本博客中我会从DAT(Double-Array Tire)的原理开始，并结合其源代码对DAT的状态转移过程进行解析。如果因此你能从我的博客中有所收获或启发，It's my pleasure.

本文链接：http://blog.csdn.net/lemon_tree12138/article/details/49281865 -- Q-WHai 
                                                                 --转载请注明出处

特别说明：
0.关于Trie树的构建及使用，请移步：http://blog.csdn.net/lemon_tree12138/article/details/49177509

1.本文参考：

(0)双数组Trie树(DoubleArrayTrie)Java实现-码农场

(1)基于双数组Trie树算法的字典改进和实现 - 期刊论文 - 道客巴巴

图形展示及说明：
0.朴素Trie树示意图：
  

  从上图中可以看到，这样的树结构是非常稀疏的。造成了资源的巨大浪费。

1.DAT节点示意图：
  

  这里"NULL"代表结束。

DAT原理说明：
0.简介：
  在学习DAT(Double-Array Trie)之前，如果你对Tire树的了解还是处在一个模糊的状态，那么我想你现在可以移步到本人的另一篇博客《数据结构：字典树的基本使用》，在对Trie树有一个基本的了解之后，再来学习本文的内容应该会更加轻松自如(如果你对Trie树已经有了或浅或深的了解，那么可以直接看下面的内容了)。

  DAT的本质是一个有限自动机(因为博主在学习DAT之前对自动机的相关内容也是一知半解，在学习DAT的过程，难免有一些痛苦。博主也紧追一下这方面的知识，也会在后面的博客中写一些相关的博文).我们要构建一些状态，用于状态的自动转移。顾名思义，在DAT中用的就是双数组：base数组和check数组。双数组的分工是：base负责记录状态，用于状态转移；check负责检查各个字符串是否是从同一个状态转移而来，当check[i]为负值时，表示此状态为字符串的结束。

  你可能问一个这样的问题：那么base数组和check数组是怎么来进行状态转移呢？

  请看下面关于DAT双数组的计算过程。

1.DAT中双数组的计算过程：
假定有字符串状态s,当前字符串状态为t，假定t加了一个字符c就等于状态tc，加了一个字符x等于状态tx，那么有：
base[t] + c.code = base[tc]
base[t] + x.code = base[tx]
check[tc] = check[tx]

上面的几个等式就是状态base和它的转移方程。

Double-Array Trie源码解析：
0.特别说明：
  DAT中的节点信息如下：

private static class Node {
    int code;
    int depth;
    int left;
    int right;
}
  code: 代表节点字符的编码。如：'a'.code = 97
  depth: 代表节点所在树的深度。root.depth = 0

  left: 代表节点的子节点在字典中范围的左边界

  rigth: 代表节点的子节点在字典中范围的右边界

1.DAT的创建
  和Trie树一样，DAT的创建只是创建Root的过程。如下：

public int build(List<String> _key) {
key = _key;
...
resize(65536 * 32);

...

Node root_node = new Node();
root_node.left = 0;
root_node.right = keySize;
root_node.depth = 0;

...

return error_;
}

2.为节点parent生成子节点
  在生成子节点的过程中，如果碰到parent='B',而'B'又是某一个key的结尾。该如何办呢？

  比如：比如若以"一举"中的'举'字符为parent，那么parent.depth = 2，"一举".length = 2.

  遇到这种情况，我们就需要对其进行过滤操作，过程如下：

String tmp = key.get(i);

int currCode = 0;
if (tmp.length() != parent.depth) {
    currCode = (int) tmp.charAt(parent.depth) + 1;
}
完整过程：

private int fetch(Node parent, List<Node> siblings) {
...

int prevCode = 0;

for (int i = parent.left; i < parent.right; i++) {
    if (key.get(i).length() < parent.depth) {
    continue;
}

String tmp = key.get(i);

int currCode = 0;
if (tmp.length() != parent.depth) {
currCode = (int) tmp.charAt(parent.depth) + 1;
}

...

if (currCode != prevCode || siblings.size() == 0) {
    Node tmp_node = new Node();
    tmp_node.depth = parent.depth + 1;
    tmp_node.code = currCode;
    tmp_node.left = i;
    if (siblings.size() != 0) {
        siblings.get(siblings.size() - 1).right = i;
    }

    siblings.add(tmp_node);
    }

    prevCode = currCode;
}

if (siblings.size() != 0) {
    siblings.get(siblings.size() - 1).right = parent.right;
}

return siblings.size();
}

3.向Trie树中插入子节点
  在DAT的创建过程中，insert是关键部分。

  在insert操作里，我们使用了递归的思路来解决问题。为什么要利用递归呢？因为在我们状态转移的过程中，父节点的base值需要依赖子返回的begin值，因为在DAT中，code[null] = 0，所以也可以认为是依赖于子节点的check值，如此反复，层层嵌套。关于这一点在下面的结构图展示中更容易体现。

(0)check的合法性检查
  之前我们说check数组是为了检查各个字符串是否是从同一个状态转移而来，但是，要如何检查呢？看下面这段代码：

outer: while (true) {
    position++;

if (check[position] != 0) {
    continue;
} else if (first == 0) {
    ...
}

begin = position - siblings.get(0).code; // 当前位置离第一个兄弟节点的距离
...
for (int i = 1; i < siblings.size(); i++) {
    if (check[begin + siblings.get(i).code] != 0) {
        continue outer;
    }
}

break;
}
  这里的position即在数组中的下标。可以看到这是一个循环遍历的过程，我们在一个合适的位置开始，逐步地尝试check值是否合法，找到第一个合法的begin值即可。
  而check[i]合法的条件就是check[i]是否为0。如果check[i]不为0，则说明此位置已经被别的状态占领了，需要更换到下一个位置。
(1)计算所有子节点的check值

for (int i = 0; i < siblings.size(); i++) {
check[begin + siblings.get(i).code] = begin;
}
(2)计算所有子节点的base值

private int insert(List<Node> siblings) {
...

for (int i = 0; i < siblings.size(); i++) {
List<Node> new_siblings = new ArrayList<Node>();

if (fetch(siblings.get(i), new_siblings) == 0) {
base[begin + siblings.get(i).code] = (value != null) ? (-value[siblings.get(i).left] - 1) : (-siblings.get(i).left - 1);
...
} else {
int h = insert(new_siblings);
base[begin + siblings.get(i).code] = h;
}
}

return begin;
}
在这一步中，大家可以很明显地看到，这是一个递归的过程。我们需要获得子节点的begin值。

采用递归之后，我们的DAT节点的状态转移过程

(3)整体的insert过程：

private int insert(List<Node> siblings) {
...

// check的合法性检查

...

// 计算所有子节点的check值

// 计算所有子节点的base值

...
}

DAT中双数组的状态转移过程

4.前缀查询
  现在假设待查找字符串T="走廊里的壁画"，我们需要在之前的字典中查找所有是T前缀的字符串。我们要怎么做呢？

  其实在上面的双数组状态转移过程图中，我们可以很清楚地找到一条满足条件的路径.如下：

关键代码如下：

public List<Integer> commonPrefixSearch(String key, int pos, int len, int nodePos) {
...

int b = base[nodePos];
...

for (int i = pos; i < len; i++) {
p = b;
n = base[p];

if (b == check[p] && n < 0) {
result.add(-n - 1);
}

p = b + (int) (keyChars[i]) + 1;
if (b == check[p]) {
b = base[p];
} else {
return result;
}
}

p = b;
n = base[p];

if (b == check[p] && n < 0) {
result.add(-n - 1);
}

return result;
}

5.关键词智能提示：
  在上面“前缀查询”的例子中，我们的匹配字符串中比较长，在还没到字符串的最后一位就遇到状态停止标志。而如果匹配字符串比较短，我就还可以做一些其他的事情了，比如常见的搜索引擎中关键词智能提示。

  过程就是在上一步的基础上，把终止循环的条件修改为直到遇到一个状态停步标志.这样我们就可以在遍历整条路径。

  这个功能，在源码中没有涉及。而本文的目的是在于解释DAT的原理和其状态转移的过程。所以，这里就暂不贴代码了。不过，在后期的《搜索引擎：对用户输入有误的关键词进行纠错处理》博客中应该会有所涉及。感兴趣的朋友，可以关注下。
---------------------
作者：Q-WHai
来源：CSDN
原文：https://blog.csdn.net/lemon_tree12138/article/details/49281865
版权声明：本文为博主原创文章，转载请附上博文链接！