【leetcode-前缀树】实现Trie（前缀树）/添加与搜索单词/数组中两个数的最大异或值

最新推荐文章于 2024-08-25 23:25:41 发布
最新推荐文章于 2024-08-25 23:25:41 发布
阅读量164 收藏
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31478771/article/details/115642721
版权
本文详细介绍了前缀树（Trie）的数据结构，包括其插入、搜索和判断前缀的方法，并提供了哈希集合、树形结构和深度优先搜索等不同的实现方式。此外，还探讨了前缀树在自动补全、拼写检查以及词典类的单词匹配问题中的应用。最后，通过一个实际示例展示了如何使用前缀树寻找数组中两个数的最大异或值，以及如何优化查找过程。
摘要由CSDN通过智能技术生成

实现Trie（前缀树）

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

请你实现 Trie 类：

  • Trie() 初始化前缀树对象。
  • void insert(String word) 向前缀树中插入字符串 word 。
  • boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
  • boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：
输入
[“Trie”, “insert”, “search”, “search”, “startsWith”, “insert”, “search”]
[[], [“apple”], [“apple”], [“app”], [“app”], [“app”], [“app”]]
输出
[null, null, true, false, true, null, true]
解释
Trie trie = new Trie();
trie.insert(“apple”);
trie.search(“apple”); // 返回 True
trie.search(“app”); // 返回 False
trie.startsWith(“app”); // 返回 True
trie.insert(“app”);
trie.search(“app”); // 返回 True

哈希集合

class Trie {
    private Set<String> set;
    private Set<String> prefixes;

    public Trie() {
        set = new HashSet<>();
        prefixes = new HashSet<>();
    }
    
    public void insert(String word) {
        set.add(word);
        for (int i = 0; i < word.length(); i++) 
            prefixes.add(word.substring(0, i + 1));
    }
    
    public boolean search(String word) {
        return set.contains(word);
    }
    
    public boolean startsWith(String prefix) {
        return prefixes.contains(prefix);
    }
}

树形结构

public class Trie {
    private Trie[] children;
    private boolean isEnd;
    
    public Trie() {
        children = new Trie[26];
        isEnd = false;
    }

    public void insert(String word) {
        Trie node = find(word, true);
        node.isEnd = true;
    }

    public boolean search(String word) {
        Trie node = find(word, false);
        return node != null && node.isEnd;
    }

    public boolean startsWith(String prefix) {
        return find(prefix, false) != null;
    }

    private Trie find(String word, boolean insertMode) {
        Trie node = this;
        for (int i = 0; i < word.length(); i++) {
            int index = word.charAt(i) - 'a';
            if (node.children[index] == null) {
                if(insertMode)
                    node.children[index] = new Trie();
                else
                    return null;
            }
            node = node.children[index];
        }
        return node;
    }
}

添加与搜索单词

请你设计一个数据结构，支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。
实现词典类 WordDictionary ：

  • WordDictionary() 初始化词典对象
  • void addWord(word) 将 word 添加到数据结构中，之后可以对它进行匹配
  • bool search(word) 如果数据结构中存在字符串与 word 匹配，则返回 true ；否则，返回 false 。word 中可能包含一些 ‘.’ ，每个 . 都可以表示任何一个字母。

示例：
输入：
[“WordDictionary”,“addWord”,“addWord”,“addWord”,“search”,“search”,“search”,“search”]
[[],[“bad”],[“dad”],[“mad”],[“pad”],[“bad”],[".ad"],[“b…”]]
输出：
[null,null,null,null,false,true,true,true]
解释：
WordDictionary wordDictionary = new WordDictionary();
wordDictionary.addWord(“bad”);
wordDictionary.addWord(“dad”);
wordDictionary.addWord(“mad”);
wordDictionary.search(“pad”); // return False
wordDictionary.search(“bad”); // return True
wordDictionary.search(".ad"); // return True
wordDictionary.search(“b…”); // return True

前缀树存储

class TrieNode {
    public TrieNode[] children;
    public boolean isEnd;
    public TrieNode() {
        children = new TrieNode[26];
        isEnd = false;
    }
}

