前缀树

最新推荐文章于 2024-04-21 20:43:30 发布

故事凌

最新推荐文章于 2024-04-21 20:43:30 发布

阅读量207

点赞数

本文链接：https://blog.csdn.net/weixin_37700260/article/details/106719927

版权

今天刷算法题, 前缀树, 字典树, 真的是一个好东西啊, 在思想上又给自己打开了一个新的思路啊!

前缀树被广泛的运用在字典查找中, 也被称为字典树

举例: 给定一系列字符串, 这些字符串构成了一种字典, 要求你在这个字典当中找出所有以"ABC"开头的字符串

解法一: 暴利搜索

直接遍历一遍字典, 然后逐个判断每个字符串是否由"ABC"开头, 假设字典很大, 有N个单词, 要对比的不是"ABC", 而是任意的, 那不妨假设所要对比的开头平均长度为M, 那么时间复杂度是O(M x N)

解法二: 前缀树

如果用前缀树头帮助对字典的存储进行优化, 那么可以把搜索的时间复杂度下降为O(M), 其中M表示字典里最长的那个单词的字符个数, 很多情况下, 字典里的单词个数N是远远大于M的, 因此, 前缀树在各种场合中是非常高效的.

经典应用

网站的搜索框会罗列出以搜索文字作为开头的相关搜索信息, 这里运用了前缀树进行后端的快速检索
汉字拼音输入法的联想输出功能也是运用了前缀树

Trie (发音为 "try") 或前缀树是一种树数据结构，用于检索字符串数据集中的键。这一高效的数据结构有多种应用：

1. 自动补全

2. 拼写检查

3. IP路由(最长前缀匹配)

4. T9(九宫格) 打字预测

5. 单词游戏

还有其他的数据结构，如平衡树和哈希表，使我们能够在字符串数据集中搜索单词。为什么我们还需要 Trie 树呢？尽管哈希表可以在 O(1)O(1) 时间内寻找键值，却无法高效的完成以下操作：

找到具有同一前缀的全部键值。
按词典序枚举字符串的数据集。

Trie 树优于哈希表的另一个理由是，随着哈希表大小增加，会出现大量的冲突，时间复杂度可能增加到 O(n)O(n)，其中 nn 是插入的键的数量。与哈希表相比，Trie 树在存储多个具有相同前缀的键时可以使用较少的空间。此时 Trie 树只需要 O(m)O(m) 的时间复杂度，其中 mm 为键长。而在平衡树中查找键值需要 O(m \log n)O(mlogn) 时间复杂度。

Trie 树的结点结构

Trie 树是一个有根的树，其结点具有以下字段：。

最多 RR 个指向子结点的链接，其中每个链接对应字母表数据集中的一个字母。本文中假定 RR 为 26，小写拉丁字母的数量。
布尔字段，以指定节点是对应键的结尾还是只是键前缀。

前缀树的java代码:

class TrieNode {

    // R links to node children
    // 连接到 R 条子节点
    private TrieNode[] links;

    // 最初只有26个字符, 最多有26条子节点
    private final int R = 26;

    // 判断是否是一个单词是否结束
    private boolean isEnd;

   // 构造器, 初始化的时候, 都要创建26子节点
    public TrieNode() {
        links = new TrieNode[R];
    }

    // 判断子节点是否存在, ch - 'a' 是0-25
    public boolean containsKey(char ch) {
        return links[ch -'a'] != null;
    }
    // 获取到子节点
    public TrieNode get(char ch) {
        return links[ch -'a'];
    }
    // 往子节点中放元素
    public void put(char ch, TrieNode node) {
        links[ch -'a'] = node;
    }
    // 设置为单词的结束符
    public void setEnd() {
        isEnd = true;
    }
    // 获取单词的结束符
    public boolean isEnd() {
        return isEnd;
    }
}

