数据结构(10)-TrieTree(字典树)的实现

Let’s Look Look What’s TrieTree!

1.1 什么是TrieTree

TrieTree又被称为字典树/单词查找树/前缀树,常用来做大量的词频分析以及排序大量字符串,是哈希树的一种变种形式,它最大的特点就是每一个节点中只存放字符串的一个字符,而树的一条边即该字符串或者是其前缀,这样的特性使得字典树被广泛地应用于海量字符串处理程序中.

1.2 TrieTree的实现

要实现TrieTree,首先需要定义其基础节点类:

private class Node {
        //该节点代表的字符串前缀出现的次数
        int count;
        //以该节点为结束的字符的数量
        int wordCount;
        //记录该字符
        char value;
        //标识该节点是否代表单词结尾
        private boolean isEnd;
        //该节点的孩子节点
        Node[] child;

        private Node() {
            count = 1;
            isEnd = false;
            child = new Node[MAX_SIZE];
        }
    }

其次是TrieTree成员变量的定义:

    //每个节点下最多只能有从a-z这26个字符
    private static final int MAX_SIZE = 26;
    //字典树空根节点
    private  Node head;

再次是构造方法:

public TrieTree() {
        //初始化Trie树头节点
        Node node = new Node();
        node.count = 1;
        //根节点不包含单词字符
        node.value = '*';
        //声明子节点
        node.child = new Node[MAX_SIZE];
        head = node;
    }

1.3 重要方法

• 1.插入字符串

    public void insert(String word) {
        if (word == null || "".equals(word)) {
            throw new IllegalArgumentException("word cant be null");
        }
        buildNode(head, word);
    }

    private void buildNode(Node node, String word) {
        char[] letters = word.toLowerCase().toCharArray();
        for (int i = 0; i < letters.length; i++) {
            //定位索引
            int index = letters[i] - 'a';
            if (node.child[index] != null) {
                //已存在该字符节点,出现次数+1
                node.child[index].count++;
            } else {
                //不存在该字符及诶单,创建
                node.child[index] = new Node();
            }
            //为相应节点赋值并让其往下走
            node.child[index].value = letters[i];
            node = node.child[index];
        }
        node.isEnd = true;
        node.wordCount++;
    }

• 2.查找前缀出现次数

public int findPreCount(String pre) {
        if (pre == null || "".equals(pre.trim())) return -1;
        return _findPreCount(head, pre);
    }

    private int _findPreCount(Node node, String pre) {
        char[] letters = pre.toLowerCase().toCharArray();
        for (int i = 0; i < letters.length; i++) {
            int index = letters[i] - 'a';
            if (node.child[index] != null) {
                //存在该字符节点,继续往下找
                node = node.child[index];
            } else {
                //无法匹配,则返回0
                return 0;
            }
        }
        return node.count;
    }

• 3.查找特定字符串出现次数

    public int findWordCount(String word) {
        if (word == null || "".equals(word.trim())) return -1;
        return _findWordCount(head, word);
    }

    private int _findWordCount(Node head, String word) {
        char[] chars = word.toLowerCase().toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (head.child[chars[i] - 'a'] == null) return 0;
            head = head.child[chars[i] - 'a'];
        }
        return head.isEnd ? head.wordCount : 0;
    }

• 4.全体词频统计

public Map<String, Integer> wordCount() {
        Map<String, Integer> res = new HashMap<>();
        //使用回溯进行搜索
        backTrace(res, head, "");
        return res;
    }

    private void backTrace(Map<String, Integer> res, Node head, String oneRes) {
        if (head != null) {
            //回溯终止条件
            if (head.isEnd) {
                res.put(oneRes, head.wordCount);
            }

            //回溯搜索过程
            Node[] child = head.child;
            for (int i = 0; i < child.length; i++) {
                if (child[i] != null) {
                    //还原字符
                    char ch = (char)(i + 'a');
                    //回溯搜索
                    backTrace(res, child[i], oneRes + ch);
                }
            }
            return;
        }
    }

1.3 时间复杂度

1. 插入数据
插入数据的时间复杂度依赖于节点的遍历搜索结果,所以与单词的长度相关,为O(len)
2.查询数据
查询数据的时间复杂度依赖于需要查询的字符串长度,需要解析字符串的每个字符去搜索,所以为O(len)

1.4 经典应用

• 有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
  -----答:先使用TrieTree进行词频统计,再使用最小堆进行Top 100统计,最后求得词频最高的100个词.

• 1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？
  -----答:先将这些字符串放入TrieTree中,然后使用回溯搜索获取所有的字符串即可.

