【数据结构】关于前缀树(单词查找树，Trie)

前缀树的说明和用途

　　前缀树又叫单词查找树，Trie，是一类常用的数据结构，其特点是以空间换时间，在查找字符串时有极大的时间优势，其查找的时间复杂度与键的数量无关，在能找到时，最大的时间复杂度也仅为键的长度+1，在找不到时可以小于键的长度。前缀树又被称为R向查找树，因为其树中的每个节点都有R个链接，但每个节点都只有一个父节点。前缀树的使用也很广泛，其常见问题有单词拆分，实现前缀树等

实现API

　　单词查找树的API将使用符号表的通用API，以体现其功能的共性，在解决具体问题时稍做变动即可。

public class String<T>	说明
public StringTrie()	构造函数
public void put(String key, T value)	向前缀树中添加一个键值对
public T get(String key)	获取给出的键对应的值，如果键不存在，返回null
public void delete(String key)	删除给出的键对应的值，根据其在树中的结构，可能会删除键
public Iterable<String> keys()	获取所有的键
public Iterable<String> keysWithPrefix(String pre)	获取给出指定前缀对应的键

 

重要API的说明实现

　　本API的实现使用的都是递归操作，在树中，递归操作都会是简洁易懂的。最开始要说明的是树的节点类，其是构成树的基础。代码如下，每个节点都包含值域和指针域，不同的指针域是一个数组，其长度代表的就是给出的字母表的长度，比如键都是由英文小写字母表示的话，那字母表长度就为26.

//节点类
//Java泛型不支持数组
class Node {
    Object value;
    Node[] nextNodes;

    Node(int n) {
        nextNodes = new Node[n];
    }
}

 

添加键值对

　　向树中添加一个键值对，首先，如果当前根节点为空，这里的根节点并不单单指整棵树的根节点，也可能是当前子树的根节点，根节点为空，则先实例化一个根节点。利用一个index记录深度，也就是应当检查key中的第index+1个字符了，那么就可以向下递归当前节点的第n的子结点，n代表的就是第index+1个字符在字母表中的位置.

/**
 * 放入一个键值对，值的类型为T，键类型确定为String
 * */
public void put(String key, T value) {
    root = put(key, value, root, 0);
}

private Node put(String key, T value, Node node, int index) {
    if (node == null) node = new Node(count);
    if (index == key.length()) {
        node.value = value;
        return node;
}
    char cur = key.charAt(index);
    node.nextNodes[cur] = put(key, value, node.nextNodes[cur], ++index);
    return node;
}

 

根据键获取值

　　获取同样可以使用递归，如果当前根结点为空，说明给出的key中包含了树中没有的字符，可以直接返回null。如果不为空，且已经递归到了键的最后一个字符，当前节点到树的根结点构成的字符流就是给出的key，可以返回当前节点，如果不是最后一个字符，可以重复递归操作。

/**
* 获得以key对应的值，没找到则返回null
* */
public T get(String key) {
    Node result = get(key, root, 0);
    if (result == null) return null;
    return (T) result.value;
}

private Node get(String key, Node node, int index) {
    if (node == null) return null;
    if (index == key.length()) return node;
    char cur = key.charAt(index);
    return get(key, node.nextNodes[cur], ++index);
}

 

删除操作

　　删除操作也使用的是递归，但操作设及到了要不要在树中删除某个字符，即删除这个键。在我们找到键对应的节点后，如果这个节点有值，那么直接将值赋空，但是如何处理这个节点呢，那就要检查其是否有子结点存在，即这个字符还存在于其他键中。如果没有子结点，那么就可以删除这个节点，并返回上层，检查其父节点是否也已经没有子结点了，没有也删除父节点，重复操作即可。

/**
* 删除一个键值对
* */
public void delete(String key) {
        root = delete(key, root, 0);
}

private Node delete(String key, Node node, int index) {
    if (node == null) return null;
    if (index == key.length()) {
        node.value = null;//找到key后，将key对应的value赋空
    }else {
        char cur = key.charAt(index);
        node.nextNodes[cur] = delete(key, node.nextNodes[cur], ++index);//在子树中递归找key
    }
    if (node.value != null) return node;//如果当前node组成的key有值对应则可以直接返回
    for (int i = 0;i < node.nextNodes.length;i++) {
       if (node.nextNodes[i].value != null) return node;//如果当前node还有子树则保留当前节点返回
    }
    return null;//当前key没有任何value，其子结点也没有，则删除这个key。
}

 

根据条件获取键