举例: 假如有一个字典, 字典里面有下面词: "A", "to", "tea", "ted", "ten", "i", "in", "inn", 每个单词还能有自己的一些权重值, 那么用前缀树来构建这个字典将会是如下的样子:

性质

每个节点至少包含两个基本属性

Childern: 数组或者集合, 罗列出每个分支当中包含的所有字符
idEnd, 布尔值, 表示是该节点是否为某字符串的结尾

前缀树的根节点是空的

所谓空, 即只利用这个节点的children属性, 即只关心在这个字典里, 有哪些打头的字符

除了根节点, 其他所有节点都有可能是单词的结尾, 叶子节点一定都是单词的结尾

实现

前缀叔最基本的操作就是两个: 创建和搜索

1. 创建

遍历一遍输入的字符串, 对每个字符串的字符进行遍历
从前缀的根节点开始, 将每个字符加入到节点的children字符集当中.
如果字符集已经包含了这个字符, 则跳过
如果当前字符是字符串的最后一个, 则把当前节点的isEnd标记为真.

由上, 创建的方法很直观

前缀树真正强大的地方在于, 每个每个节点还能用来保存额外的信息, 比如可以用来记录拥有相同前缀的所有字符串, 因此, 当用户输入某个前缀时, 就能在O(1)的时间内给出对应的推荐字符串

我们通过搜索 Trie 树来插入一个键。我们从根开始搜索它对应于第一个键字符的链接。有两种情况：

链接存在。沿着链接移动到树的下一个子层。算法继续搜索下一个键字符。链接不存在。创建一个新的节点，并将它与父节点的链接相连，该链接与当前的键字符相匹配。重复以上步骤，直到到达键的最后一个字符，然后将当前节点标记为结束节点，算法完成。

向前缀树中插入元素:

class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    // Inserts a word into the trie.
    public void insert(String word) {
        TrieNode node = root;
        for (int i = 0; i < word.length(); i++) {
            // 获取到每个字符
            char currentChar = word.charAt(i);
            // 判断是否存在, 不存在, 直接放入子节点
            if (!node.containsKey(currentChar)) {
                node.put(currentChar, new TrieNode());
            }
            // 子节点变成父节点, 进行下一次的循环
            node = node.get(currentChar);
        }
        // 设置最后的字符为单词的结束符
        node.setEnd();
    }
}

2. 搜索

与创建方法类似, 从前缀的根节点出发, 逐个匹配输入的前缀字符, 如果遇到了就继续往下一层搜索, 如果没遇到, 就立即返回.

在 Trie 树中查找键每个键在 trie 中表示为从根到内部节点或叶的路径。我们用第一个键字符从根开始，。检查当前节点中与键字符对应的链接。有两种情况：

存在链接。我们移动到该链接后面路径中的下一个节点，并继续搜索下一个键字符。不存在链接。若已无键字符，且当前结点标记为 isEnd，则返回 true。否则有两种可能，均返回 false :还有键字符剩余，但无法跟随 Trie 树的键路径，找不到键。没有键字符剩余，但当前结点没有标记为 isEnd。也就是说，待查找键只是Trie树中另一个键的前缀。

在树中查找元素

class Trie {
    ...

    // search a prefix or whole key in trie and
    // returns the node where search ends
    // 搜索前缀
    private TrieNode searchPrefix(String word) {
        TrieNode node = root;
        for (int i = 0; i < word.length(); i++) {
           // 获取到单词的每一个字符
           char curLetter = word.charAt(i);
           // 如果子节点包含, 就把子节点当成新的父节点, 进入下一次循环
           if (node.containsKey(curLetter)) {
               node = node.get(curLetter);
           } else {
             // 否则, 就返回空
               return null;
           }
        }
        // 返回最终的子节点
        return node;
    }

    // Returns if the word is in the trie.
    // 判断单词是否存在于前缀树中
    public boolean search(String word) {
       TrieNode node = searchPrefix(word);
       // 最后的节点不能为空, 而且该节点上必须有单词的结束符
       return node != null && node.isEnd();
    }
}

