数据结构 之 前缀树

已于 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_55786578的博客
05-05 1261
字典树，又称Trie、单词查找树、前缀树，是一种树形结 构，用于保存关联数组，其中的键通常是字符串。适合统计、 排序和存储大量的字符串，经常被搜索引擎系统用于文本词频 统计。字典树利用字符串的公共前缀来减少查询时间，最大限度 地减少无谓的字符串比较，查询效率比哈希树高。
数据结构实验报告 树.doc
09-29
数据结构实验报告主要关注了树和二叉树的相关知识，包括它们的概念、存储结构、操作算法以及应用。以下是这些知识点的详细说明： 1. **树的基本概念**：树是一种非线性的数据结构，由节点（顶点）和边组成，其中每...
数据结构-前缀树
qq_48664605的博客
04-21 882
前缀树的时间复杂度分析。
【数据结构】前缀树(trie)
ls199848的博客
02-23 1861
学习了解前缀树的基本概念、基本性质和前缀树的相关应用场景，学习前缀树的结构，以及前缀树的相关方法，包括前缀树的添加、查询、删除等方法，并通过相关例题来强化巩固自己的学习
Java实现前缀树（leetCode 208
最新发布
2401_85767533的博客
06-17 279
④从第一字符开始有连续重复的字符只占用一个节点，比如上面的to，和ten，中重复的单词t只占用了一个节点。//当前结点是否是完整字符串（是否是叶结点）②从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。①根节点不包含字符，除根节点外的每一个子节点都包含一个字符。//添加结点的过程既是添加结点的作用也是匹配前缀的过程。前缀树Trie Tree，是一种字典树，匹配树。1.2 当前字符串在字典中是其他字符串的前缀。③每个节点的所有子节点包含的字符互不相同。//不包含当前字符加入。
经典数据结构——前缀树
Morty的技术乐园
05-29 8393
引言 前缀树——trie 树，也叫作“单词查找树”、“字典树”。 它属于多叉树结构，典型应用场景是统计
数据结构：Trie（前缀树/字典树）
m0_63997099的博客
03-26 1326
Trie 又称字典树、前缀树和单词查找树，是一颗非典型的多叉树模型，即每个结点的分支数量可能为多个。Trie这个名字取自“retrieval”，检索，读音和 try 相同。
数据结构：树(Tree)【详解】
热门推荐
UniqueUnit的博客
02-26 16万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
数据结构—前缀树Trie的实现原理以及Java代码的实现
终生学习践行者
11-17 1010
详细介绍了前缀树Trie的实现原理以及Java代码的实现。
数据结构 —— 哈夫曼树
weixin_43254100的博客
07-17 1768
到达叶子节点的路径都是不一样的，没有一个到达叶子节点时经过其它的叶子节点，因此每个叶子节点的编码不可能是其它叶节点编码的前缀，保证了哈夫曼编码是前缀编码。传送字符为ABACCDA，A—00，B—01，C—10，D—11， 编码后为：00010010101100。5%需要判断1次，15%需要判断2次，40%需要判断3次，30%需要判断4次，10%需要判断4次、5%需要判断3次，15%需要判断3次，40%需要判断2次，30%需要判断2次，10%需要判断2次。如何找到效率最高，最优判断次数的判断树呢？
【数据结构】前缀树
lwgzj的博客
04-12 577
结构 Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树或键树，是一种多叉树结构。如下图： 基本性质： ①根节点不包含字符，除根节点外的每一个子节点都包含一个字符。 ②从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。 ③每个节点的所有子节点包含的字符互不相同。 ④从第一字符开始有连续重复的字符只占用一个节点，比如上面的body,boy和boa...
数据结构之前缀树
qq_56999918的博客
01-06 1247
“字典树又称前缀树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。”------百度百科 前缀树大致长成这样： 前缀树的特点： 1.根节点不包含任何字符内容，除根节点之外的其他节点只能包含一个字符；   2.从根节点到某一节点，路径上经过的字符连接起来，为该节点...
头歌数据结构构建哈夫曼树及编码
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数据结构
删除单向链表中的节点
qq_43164662的博客
02-21 5951
在单链表中只给定需要删除的节点（非尾节点），如何删除该节点，而且不断链。
Java之约瑟夫环问题
qq_43164662的博客
11-06 4603
通过学习Java约瑟夫环问题，理解大问题拆解成小问题，然后小问题之间递推求解，这也是动态规划的核心思想。
Java求众数
qq_43164662的博客
11-04 2961
用Java来求一个数组的众数，可使用HashMap、栈等数据结构完成。
赫夫曼树与最优前缀编码：数据结构详解
总结来说，数据结构课程中提到的前缀编码与赫夫曼树紧密相关，是理解数据压缩算法的基础之一。同时，深入理解各种树的类型、存储结构和遍历方法，对于在实际编程中处理数据结构问题具有重要的指导意义。通过学习这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值