　　获取全部的键其实就是获取以空字符为开头的键，那如果获取以某个字符串开头的键呢，其实如果我们先利用私有的get函数，根据给出的前缀，就可以直接获取到前缀最后一个字符代表的那个节点。再获取当前节点的全部子树所代表的key值，那就是我们要的答案。获取当前节点的全部子树代表的key值，就要在递归到当前层是用已有的pre加上当前字符。如果节点的value不为空，代表这个节点到根节点组成的字符串是一个合法的key。

/**
* 获得全部的key
* */
public Iterable<String> keys() {
    //获取所有的keys，就是收集以空字符开头的key
    return keysWithPrefix("");
}
/**
* 获得以某个字符串开头的全部keys
* */
public Iterable<String> keysWithPrefix(String pre) {
    Queue<String> queue = new LinkedList<>();
    //调用get，代表先到达前缀所在的那个节点，再向下收集
    collect(get(pre, root, 0), pre, queue);
    return queue;
}

//在给定前缀的节点后收集所有的字符
private void collect(Node node, String pre, Queue<String> queue) {
    if (node == null) return;
    if (node.value != null) queue.add(pre);//找到了一个以pre为前缀的key
    for (int i = 0;i < node.nextNodes.length;i++) {
        //此处因为字母表的原因，只写出大概意思，pre值应该更新为pre加上当前子结点代表的字符
        collect(node.nextNodes[i], pre+i, queue);
    }
}

 

全部实现

public class StringTrie<T> {

    private Node root;
    private int count;

    public StringTrie() {
        this.count = 26;//默认查找树只包含26个小写字母
        root = new Node(count);
    }
    public StringTrie(int count) {
        this.count = count;
        root = new Node(count);
    }

    /**
     * 放入一个键值对，值的类型为T，键类型确定为String
     * */
    public void put(String key, T value) {
        root = put(key, value, root, 0);
    }

    private Node put(String key, T value, Node node, int index) {
        if (node == null) node = new Node(count);
        if (index == key.length()) {
            node.value = value;
            return node;
        }
        char cur = key.charAt(index);
        node.nextNodes[cur] = put(key, value, node.nextNodes[cur], ++index);
        return node;
    }
    /**
     * 获得以key对应的值，没找到则返回null
     * */
    public T get(String key) {
        Node result = get(key, root, 0);
        if (result == null) return null;
        return (T) result.value;
    }

    private Node get(String key, Node node, int index) {
        if (node == null) return null;
        if (index == key.length()) return node;
        char cur = key.charAt(index);
        return get(key, node.nextNodes[cur], ++index);
    }

    /**
     * 删除一个键值对
     * */
    public void delete(String key) {
        root = delete(key, root, 0);
    }

    private Node delete(String key, Node node, int index) {
        if (node == null) return null;
        if (index == key.length()) {
            node.value = null;//找到key后，将key对应的value赋空
        }else {
            char cur = key.charAt(index);
            node.nextNodes[cur] = delete(key, node.nextNodes[cur], ++index);//在子树中递归找key
        }
        if (node.value != null) return node;//如果当前node组成的key有值对应则可以直接返回
        for (int i = 0;i < node.nextNodes.length;i++) {
            if (node.nextNodes[i].value != null) return node;//如果当前node还有子树则保留当前节点返回
        }
        return null;//当前key没有任何value，其子结点也没有，则删除这个key。
    }

    /**
     * 获得全部的key
     * */
    public Iterable<String> keys() {
        //获取所有的keys，就是收集以空字符开头的key
        return keysWithPrefix("");
    }
    /**
     * 获得以某个字符串开头的全部keys
     * */
    public Iterable<String> keysWithPrefix(String pre) {
        Queue<String> queue = new LinkedList<>();
        //调用get，代表先到达前缀所在的那个节点，再向下收集
        collect(get(pre, root, 0), pre, queue);
        return queue;
    }

    //在给定前缀的节点后收集所有的字符
    private void collect(Node node, String pre, Queue<String> queue) {
        if (node == null) return;
        if (node.value != null) queue.add(pre);//找到了一个以pre为前缀的key
        for (int i = 0;i < node.nextNodes.length;i++) {
            //此处因为字母表的原因，只写出大概意思，pre值应该更新为pre加上当前子结点代表的字符
            collect(node.nextNodes[i], pre+i, queue);
        }
    }

}
//节点类
//Java泛型不支持数组
class Node {
    Object value;
    Node[] nextNodes;

    Node(int n) {
        nextNodes = new Node[n];
    }
}