数据结构 之 前缀树

已于 2022-03-08 19:50:09 修改
阅读量349 收藏 1
点赞数 1
分类专栏： 数据机构与算法 文章标签： 数据结构 前缀树 Java
于 2022-03-07 16:53:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43164662/article/details/123334117
版权

前缀树

前言

前缀树是一种利于高效地存储和检索字符串数据集中的键，适合用于表示有基础变量复合出来的复杂变量，如26个字符复合出来的单词，实现快速搜索和插入，以及前缀查询。

一、案例

在这里插入图片描述

二、题解

package com.xhu.offer.offerII;

//实现前缀树
public class Trie {
    TreeNode root;

    /**
     * Initialize your data structure here.
     */
    public Trie() {
        root = new TreeNode();
    }

    /**
     * Inserts a word into the trie.
     */
    public void insert(String word) {
        char[] chs = word.toCharArray();
        TreeNode p = root;

        for (char ch : chs) {
            int idx = ch - 'a';
            TreeNode n = p.next[idx];

            if (n == null) p.next[idx] = new TreeNode();

            p = n;
        }
        p.isEnd = true;
    }

    /**
     * Returns if the word is in the trie.
     */
    public boolean search(String word) {
        char[] chs = word.toCharArray();
        TreeNode p = root;
        for (char ch : chs) {
            int idx = ch - 'a';
            TreeNode n = p.next[idx];
            if (n == null) return false;

            p = n;
        }
        return p.isEnd;
    }

    /**
     * Returns if there is any word in the trie that starts with the given prefix.
     */
    public boolean startsWith(String prefix) {
        char[] chs = prefix.toCharArray();
        TreeNode p = root;
        for (char ch : chs) {
            int idx = ch - 'a';
            TreeNode n = p.next[idx];
            if (n == null) return false;

            p = n;
        }
        return true;
    }

    //只有小写字母，定义前缀树的数据结构
    public class TreeNode {
        boolean isEnd;

        TreeNode[] next;

        public TreeNode() {
            next = new TreeNode[26];
        }
    }
}

总结

1）第一次见前缀树结构，适用于固定的单一变量复合出复杂变量问题。

参考文献

[1] LeetCode 原题
[2] LeetCode 用户评论

附录

1、替换单词

在这里插入图片描述

package com.xhu.offer.offerII;

import java.util.Iterator;
import java.util.List;

//替换单词
public class ReplaceWords {
    //构建词根树
    TreeNode root = new TreeNode();

    public String replaceWords(List<String> dictionary, String sentence) {
        buildTrie(dictionary);
        //替换单词
        StringBuilder sb = new StringBuilder();
        String[] strs = sentence.split(" ");
        for (String str : strs) {
            char[] chs = str.toCharArray();

            TreeNode p = root;
            int count = 0;
            for (char ch : chs) {
                int idx = ch - 'a';
                TreeNode n = p.next[idx];
                if (n == null || p.isEnd) break;
                count++;
                p = p.next[idx];
            }
            sb.append(p.isEnd ? str.substring(0, count) : str).append(" ");
        }
        return sb.toString().trim();
    }


    private void buildTrie(List<String> dic) {
        Iterator<String> iterator = dic.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            char[] chs = s.toCharArray();
            TreeNode p = root;
            for (char ch : chs) {
                int idx = ch - 'a';
                TreeNode n = p.next[idx];
                if (n == null) p.next[idx] = new TreeNode();
                p = p.next[idx];
            }
            p.isEnd = true;
        }
    }

    public class TreeNode {
        boolean isEnd;
        TreeNode[] next = new TreeNode[26];
    }

}

2、神奇的字典

在这里插入图片描述

package com.xhu.offer.offerII;

import java.util.ArrayList;
import java.util.List;

//神奇的字典
public class MagicDictionary {
    /**
     * Initialize your data structure here.
     */
    public MagicDictionary() {

    }

    /**
     * 构造前缀树
     *
     * @param dictionary 前缀树构造所需单词
     */
    public void buildDict(String[] dictionary) {
        for (String s : dictionary) {
            char[] chs = s.toCharArray();
            TreeNode p = root;

            for (char ch : chs) {
                int idx = ch - 'a';

                if (p.next[idx] == null) p.next[idx] = new TreeNode();

                p = p.next[idx];
            }
            p.isEnd = true;
        }
    }

    TreeNode root = new TreeNode();

    public boolean search(String searchWord) {
        return recursion(root, searchWord, 0, 0);
    }

