python 实现 tire树的相关操作

最新推荐文章于 2024-07-28 10:56:51 发布
最新推荐文章于 2024-07-28 10:56:51 发布
阅读量295 收藏
点赞数
分类专栏： 随笔记 文章标签： tire树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40007143/article/details/119531205
版权

题目

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码

from TrieNodeAbstract import TrieNodeAbstract
from ChildrenDictionary import ChildrenDictionary
import math
from typing import Dict, List, Union

# For help in traversing children
ALPHABET = 'abcdefghijklmnopqrstuvwxyz'


class TrieTree(TrieNodeAbstract):
    def __init__(self, char='', value: str = ''):
        '''
        Initializes:
            This node's char, `self._char`, ie. your current character in the key
            This node's set of subtrees, 'children', using a dictionary
            This node's value, `self._value`  only set iff its a valid word in the dictionary
        '''
        self._value = value
        self._children: ChildrenDictionary = ChildrenDictionary()
        self._char = char

    # TASK 1
    def insert(self, word: str) -> None:
        '''
        Insert your new word, keep in mind, you must insert all child nodes
        >>> trie = TrieTree()
        >>> trie.insert("word")
        >>> trie.insert("water")
        >>> trie.insert("banana")
        >>> "word" in str(trie)
        True
        >>> "water" in str(trie)
        True
        >>> "bob" in str(trie)
        False
        >>> "banana" in str(trie)
        True
        '''

        cur = self
        for c in word:
            if c not in cur._children:
                cur._children[c] = TrieTree()
            cur = cur._children[c]
            cur._char = c
        cur._value = word
        # raise NotImplementedError

    # TASK 2
    def __contains__(self, key: str):
        '''
        Returns True iff key is in tree, otherwise False
        >>> trie = TrieTree()
        >>> trie.insert("word")
        >>> "word" in trie
        True
        >>> "other" in trie
        False
        '''
        # TODO
        cur = self
        for c in key:
            if c not in cur._children:
                return False
            cur = cur._children[c]
        return (bool)(cur._value)

        # raise NotImplementedError

    # TASK 3
    def __delitem__(self, key: str):
        '''
        Deletes entry in tree and prunes unecessary branches if key exists, otherwise changes nothing
        >>> trie = TrieTree()
        >>> trie.insert("word")
        >>> "word" in trie
        True
        >>> del trie["word"]
        >>> "word" in trie
        False
        >>> str(trie)
        'TrieTree'
        >>> trie.insert('ab')
        >>> trie.insert('abs')
        >>> str(trie)
        'TrieTree\\n   `- a\\n      `- b : ab\\n         `- s : abs'
        >>> del trie['ab']
        >>> str(trie)
        'TrieTree\\n   `- a\\n      `- b\\n         `- s : abs'
        '''

        # TODO
        if not self.__contains__(key):
            return False
        cur = self
        cur2 = self
        last1 = self
        last2 = self
        ch = key[0]
        for c in key:
            if c in cur._children:
                if(len(cur._children)>1):
                    cur2 = cur
                    ch = c
                cur = cur._children[c]

                if ((bool)(cur._value) & (last1 == self)):
                    last1 = cur
                elif ((bool)(cur._value) & (last1 != self) & (last2 == self)):
                    last2 = cur
                elif ((bool)(cur._value) & (last1 != self) & (last2 != self)):
                    last1 = last2
                    last2 = cur
        if last2 == self:
            if cur._children:
                cur._value = ''
            else:
                cur2._children.pop(ch)
        else:
            if last2._children:
                last2._value = ''
            else:
                last1._children = ChildrenDictionary()

        # raise NotImplementedError

    # TASK 4
    def get_completion_words(self, pre_string):
        word_list = []
        # 叶节点退出递归，返回完整字符串
        if self._value:
            word_list.append(pre_string)
            # return word_list
        # 通过字典树的每个分支对之前的字符串进行补充
        for c in self._children:
            cur = self._children[c]
            word_list.extend(cur.get_completion_words(pre_string + str(c)))
        # 返回最终结果
        return word_list

    def sort(self, decreasing=False):
        '''
        Returns list of words in tree sorted alphabetically
        >>> trie = TrieTree()
        >>> trie.insert('banana')
        >>> trie.insert('cherry')
        >>> trie.insert('apple')
        >>> trie.sort()
        ['apple', 'banana', 'cherry']
        >>> trie.sort(decreasing=True)
        ['cherry', 'banana', 'apple']
        '''
        # TODO
        if (decreasing == False):
            ans = self.get_completion_words('')
            ans.sort()
            return ans
        if (decreasing):
            ans = self.get_completion_words('')
            ans.sort(reverse=True)
            return ans

    # TASK 5
    def autoComplete(self, prefix, N=10):
        '''
        if given a valid prefix, return a list containing N number of suggestions starting with that prefix in alphabetical order
        else return an empty list
        >>> trie = TrieTree()
        >>> trie.insert('apple')
        >>> trie.insert('dad')
        >>> trie.insert('apples')
        >>> trie.insert('application')
        >>> trie.insert('app')
        >>> trie.insert('about')
        >>> trie.autoComplete('a')
        ['about', 'app', 'apple', 'apples', 'application']
        >>> trie.autoComplete('a', N=2)
        ['about', 'app']
        >>> trie.autoComplete('app')
        ['app', 'apple', 'apples', 'application']
        >>> trie.autoComplete('c')
        []
        >>> trie.autoComplete('d')
        ['dad']
        '''

        # TODO
        cur = self
        # last = cur
        for c in prefix:
            if c in cur._children:
                # last = cur
                cur = cur._children[c]
        if (cur == self):
            return []
        a = cur.sort()
        b = []
        if len(a) <= N:
            for str in a:
                str = prefix + str
                b.append(str)
        else:
            a = a[0:N]
            for str in a:
                str = prefix + str
                b.append(str)
        return b
        # raise NotImplementedError

    # TASK 6
    def autoCorrect(self, word, errorMax = 2):
        '''
        Given a word, if misspelt return a list of possible valid words from the last valid prefix, with up to errorMax errors
        >>> trie = TrieTree()
        >>> trie.insert('dab')
        >>> trie.autoCorrect('dod')
        ['dab']
        >>> trie.autoCorrect('dod', errorMax=1)
        []
        >>> trie.autoCorrect('dad', errorMax=1)
        ['dab']
        >>> trie.insert('apple')
        >>> trie.insert('dad')
        >>> trie.insert('dude')
        >>> trie.insert('apples')
        >>> trie.insert('application')
        >>> trie.insert('app')
        >>> trie.insert('about')
        >>> trie.insert("apples")
        >>> trie.insert("application")
        >>> trie.insert('app')
        >>> trie.insert('apple')
        >>> sorted(trie.autoCorrect('apl', errorMax=10))
        ['app', 'apple', 'apples', 'application']
        >>> trie.autoCorrect('aboot')
        ['about']
        >>> sorted(trie.autoCorrect('dea'))
        ['dab', 'dad']
        >>> sorted(trie.autoCorrect('dod'))
        ['dab', 'dad', 'dude']
        >>> sorted(trie.autoCorrect('dea', errorMax=3))
        ['dab', 'dad', 'dude']
        '''
        # TODO
        i4 = 0
        ans = []
        cur22 = self
        for c1 in word:
            if c1 in cur22._children:
                cur22 = cur22._children[c1]
                i4 = i4+1
            else:
                break
        becompared = cur22.sort()
        word2 = word[i4:]
        while becompared:
            error = 0
            len1 = len(word2)
            len2 = len(becompared[0])
            len3 = min(len1,len2)
            len4 = max(len1,len2)
            for i in range(len3):
                if(word[i] != becompared[0][i]):
                    error = error+1
            error = error+(len4-len3)
            if error<=errorMax:
                ans.append(becompared[0])
            becompared.pop(0)
        for i3 in range(len(ans)):
            ans[i3] = word[:i4] + ans[i3]
        return ans
        # raise NotImplementedError

    # TASK 7
    def merge(self, otherTrie: TrieNodeAbstract):
        '''
        Merges another TrieTree into this one
        >>> trie1 = TrieTree()
        >>> trie2 = TrieTree()
        >>> trie1.insert('amazing')
        >>> trie2.insert('amazon')
        >>> trie1.merge(trie2)
        >>> 'amazon' in trie1
        True
        '''
        # TODO
        temp = otherTrie.sort()
        while temp:
            self.insert(temp[0])
            temp.pop(0)
        # raise NotImplementedError

    def pPrint(self, _prefix="", _last=True, index=0):
        '''
        DONT CHANGE THIS
        '''
        ret = ''
        if index:
            ret = _prefix + ("`- " if _last else "|- ") + self._char
            _prefix += "   " if _last else "|  "
            if self._value:
                ret += ' : ' + str(self._value)
            ret += '\n'
        else:
            ret = _prefix + "TrieTree"
            _prefix += "   " if _last else "|  "
            ret += '\n'
        child_count = len(self._children)
        for i, child in enumerate(self._children):
            _last = i == (child_count - 1)
            ret += self._children[child].pPrint(_prefix, _last, index + 1)
        return ret

    def __str__(self):
        return self.pPrint().strip()