1.5 完整代码

/**
 * @Auther: ARong
 * @Date: 19-9-3 上午9:57
 * @Description: 使用Java实现字典树
 **/
public class TrieTree {
    //每个节点下最多只能有从a-z这26个字符
    private static final int MAX_SIZE = 26;
    //字典树空根节点
    private  Node head;
    //字典树节点
    private class Node {
        //该节点代表的字符串前缀出现的次数
        int count;
        //以该节点为结束的字符的数量
        int wordCount;
        //记录该字符
        char value;
        //标识该节点是否代表单词结尾
        private boolean isEnd;
        //该节点的孩子节点
        Node[] child;

        private Node() {
            count = 1;
            isEnd = false;
            child = new Node[MAX_SIZE];
        }
    }

    public TrieTree() {
        //初始化Trie树头节点
        Node node = new Node();
        node.count = 1;
        //根节点不包含单词字符
        node.value = '*';
        //声明子节点
        node.child = new Node[MAX_SIZE];
        head = node;
    }

    /**
     * @auther: Arong
     * @description: 在Trie树中插入字符串
     * @param: [word]
     * @return: void
     * @date: 上午10:09 19-9-3
     */
    public void insert(String word) {
        if (word == null || "".equals(word)) {
            throw new IllegalArgumentException("word cant be null");
        }
        buildNode(head, word);
    }
    /**
     * @auther: Arong
     * @description: 用word构建字典树
     * @param: [head, word]
     * @return: void
     * @date: 上午10:15 19-9-3
     */
    private void buildNode(Node node, String word) {
        char[] letters = word.toLowerCase().toCharArray();
        for (int i = 0; i < letters.length; i++) {
            //定位索引
            int index = letters[i] - 'a';
            if (node.child[index] != null) {
                //已存在该字符节点,出现次数+1
                node.child[index].count++;
            } else {
                //不存在该字符及诶单,创建
                node.child[index] = new Node();
            }
            //为相应节点赋值并让其往下走
            node.child[index].value = letters[i];
            node = node.child[index];
        }
        node.isEnd = true;
        node.wordCount++;
    }

    /**
     * @auther: Arong
     * @description: 查找前缀出现次数
     * @param: [pre]
     * @return: data_struct.TrieTree.Node
     * @date: 上午10:30 19-9-3
     */
    public int findPreCount(String pre) {
        if (pre == null || "".equals(pre.trim())) return -1;
        return _findPreCount(head, pre);
    }

    /**
     * @auther: Arong
     * @description: 查找前缀出现次数
     * @param: [node, pre]
     * @return: void
     * @date: 上午10:31 19-9-3
     */
    private int _findPreCount(Node node, String pre) {
        char[] letters = pre.toLowerCase().toCharArray();
        for (int i = 0; i < letters.length; i++) {
            int index = letters[i] - 'a';
            if (node.child[index] != null) {
                //存在该字符节点,继续往下找
                node = node.child[index];
            } else {
                //无法匹配,则返回0
                return 0;
            }
        }
        return node.count;
    }

    /**
     * @auther: Arong
     * @description: 搜索特定单词出现的次数
     * @param: [word]
     * @return: int
     * @date: 下午8:24 19-9-5
     */
    public int findWordCount(String word) {
        if (word == null || "".equals(word.trim())) return -1;
        return _findWordCount(head, word);
    }

    private int _findWordCount(Node head, String word) {
        char[] chars = word.toLowerCase().toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (head.child[chars[i] - 'a'] == null) return 0;
            head = head.child[chars[i] - 'a'];
        }
        return head.isEnd ? head.wordCount : 0;
    }

    /**
     * @auther: Arong
     * @description: 全部词频数量统计
     * @param: []
     * @return: java.util.List<java.util.Map<java.lang.String,java.lang.Integer>>
     * @date: 下午9:33 19-9-5
     */
    public Map<String, Integer> wordCount() {
        Map<String, Integer> res = new HashMap<>();
        //使用回溯进行搜索
        backTrace(res, head, "");
        return res;
    }

    private void backTrace(Map<String, Integer> res, Node head, String oneRes) {
        if (head != null) {
            //回溯终止条件
            if (head.isEnd) {
                res.put(oneRes, head.wordCount);
            }

            //回溯搜索过程
            Node[] child = head.child;
            for (int i = 0; i < child.length; i++) {
                if (child[i] != null) {
                    //还原字符
                    char ch = (char)(i + 'a');
                    //回溯搜索
                    backTrace(res, child[i], oneRes + ch);
                }
            }
            return;
        }
    }
}