    /**
     * DFS
     *
     * @param root       表示上一次比较时所用节点，即父节点，递归口通过判断父节点是否为end节点来确定是否完全匹配。
     * @param searchWord 表示需要去DFS匹配的字符串
     * @param i          该比searchWord的第几个字符了
     * @param count      表示前面已经有几个字符不同了
     * @return 只要匹配成功一次就返回true，即成功匹配，否则false，for中的flag为false表示继续DFS，for外的false表示DFS完也匹配不成功
     */
    private boolean recursion(TreeNode root, String searchWord, int i, int count) {
        if (count > 1 || root == null) return false;
        if (i == searchWord.length()) {
            if (root.isEnd && count == 1) return true;
            else return false;
        }
        for (int j = 0; j < 26; j++) {
            boolean flag = false;
            int idx = searchWord.charAt(i) - 'a';

            if (idx != j) flag = recursion(root.next[j], searchWord, i + 1, count + 1);
            else flag = recursion(root.next[j], searchWord, i + 1, count);
            if (flag) return true;
        }
        return false;
    }


    public class TreeNode {
        boolean isEnd;
        TreeNode[] next = new TreeNode[26];
    }
}

//使用list，找同等长度的字符串拿去作比较，修改修改一次两者相等，则true，否则false。
//这里判断是否修改一次相等，就对比有多少字符不相等即可。
class MagicDictionary2 {
    List<String> cache = new ArrayList<>();

    /**
     * Initialize your data structure here.
     */
    public MagicDictionary2() {

    }

    public void buildDict(String[] dictionary) {
        for (String s : dictionary) cache.add(s);
    }

    public boolean search(String searchWord) {
        int size = cache.size();

        for (String s : cache) {
            if (s.length() != searchWord.length()) continue;
            if (find(s, searchWord)) return true;
        }
        return false;
    }

    //注：只修改一次，直接比较字符不等的时候有多少，不用递归+for那么麻烦。
    private boolean find(String s, String searchWord) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) != searchWord.charAt(i)) count++;
            if (count > 1) return false;
        }

        return count == 1;
    }

}

3、最短单词编码之逆前缀树

掌握好前缀树的各个细节，才能举一反三，采用逆前缀树来解决最短单词编码。
在这里插入图片描述

package com.xhu.offer.offerII;

//最短的单词编码
public class MinimumLengthEncoding {
    //倒装的前缀树即可，然后统计每条路径长度之和 + 路径条数(需要多少#)
    public int minimumLengthEncoding(String[] words) {
        //建树
        buildTree(words);
        //统计路径
        return countPath(root)[0];
    }


    private int[] countPath(TreeNode root) {

        if (root.next == null) {
            return new int[]{1, 1};
        }
        int res = 0, count = 0;
        for (int i = 0; i < 26; i++) {
            if (root.next[i] != null) {
                int[] r = countPath(root.next[i]);
                count += r[1];
                res += r[0];
            }
        }
        return new int[]{res + count, count};
    }

    TreeNode root = new TreeNode();

    private void buildTree(String[] words) {
        for (String word : words) {
            char[] chs = word.toCharArray();
            TreeNode p = root;
            for (int i = chs.length - 1; i >= 0; i--) {
                int idx = chs[i] - 'a';
                if (p.next == null) p.next = new TreeNode[26];
                if (p.next[idx] == null) p.next[idx] = new TreeNode();
                p = p.next[idx];
            }
        }
    }

    public class TreeNode {
        TreeNode[] next;
    }
}

4、单词之和

在这里插入图片描述

package com.xhu.offer.offerII;

//单词之和
public class MapSum {
    //前缀树

    /**
     * Initialize your data structure here.
     */
    public MapSum() {

    }

    TreeNode root = new TreeNode();

    public void insert(String key, int val) {
        char[] chs = key.toCharArray();
        TreeNode p = root;

        for (char ch : chs) {
            int idx = ch - 'a';

            if (p.next == null) p.next = new TreeNode[26];
            if (p.next[idx] == null) p.next[idx] = new TreeNode();

            p = p.next[idx];
        }
        p.isEnd = true;
        p.val = val;
    }


    public int sum(String prefix) {
        char[] chs = prefix.toCharArray();

        TreeNode p = root;
        for (char ch : chs) {
            int idx = ch - 'a';

            if (p.next == null || p.next[idx] == null) return 0;

            p = p.next[idx];
        }
        int[] total = new int[]{0};
        order(p, total);

        return total[0];
    }