if __name__ == '__main__':
    import doctest

    doctest.testmod()
    '''
    trie = TrieTree()

    trie.insert('deal')

    trie.insert('dear')
    trie.insert('do')

    trie.insert('heat')
    trie.insert('hen')

    trie.insert('he')

    # trie.__str__()
    # trie.__delitem__('he')
    # a = trie.__contains__('he')

    # a = trie.sort(True)
    # a = trie.sort(False)
    b = trie.autoComplete('he')
    print(b)
    '''

这个代码里面的task1到task7是需要完成的函数，其他的函数是不需要更改的。当然了，这个代码是不完整的，还有其他的一些.py文件，可以从这里下载完整的代码学习。

用python去对tire树进行操作，这个项目是很全面的。 谢谢使用

指针的值是地址
关注
专栏目录
python 实现 trie(字典) 树
凌墨的博客
07-02 2万+
tire 树 也叫字典树，也是一种 N 叉树，是一种特殊的前缀树结构。1、前缀树是N叉树的一种特殊形式。通常来说，一个前缀树是用来存储字符串的。前缀树的每一个节点代表一个字符串（前缀）。每一个节点会有多个子节点，通往不同子节点的路径上有着不同的字符。子节点代表的字符串是由节点本身的原始字符串，以及通往该子节点路径上所有的字符组成的。下面是前缀树的一个例子：前缀树的一个重要的特性是，节点所有的后代都...
Trie树（字典树）实现词频统计或前缀匹配类型的问题
Sup_Heaven的专栏
10-15 9534
一：概念      如果我们有and,as,at,cn,com这些关键词，那么trie树（zidianshu）？ 从上面的图中，我们或多或少的可以发现一些好玩的特性。       第一：根节点不包含字符，除根节点外的每一个子节点都包含一个字符。       第二：从根节点到某一节点，路径上经过的字符连接起来，就是该节点对应的字符串。       第三：每个单词
Python实现Trie树
06-13
用Python实现Trie树的应用，并可以对英汉词典进行导入和检索、添加和删除，最终可以将导入的英汉词典保存到本地磁盘。内附两个.py文件，分别是tree.py和d_gui.py，tree.py是类和方法,d_gui.py是图形界面；一个.txt文件，是需要导入的英汉词典，有7000+词汇。只需运行图形界面即可。特别说明：python的版本以2.7为好，图形界面模块是wxPython,需要自行安装，且版本不宜过高，以免不兼容。
字典树（tire）之python实现
weixin_44517095的博客
04-22 641
字典树又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 class Trie(object): def __init__(self): """ Initialize your data structure here. ""...
python使用字典(dict)实现TrieTree
Chrispink
04-09 2346
腾讯电面被问到字符串搜索的问题,当时只答出来O(n^2)级别的线性搜索. 其实trie树的概念在脑里一直有初步概念,只是没有归纳总结,一时被问到自然很难答出来.提醒自己,对于脑子里一些有初步设想的算法概念都应该在网络上找找相关知识,毕竟开源的世界里,你能想到的,总有人想得比你更远,考虑得比你更完善. 关于海量字符串数据的问题都可以用tire树解决,典型应用就是搜索框的自动联想功能. 每个结点带...
python 实现 trie树（字典树）
arvinChen的博客
01-12 544
python 实现 字典树 trie
Python实现字典树-Trie
baidu_36146918的博客
05-06 1333
本篇文章将解释什么是字典树以及字典树的Python实现什么是字典树(Trie)节点设计数据结构设计实现 什么是字典树(Trie) 字典树是一种树型数据结构，通常用来存储大量字符串。字典树的每个节点通常都为一个字符。从根节点的第一个孩子节点开始到可以作为字符串结尾的节点的路径就是Trie所存储的字符串，这种存储方式带来的好处就是Trie的时间复杂度和存储字符串的数据量无关只与查询的字符串长度有关，这...
python的大数据处理应用与实现
02-22 1707
最近看到一篇关于海量数据处理的python实现，具体参（http://blog.csdn.net/quicktest/article/details/7453189#comments）。文章中主要出现的问题是对于海量数据的处理分治这块实现思想不对，改进后采用了直接对文件进行处理会导致内存溢出，在此我将运用hash对原文件进行分割再进行处理（对于海量数据的处理大家可考：http://blog.csd
人工智能|机器学习——Aho-Corasic多模匹配算法的学习、理解和应用（Python）
也许有一天我们再相逢 睁开眼睛看清楚 我才是英雄！
07-28 748
2.1 Aho-Corasick算法的定义Aho-Corasick（简称为AC自动机），是一种基于前缀的，使用了确定有限自动机(DFA)原理的，字符串多模匹配算法。什么是DFA?DFA也就是确定有限自动机，英文全称是Deterministic Finite Automaton。具体的细节介绍，可以参照百度百科、维基百科，以及《算法导论》之类的算法书。在这里，我们尝试用通俗的语言和图示来解释一遍。首先，什么是自动机(A)。自动机就是一个代码块。这段代码块只做一件事，那就是接收输入值和状态值输出。
CSC148 A2 Students.7z
08-10
5. **两棵Tire树的合并**：Trie树的合并通常是指将两个已经构造好的Trie树合并成一个新的，以合并它们包含的所有字符串。这个操作在处理大量数据，如合并不同来源的词库时非常有用。 6. **自动纠错**：自动纠错功能...
Python-KeywordExtractor使用python实现了一个简单的trie树结构
08-10
使用python实现了一个简单的trie树结构，可增加/查找/删除关键词，用于中文的关键词匹配
DoubleArrayTrie:双端trie树的python实现
04-29
DoubleArrayTrie 双端trie树的python实现 版本翻译于 将其改写成python3.5版本 最主要的贡献是 —— 1：实现了其模糊查询的功能；2：自定义编码值，解决双端trie树需要预定义字母表的问题 另外，有实现了字典Trie树，字典Trie树构建简单、模糊查找功能实现容易，无需状态记录；其与双数组Tire可以说在功能上互补； 在存储值很多且多有冲突、字符编码范围较大的情况下，双数组Trie树很可能在序列化到硬盘以及加载到内存的占用空间都远大于字典Trie树
Python学习笔记：Trie Tree的实现
NS
10-09 1496
# Trie Tree class TrieTree(object): def __init__(self, key=None, size=0): self.key = key self.size = size self.children = [] def insert(self, word): node = sel
Tire树
正在进行时
03-05 2881
转载自：http://blog.csdn.net/v_july_v/article/details/6897097             从Trie树（字典树）谈到后缀树 说明：本文基本上是“整理”性质，致谢文末的参考文献。  引言     常关注本blog的读者朋友想必看过此篇文章：从B树、B+树、B*树谈到R 树，这次，咱们来讲另外两种树：Ti
前缀树Trie--LeetCode(python)
扣扣biubiubiu~
10-30 620
实现 Trie (前缀树) 实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。 示例: Trie trie = new Trie(); trie.insert(“apple”); trie.search(“apple”); // 返回 true trie.search(“app”); // 返回 false trie.start...
再战leetcode(208.实现Tire(前缀树)
Gideon
04-28 117
208.实现Tire(前缀树) 题目描述 题解 具体请看 leetcode大佬题解 代码: class TrieNode { boolean isWord;//是否是单词 TrieNode[] children;//26个小写字母 public TrieNode() { isWord = true; children = new TrieNode[26]; } } p
Python - 深夜数据结构与算法之 Trie
BITDDD小栈
01-08 1830
Python Trie 树简介与算法练习。
海量数据处理之Tire树（字典树）
热门推荐
田原的学习笔记
08-13 3万+
参考博文：http://blog.csdn.net/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树     Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较
Trie数的Python实现代码
897371388
08-06 226
关于Trie树的原理这里不做介绍，网上相关的资料非常多，可以参考July的文章：http://blog.csdn.net/v_july_v/article/details/6897097。不过Trie确实是非常的强大，原理不复杂，使用起来也非常的方便。代码实现其实也不难，如果用C++实现的话需要自己定义数据结构（结构体）来构建树，这里我介绍怎样用Python实现，用Python实现起来尤为的方便，...
java实现tire树
最新发布
09-07
它是一种哈希树的变种，通常用于实现搜索引擎中的自动补全和拼写检查等功能。 在Java中实现Trie树，你可以按照以下步骤进行： 1. 定义Trie树的节点结构。每个节点包含一个字典，用于存储其子节点，以及一个标志位...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

指针的值是地址

觉得还不错，我会继续努力的。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值