class WordDictionary {
    private TrieNode root;
    
    public WordDictionary() {
        root = new TrieNode();
    }
    
    public void addWord(String word) {
        TrieNode node = root;
        for (int i = 0; i < word.length(); i++) {
            int index = word.charAt(i) - 'a';
            if (node.children[index] == null)
                node.children[index] = new TrieNode();
            node = node.children[index];
        }
        node.isEnd = true;
    }
    
    public boolean search(String word) {
        return dfs(word, root);
    }

    private boolean dfs(String word, TrieNode root) {
        TrieNode cur = root;
        char[] array = word.toCharArray();
        for (int i = 0; i < array.length; i++) {
            if (array[i] == '.') {
                for (int j = 0; j < 26; j++) {
                    if (cur.children[j] != null) {
                        if (dfs(word.substring(i + 1), cur.children[j]))
                            return true;
                    }
                }
                return false;
            }
            if (cur.children[array[i] - 'a'] == null)
                return false;
            cur = cur.children[array[i] - 'a'];
        }
        return cur.isEnd;
    }
}

哈希集合存储

class WordDictionary {
    private Map<Integer, HashSet<String>> map;

    public WordDictionary() {
        map = new HashMap<>();
    }
    
    public void addWord(String word) {
        int len = word.length();
        HashSet<String> set = map.getOrDefault(len, new HashSet<String>());
        set.add(word);
        map.put(len, set);
    }
    
    public boolean search(String word) {
        int len = word.length();
        HashSet<String> set = map.getOrDefault(len, new HashSet<String>());
        if (set.contains(word))
            return true;
        for (String s : set) {
            if (equal(s, word, len))
                return true;
        }
        return false;
    }

    private boolean equal(String s, String word, int len) {
        char[] c1 = s.toCharArray();
        char[] c2 = word.toCharArray();
        for (int i = 0; i < len; i++) {
            if (c1[i] != c2[i] && c2[i] != '.')
                return false;
        }
        return true;
    }
}

哈希集合数组

按单词长度和首字母分类。

class WordDictionary {
    private HashSet<String>[][] table;

    public WordDictionary() {
        table = new HashSet[500][26];
    }
    
    public void addWord(String word) {
        int len = word.length();
        int charIndex = word.charAt(0) - 97;
        HashSet<String> set = table[len - 1][charIndex];
        if (set == null) {
            set = new HashSet<String>();
            table[len - 1][charIndex] = set;
        }
        set.add(word);
    }
    
    public boolean search(String word) {
        int len = word.length();
        HashSet<String> set;
        if ('.' == word.charAt(0)) {
            HashSet<String>[] setArray = table[len - 1];
            if (setArray == null || setArray.length == 0)
                return false;
            for (int i = 0; i < setArray.length; i++) {
                set = setArray[i];
                if (set == null || set.size() == 0)
                    continue;
                for (String key : set) {
                    if (match(word, key))
                        return true;
                }
            }

        } else {
            int charIndex = word.charAt(0) - 97;
            set = table[len - 1][charIndex];
            if (set == null || set.size() == 0)
                return false;
            for (String key: set) {
                if (match(word, key))
                    return true;
            }
        }
        return false;
    }

    private boolean match(String word, String value) {
        int len = word.length();
        for (int i = 0; i < len; i++) {
            if ('.' == word.charAt(i) || word.charAt(i) == value.charAt(i))
                continue;
            return false;
        }
        return true;
    }
}

正则表达式

import java.util.regex.*;
class WordDictionary {
	StringBuilder sb;
	public WordDictionary() {
		sb = new StringBuilder();
		sb.append('#');
	}
	public void addWord(String word) {
		sb.append(word);
		sb.append('#');
	}

	public boolean search(String word) {
		Pattern p = Pattern.compile('#' + word + '#');
		Matcher m = p.matcher(sb.toString());
		return m.find();
	}
}

数组中两个数的最大异或值

给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。
进阶：你可以在 O(n) 的时间解决这个问题吗？