查找 Trie 树中的键前缀该方法与在 Trie 树中搜索键时使用的方法非常相似。我们从根遍历 Trie 树，直到键前缀中没有字符，或者无法用当前的键字符继续 Trie 中的路径。与上面提到的“搜索键”算法唯一的区别是，到达键前缀的末尾时，总是返回 true。我们不需要考虑当前 Trie 节点是否用 “isend” 标记，因为我们搜索的是键的前缀，而不是整个键。

class Trie {
    ...

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    public boolean startsWith(String prefix) {
        TrieNode node = searchPrefix(prefix);
        return node != null;
    }
}

例题分析

单词搜索 II](https://leetcode-cn.com/problems/word-search-ii/)

给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。

示例:

输入:
words = ["oath","pea","eat","rain"] and board =
[
  ['o','a','a','n'],
  ['e','t','a','e'],
  ['i','h','k','r'],
  ['i','f','l','v']
]

输出: ["eat","oath"]

说明:你可以假设所有输入都由小写字母 a-z 组成。

提示:

你需要优化回溯算法以通过更大数据量的测试。你能否早点停止回溯？如果当前单词不存在于所有单词的前缀中，则可以立即停止回溯。什么样的数据结构可以有效地执行这样的操作？散列表是否可行？为什么？前缀树如何？如果你想学习如何实现一个基本的前缀树，请先查看这个问题：实现Trie（前缀树）。

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

public class findWords_212 {
    public List<String> findWords(char[][] board, String[] words) {
        //构建字典树
        wordTrie myTrie=new wordTrie();
        trieNode root=myTrie.root;
        for(String s:words)
            myTrie.insert(s);

        //使用set防止重复
        Set<String> result =new HashSet<>();
        int m=board.length;
        int n=board[0].length;
        boolean[][] visited=new boolean[m][n];
        //遍历整个二维数组
        for(int i=0;i<board.length; i++){
            for (int j = 0; j < board [0].length; j++){
                find(board,visited,i,j,m,n,result,root);
            }
        }
        System.out.print(result);
        return new LinkedList<String>(result);
    }
    private void find(char [] [] board, boolean [][]visited,int i,int j,int m,int n,Set<String> result,trieNode cur){
        //边界以及是否已经访问判断
        if(i<0||i>=m||j<0||j>=n||visited[i][j])
            return;
        cur=cur.child[board[i][j]-'a'];
        visited[i][j]=true;
        if(cur==null)
        {
            //如果单词不匹配，回退
            visited[i][j]=false;
            return;
        }
        //找到单词加入
        if(cur.isLeaf)
        {
            result.add(cur.val);
            //找到单词后不能回退，因为可能是“ad” “addd”这样的单词得继续回溯
//            visited[i][j]=false;
//            return;
        }
      //上下左右去遍历, 通过递归的方法去实现
        find(board,visited,i+1,j,m,n,result,cur);
        find(board,visited,i,j+1,m,n,result,cur);
        find(board,visited,i,j-1,m,n,result,cur);
        find(board,visited,i-1,j,m,n,result,cur);
        //最后要回退，因为下一个起点可能会用到上一个起点的字符
        visited[i][j]=false;
    }


}

//字典树
class wordTrie{
    public trieNode root=new trieNode();
    public void insert(String s){
        trieNode cur=root;
        for(char c:s.toCharArray()){
            if(cur.child[c-'a']==null){
                cur.child [c-'a'] = new trieNode();
                cur=cur.child[c-'a'];
            }else
                cur=cur.child [c-'a'];
        }
        cur.isLeaf=true;
        cur.val=s;
    }
}
//字典树结点
class trieNode{
    public String val;
    public trieNode[] child=new trieNode[26];
    public boolean isLeaf=false;

    trieNode(){

    }
}