    private void order(TreeNode p, int[] total) {
        if (p.isEnd) {
            total[0] += p.val;
        }
        if (p.next == null) return;

        for (int i = 0; i < 26; i++) {
            if (p.next[i] != null) order(p.next[i], total);
        }
    }

    public class TreeNode {
        boolean isEnd;
        int val;
        TreeNode[] next;
    }
}

5、最大的异或

在这里插入图片描述

package com.xhu.offer.offerII;


//最大的异或
public class FindMaximumXOR {
    TreeNode root = new TreeNode();

    public int findMaximumXOR(int[] nums) {
        //建树
        buildTree(nums);
        //寻找最大解
        int res = 0;
        for (int num : nums) {
            int t = find(num);
            res = res < t ? t : res;
        }
        return res;
    }


    private int find(int num) {
        int count = 30;
        TreeNode p = root;
        int res = 0;
        while (count >= 0) {
            int m = num >>> count & 1;
            boolean f1 = m == 1 && p.right != null, f2 = m == 0 && p.left != null;

            if (f1 || f2) res |= 1 << count;

            if (p.right != null && (m == 1 || p.left == null)) p = p.right;
            else p = p.left;
            count--;
        }
        return res;
    }

    private void buildTree(int[] nums) {
        for (int num : nums) {
            int count = 30;
            TreeNode p = root;

            while (count >= 0) {
                int m = num >>> count-- & 1;
                boolean f1 = m == 1 && p.left == null, f2 = m == 0 && p.right == null;
                if (f1) p.left = new TreeNode();
                if (f2) p.right = new TreeNode();

                p = m == 1 ? p.left : p.right;
            }
        }
    }