示例 1：
输入：nums = [3,10,5,25,2,8]
输出：28
解释：最大运算结果是 5 XOR 25 = 28.

示例 2：
输入：nums = [0]
输出：0

示例 3：
输入：nums = [2,4]
输出：6

示例 4：
输入：nums = [8,10,2]
输出：10

示例 5：
输入：nums = [14,70,53,83,49,91,36,80,92,51,66,70]
输出：127

利用前缀树来查找与 当前数字 相异或 值最大的数字

要想找到异或值最大的数字，即尽可能每一位都不相同，且不相同的位数越高越好。
将数字的二进制形式加入前缀树，同时计算该数字在前缀树中所能得到的最大异或值。
在这里插入图片描述

class Solution {
    class TrieNode {
        TrieNode[] children = new TrieNode[2];
    }

    private TrieNode root = new TrieNode();

    private void initTrie(int[] nums, int top_bit) {
        for (int num : nums) {
            TrieNode cur = root;
            for (int i = top_bit; i >= 0; i--) {
                int bit = (num >>> i) & 1;
                TrieNode next = cur.children[bit];
                if (next == null) {
                    next = new TrieNode();
                    cur.children[bit] = next;
                }
                cur = next;
            }
        }
    }

    public int findMaximumXOR(int[] nums) {
        int len = nums.length;
        if (len == 1)
            return 0;
        else if (len == 2)
            return nums[0] ^ nums[1];

        int maxNum = nums[0];
        for(int num : nums) 
            maxNum = Math.max(maxNum, num);
        int top_bit = (Integer.toBinaryString(maxNum)).length();

        initTrie(nums, top_bit);

        int maxXor = 0;
        for (int num : nums) {
            TrieNode cur = root;
            int currXor = 0;
            for (int i = top_bit; i >= 0; i--) {
                int bit = (num >>> i) & 1, xorBit = bit ^ 1;
                TrieNode next = cur.children[xorBit];
                if (next == null) {
                    cur = cur.children[bit];
                } else {
                    cur = next;
                    currXor |= (1 << i);
                }
            }
            maxXor = Math.max(maxXor, currXor);
        }
        return maxXor;
    }
}

合并建树和查找

class Solution {
    class TrieNode {
        TrieNode[] children = new TrieNode[2];
    }

    private TrieNode root = new TrieNode();

