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

最新推荐文章于 2024-07-16 18:41:16 发布
最新推荐文章于 2024-07-16 18:41:16 发布
阅读量161 收藏
点赞数
分类专栏： 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武
关注
专栏目录
python-leetcode面试题解之第421题数组中两个数的最大异或值.zip
06-27
python python_leetcode面试题解之第421题数组中两个数的最大异或值
Trie树
weixin_47251999的博客
01-29 9165
基本概念 Trie 树，也叫“字典树”。顾名思义，它是一个树形结构。它是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串的问题。 Trie 树的本质，就是利用字符串之间的公共前缀，将重复的前缀合并在一起： Trie树的操作 Trie树是为匹配字符串而准备的，所以我们需要预先建立一个Trie树： 构造Trie树 但实际上构造Trie树，是利用数组（每个节点是字符值+下一字符的索引）： 纯26个小写英文字母匹配，可以通过字符的 ASCII 码减去“a”的 ASCII 码，迅
Trie树（字典树&前缀树）
小朱小朱绝不认输的博客
05-16 2140
Trie树的学习 文章目录1. Trie树的基本知识2. Trie树的实现2.1 二维数组实现2.2 TrieNode实现2.3 方法对比2.4 问题分析 1. Trie树的基本知识 Trie 树（又叫「前缀树」或「字典树」）是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。 Trie 树的本质，就是利用字符串之间的公共前缀，将重复的前缀合并在一起。 Trie树是一种哈希树的变种。 典型应用：用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 优点：最大限度
数据结构-trie树 插入，查询操作详解
最新发布
xmf_learn_c的博客
07-16 871
Trie树（也称为字典树、前缀树）是一种专门用于处理字符串的数据结构。它的主要特点是能够提供高效的插入、查找操作，尤其适用于需要频繁搜索、前缀匹配和大量字符串存储的应用场景。需要明确的是：1.Trie树是一种树形结构，每个节点代表一个字符或者字符串的一部分。2.每个节点通常有多个子节点，每个子节点对应一个字符，从而形成树状结构。我们根据这两个特征来进行插入操作，通过一道模板题更直观的理解代码实现。
Trie 树（数据结构）
zgdlxs的博客
01-23 7845
1.Trie树的概念 Trie树是数据结构比较简单的一种。Trie 树的基本用法是高效的存储和查找字符串集合的数据结构。Trie树也叫做字典树，它是一个树形结构。是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串。Trie树本质，利用字符串之间的公共前缀，将重复的前缀合并在一起。 2.Trie树的操作 2.1存储 Trie树的存储是从根节点开始从前往后依次便利每一个字符。 ...
Trie树（详解+例题）
m0_67717626的博客
03-16 1958
Trie树，即字典树，又称单词查找树或键树，是一种树形结构，每个节点保存一个字符，一条路径表示一个字符串。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较。Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。
【图解算法】Trie树
就爱摆烂
04-07 4136
Trie树，字符串查找树
Python算法题源代码-LeetCode(力扣)-实现 Trie (前缀树)
02-25
实现 Trie (前缀树) Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。 这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie()...
php-leetcode题解之实现Trie前缀树.zip
06-11
2. **插入操作**：插入单词到Trie树中，我们需要遍历单词的每个字符，根据字符在节点的子节点数组中找到对应的子节点。如果该子节点不存在，我们创建一个新的节点。当遍历完单词所有字符后，将最后一个节点的“结束...
leetcode-4.寻找两个正序数组的中位数
07-04
寻找两个正序数组的中位数 #### 问题描述 在本题目中，我们需要处理两个正序数组`nums1`和`nums2`，其长度分别为`m`和`n`。任务是找出并返回这两个正序数组的中位数。特别地，算法的时间复杂度应控制在`O(log(m+n)...
algoboy101#note_blog_leetcode#[421]数组中两个数的最大异或值1
07-25
找到 ai 和aj 最大的异或 (XOR) 运算结果，其中0 ≤ i, j  。示例:输入: [3, 10, 5, 25, 2, 8]输出: 28解释:
Trie树总结
weixin_55851276的博客
06-05 704
关于Trie树的总结
【数据结构基础】树 - 前缀树(Trie Tree)
DeveloperFire的博客
02-03 4430
在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。Trie 这个术语来自于 retrieval。根据词源学，trie 的发明者 Edward Fredkin 把它读作/ˈtriː/ “tree”。
Trie字典树详解
smf12138的博客
11-22 1885
Trie树，又叫字典树，前缀树(Prefix Tree)，单词查找树，是一种多叉树的结构.上图就是一颗Trie树，表示了关键字集合根节点不包含字符，除根节点外每一个节点都只包含一个字符从根节点到某一节点，路径上的字符连接起来，为该节点对应的字符串每个节点的所有子节点包含的字符都不相同.算法核心：利用字符串的公共前缀来减少查询时间，最大限度的减少无畏字符串的比较.单词检索统计和排序字符串字符串前缀搜索我们来看一个场景：当我们在浏览器的搜索框中打出一个字符串的前缀时，它便实时的单词自动补齐.对于。
Tire树（字典树）
qigaohua的博客
02-04 1910
1.1、什么是Trie树   Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。   Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质： 根节点不包含字符，除根节点外每一个节点都只包含一个字符。 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应
Trie树（字典树，前缀树，键树）分析详解
热门推荐
Hyman's Blog
01-13 2万+
Trie树概述   Trie树，又称字典树、前缀树、单词查找树、键树，是一种多叉树形结构，是一种哈希树的变种。Trie这个术语来自于retrieval，发音为/tri:/ “tree”，也有人读为/traɪ/ “try”。Trie树典型应用是用于快速检索（最长前缀匹配），统计，排序和保存大量的字符串，所以经常被搜索引擎系统用于文本词频统计，搜索提示等场景。它的优点是最大限度地减少无谓的字符串比较，查
Trie树（Prefix Tree）介绍
dbbaq24022的专栏
05-09 522
本文用尽量简洁的语言介绍一种树形数据结构 —— Trie树。 一、什么是Trie树 Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树 或 键树，是一种多叉树结构。如下图： 上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。从上图可以归纳...
数据结构：Trie（前缀树/字典树）
m0_63997099的博客
03-26 1758
Trie 又称字典树、前缀树和单词查找树，是一颗非典型的多叉树模型，即每个结点的分支数量可能为多个。Trie这个名字取自“retrieval”，检索，读音和 try 相同。
Trie树(字典树、前缀树) (小白整理)
licorice1235的博客
06-20 1063
此处引路: 字典树(Trie)详解 - Seaway-Fu - 博客园 (cnblogs.com) Trie树（Prefix Tree）介绍_神奕的专栏-CSDN博客_prefix tree Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树或键树，是一种多叉树结构。（空间换时间） 宽度：范围（例：英文->26） 深度：最长的字母长度加1（root根节点独占顶层） 用处：维护字符串，存储 字典 的一种数据结构。 性质： （1）根节点不包含...
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、付费专栏及课程。

余额充值