    public class TreeNode {
        TreeNode left;//1
        TreeNode right;//0
    }
}
REN_林森
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-前缀树
weixin_42280618的博客
06-30 58
数据结构-前缀树前缀树具体代码实现关于前缀树相关的leetcode 前缀树 又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 它有3个基本性质： 根节点不包含字符，除根节点外每一个节点都只包含一个字符； 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串； 每个节点的所有子节
数据结构之树
EditGP的专栏
10-22 562
//树中结点和它的兄弟结点地位相同(如果有) //对应于树的二叉链表来说，沿着结点的右指针(如果有)一直往右走,则当前结点和这些右指针所指向的结点之间都是兄弟 #include using namespace std; #define QSIZE 20 typedef char ElemType; typedef struct CSNode { ElemType data; CSNode *p
【数据结构】前缀树(trie)
ls199848的博客
02-23 1828
学习了解前缀树的基本概念、基本性质和前缀树的相关应用场景，学习前缀树的结构，以及前缀树的相关方法，包括前缀树的添加、查询、删除等方法，并通过相关例题来强化巩固自己的学习
经典数据结构——前缀树
Morty的技术乐园
05-29 8352
引言 前缀树——trie 树，也叫作“单词查找树”、“字典树”。 它属于多叉树结构，典型应用场景是统计
Java实现前缀树（leetCode 208
最新发布
2401_85767533的博客
06-17 278
④从第一字符开始有连续重复的字符只占用一个节点，比如上面的to，和ten，中重复的单词t只占用了一个节点。//当前结点是否是完整字符串（是否是叶结点）②从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。①根节点不包含字符，除根节点外的每一个子节点都包含一个字符。//添加结点的过程既是添加结点的作用也是匹配前缀的过程。前缀树Trie Tree，是一种字典树，匹配树。1.2 当前字符串在字典中是其他字符串的前缀。③每个节点的所有子节点包含的字符互不相同。//不包含当前字符加入。
Java 前缀树
SCU_XLJ的博客
09-18 900
每一个节点会有多个子节点，通往不同子节点的路径上有着不同的字符。子节点代表的字符串是由节点本身的原始字符串，以及通往该子节点路径上所有的字符组成的。查找前缀树中的字符串，是否包含此前缀，同样，遍历为空时直接返回false，遍历结束不为空，则代表查找前缀树中某个字符串有这个前缀。2、从根节点到某一个节点，路径上经过的字符连接起来，就是该节点对应的字符串（例如：结果U代表的字符串就是"YU"）（1）判断Root节点的子节点是否包含”NB“的前缀‘N’，没有就新建节点进行遍历赋值，有则往‘N’节点遍历。
数据结构之前缀树
qq_56999918的博客
01-06 1245
“字典树又称前缀树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。”------百度百科 前缀树大致长成这样： 前缀树的特点： 1.根节点不包含任何字符内容，除根节点之外的其他节点只能包含一个字符；   2.从根节点到某一节点，路径上经过的字符连接起来，为该节点...
数据结构—前缀树Trie的实现原理以及Java代码的实现
终生学习践行者
11-17 1005
详细介绍了前缀树Trie的实现原理以及Java代码的实现。
数据结构实验报告 树.doc
09-29
数据结构实验报告主要关注了树和二叉树的相关知识，包括它们的概念、存储结构、操作算法以及应用。以下是这些知识点的详细说明： 1. **树的基本概念**：树是一种非线性的数据结构，由节点（顶点）和边组成，其中每...
头歌数据结构构建哈夫曼树及编码
05-18
哈夫曼树是一种特殊的二叉树，用于解决数据压缩中的编码问题。它的构造原则是使得树中所有叶子节点（代表需要编码的字符）到...此外，哈夫曼树还被广泛应用于数据结构和算法的教学中，帮助学生理解二叉树的操作和应用。
Python数据结构与算法之字典树实现方法示例
09-21
字典树（Trie Tree），又称前缀树或字典树，是一种特殊的树形数据结构，主要用于存储关联数组，尤其是字符串。这种数据结构允许我们快速查找具有相同前缀的字符串，例如在搜索引擎中进行关键词匹配或统计词频。 在...
AVL-红黑树-前缀树
05-16
AVL树、红黑树和前缀树是数据结构与算法中的重要概念，它们在高效地存储和检索数据方面有着广泛的应用。以下是关于这三种数据结构的详细解释： 1. AVL树： AVL树是一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E...
C++前缀树trie的实现
12-25
C++实现的前缀树trie数据结构
Java-前缀树
chara9885的博客
03-26 137
笔记啊笔记
Java前缀树
CkkkkkkkC的博客
02-16 144
前缀树的Java实现
Java实现前缀树（leetCode 208，看完这一篇就够了
m0_60707660的博客
03-18 409
如果你选择了IT行业并坚定的走下去，这个方向肯定是没有一丝问题的，这是个高薪行业，但是高薪是凭自己的努力学习获取来的，这次我把P8大佬用过的一些学习笔记（pdf）都整理在本文中了《Java中高级核心知识全面解析》ava中高级核心知识全面解析》**[外链图片转存中…(img-SKgcBjLN-1710694127064)][外链图片转存中…(img-YBQ5Mix8-1710694127065)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】
前缀树详解-Java版
乐无声的博客
08-01 2387
文章目录前言一、前缀树介绍一、前缀树的表示1、数组2、Map二、插入总结 前言 今天在做算法题的时候，遇到了一道用到前缀树这种数据结构的题目，借此机会，写篇博文，记录一下前缀树到底是什么？ 一、前缀树介绍   前缀树(字典树)是N叉树的一种特殊形式。通常来说，一个前缀树是用来存储字符串的。前缀树的每一个节点代表一个字符串（前缀）。每一个节点会有多个子节点，通往不同子节点的路径上有着不同的字符。子节点代表的字符串是由节点本身的原始字符串，以及通往该子节点路径上所有的字符组成的。 例如，现在我要存储字符串[“Y
【数据结构】前缀树
可可卷的博客
12-05 474
前缀树，也叫字典树，Trie 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 可以简单地认为，Trie是一种26叉树，每一个节点都有26个子节点，对应a-z。 单词不存储于字典树的节点内，而是字典树从根节点到该节点的路径 在具体实现上，python使用字典性能更好，而C++则是使用数组性能更好 字典树练习题集 https://leetcode-cn.com/tag/trie/problemset/ 实现 T
【数据结构与算法系列】——前缀树（字典树）、后缀树，主要用于海量数据的查找和去重问题
your_棒棒糖的博客
04-27 1738
前缀树 LeetCode题目中有关前缀树的描述：Trie前缀树-字典树 前缀树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 Trie树也有它的缺点，Trie树的内存消耗非常大。 性质：不同字符串的相同前缀只保存一份。 操作：查找，插
赫夫曼树与最优前缀编码：数据结构详解
总结来说，数据结构课程中提到的前缀编码与赫夫曼树紧密相关，是理解数据压缩算法的基础之一。同时，深入理解各种树的类型、存储结构和遍历方法，对于在实际编程中处理数据结构问题具有重要的指导意义。通过学习这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值