    public int findMaximumXOR(int[] nums) {
        int len = nums.length;
        if (len == 1)
            return 0;
        else if (len == 2)
            return nums[0] ^ nums[1];

        int maxNum = nums[0];
        for(int num : nums) 
            maxNum = Math.max(maxNum, num);
        int top_bit = (Integer.toBinaryString(maxNum)).length();

        int maxXor = 0;
        for (int num : nums) {
            TrieNode cur = root, xorCur = root;
            int currXor = 0;
            for (int i = top_bit; i >= 0; i--) {
                int bit = (num >>> i) & 1, xorBit = bit ^ 1;
                TrieNode next = cur.children[bit], xorNext = xorCur.children[xorBit];
                if (next == null) {
                    next = new TrieNode();
                    cur.children[bit] = next;
                }
                cur = next;

                if (xorNext == null) {
                    xorCur = xorCur.children[bit];
                } else {
                    xorCur = xorNext;
                    currXor |= (1 << i);
                }
            }
            maxXor = Math.max(maxXor, currXor);
        }
        return maxXor;
    }
}
Hung武
关注
专栏目录
3.Trie树--求最大异或对
m0_72389201的博客
10-03 241
关于Trie树的一个用法，求最大异或对
acwing.835.Trie字符串统计
qq_47997583的博客
04-14 520
Trie字符串统计 维护一个字符串集合，支持两种操作： I x 向集合中插入一个字符串 x； Q x 询问一个字符串在集合中出现了多少次。 共有 N 个操作，输入的字符串总长度不超过 105，字符串仅包含小写英文字母。 输入格式 第一行包含整数 N，表示操作数。 接下来 N 行，每行包含一个操作指令，指令为 I x 或 Q x 中的一种。 输出格式 对于每个询问指令 Q x，都要输出一个整数作为结果，表示 x 在集合中出现的次数。 每个结果占一行。 数据范围 1≤N≤2∗104 输入样例： 5 I abc
Trie树（字典树）
最新发布
WHabc2002的博客
08-25 795
Trie树，又称字典树，是用来高效存储和查找字符串集合的一种数据结构查找时，可以高效的查找某个字符串是否 在Trie树中出现过，并且可以查找出现了多少次利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。1.2主要性质1.根节点不包含字符，除根节点外的每一个子节点都包含一个字符。2.从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。3.每个节点的所有子节点包含的字符互不相同。
Trie树
小蒟蒻yyb的博客
07-10 7342
Trie树即字典树 以下内容来自某度某科在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。 在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子
海量数据处理---Trie树（字典树）
qisefengzheng的专栏 总有一天你将破蛹而出
05-26 649
方法介绍 1.1、什么是Trie树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是最大限度地减少无谓的字符串比较，查询效率比较高。 Trie的核心思想是空间换时间，利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质：
Java实现 LeetCode 421 数组中两个数的最大异或值
热门推荐
南 墙
03-15 1万+
421. 数组中两个数的最大异或值 给定一个非空数组，数组中元素为 a0, a1, a2, … , an-1，其中 0 ≤ ai < 231 。 找到 ai 和aj 最大的异或 (XOR) 运算结果，其中0 ≤ i, j < n 。 你能在O(n)的时间解决这个问题吗？ 示例: 输入: [3, 10, 5, 25, 2, 8] 输出: 28 解释: 最大的结果是 5 ^ 25 = 2...
【LeetCode】421. 数组中两个数的最大异或值（哈希集合，字典树，详细图文解释）
Viper的程序员修炼手册
07-02 1038
题目 地址 分析 题目要求 O(N)时间复杂度，下面会讨论两种典型的 O(N) 复杂度解法。 利用哈希集合存储按位前缀。 利用字典树存储按位前缀。 这两种解法背后的思想是一样的，都是先将整数转化成二进制形式，再从最左侧的比特位开始逐一处理来构建最大异或值。两个方法的不同点在于采用了不同的数据结构来存储按位前缀。第一个方法在给定的测试集下执行速度更快，但第二种方法更加普适，更加简单。 异或运算的性质 解决这个问题，我们首先需要利用异或运算的一个性质： 如果 a ^ b = c 成立，那么a ^ c =
手撕力扣之图论：课程表、课程表 II、省份数量、等式方程的可满足性、情侣牵手、 实现 Trie (前缀树)、数组中两个数的最大异或值、判断二分图
weixin_39770712的博客
08-19 288
力扣210. 课程表 II 现在你总共有 n 门课需要选，记为 0 到 n-1。 在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]。 给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。 可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。 思路： 我们使用一个队列来进行广度优先搜索。开始时，所有入度为 00 的节点都被放入队列中，它们就是可以作为拓扑排序最前面的节点，并且它
【算法】Trie数（前缀树/字典树）简介及Leetcode上关于前缀树的题
haolexiao的专栏
04-04 7989
前几天同学面今日头条被问到了Trie树，刚好我也对于Trie树这种数据结构不是很熟悉，所以研究了一下前缀树，然后把Leetcode上关于前缀树的题都给做了一遍。 Leetcode上关于前缀树的题有如下： 208. Implement Trie (Prefix Tree)这道题是实现一个前缀树，作为基础题啦 Add and Search Word - Data structure design这道题是
【LeetCode刷题笔记】前缀树
川峰的博客
12-22 1018
LeetCode刷题笔记之前缀树篇。
leetcode中寻找两个正序数组的中位数python
05-30
好的，下面是寻找两个正序数组的中位数的 Python 代码： ```python def findMedianSortedArrays(nums1, nums2): nums = sorted(nums1 + nums2) n = len(nums) if n % 2 == 0: return (nums[n // 2 - 1] + nums...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值