字典树简介、应用以及与哈希表的比较

最新推荐文章于 2023-03-20 16:07:43 发布
最新推荐文章于 2023-03-20 16:07:43 发布
阅读量2k 收藏 4
点赞数
分类专栏： 数据结构 数据结构入门 文章标签： 数据结构 trie树-c++实现 字典树 查询单词
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liyongqi_/article/details/71189435
版权

题目要求：

1、设计并实现N-array trie,包括初始化，查找，插入，删除等。
2、应用trie结构实现文本文档的索引化，首先扫描文本文档，然后利用trie结构记录单词行号，最后在trie上实现查询
3、用户的查询可以是针对一个单词，也可以是某些字母开头的。

我的思路：

根据题目的要求，用字典树这一数据结构实现最为符合，下面介绍一下字典树：

字典树介绍：

我们拿存储英文单词的字典树为例，从实质上来讲，该字典树就是一个26叉树。（若是储存数字如电话号码，那么就是一个10叉树）。
比如说我想储存he,her,boy这三个单词，那么其结构如下图所示：

这里写图片描述

总结其基本性质如下：
根节点不包含字符，除根节点意外每个节点至多包含一个单词。
从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。

代码实现：

TrieNode类（节点类）：string rownum(储存行号)，26个指向TrieNode的指针（*a,*b,……）,构造函数等；

Trie类（树）：
root（根节点）
storeWord()(插入单词的方法)：从根节点向子节点遍历（若子节点为空，则新建子节点，直到到达对应位置）
queryWord（查询单词行号）：从根节点向子节点遍历到达对应位置返回行号

其中题目中提到的查询以某些字母开头的单词，那么只需遍历以该节点为根的子树即可（比如层次遍历）。如下，想查询以he开头的单词,遍历蓝色圈起来的子树。
这里写图片描述

对字典树的分析：

优点：

1、插入，查询，删除等操作复杂度为O(h),其中h为单词的长度。为什么会这么快呢，本质是空间换时间（空间复杂度为26的h次方），利用指针来避免做其他不必要的查找。（初始化的时间复杂度为n O(h),n为单词个数）
2、当储存大量单词或者说储存的单词有着共同前缀时节省了空间。（比如说用线性存储boy,boyfriend如用trie存储的差别）

缺点：

指针占用的空间，空间复杂度大。如果储存少量的单词，并不能节省空间。

字典树的应用：

1、  字符串检索：
事先将已知的一些字符串（字典）的有关信息保存到trie树里，查找另外一些未知字符串是否出现过或者出现频率。（本题既是如此）
2、  字符串最长公共前缀（转化为寻找共同祖先问题）

与哈希的比较

这里写图片描述

实际效果：

我存储26400行的单词，其中查询很快，达到了预期，但初始化过程表现很差，用时约3分钟。
这里写图片描述

我的改进：

在每个节点直接申请所有的指针，来获得连续的空间，防止内存过于碎片化，但效果并不好。

下面是代码版本一


#include <stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
#include <stdio.h>
#include<string.h>
#include <iostream>  
#include <cstdlib>
#include <cstdio>
#include <stack>  
#include <string>
#include <fstream>  
#include <sstream>
#include <iostream>
#include <vector>
using namespace std; 

class BinaryTreeNode//二叉树的节点类
{
public:
    BinaryTreeNode() { a = b= c = d = e= f =g=h=i=j=k=l=m=n=o=p=q=r=s=t=u=v=w=x=y=z=0; }
    BinaryTreeNode(string num) { rownum = num; a = b= c = d = e= f =g=h=i=j=k=l=m=n=o=p=q=r=s=t=u=v=w=x=y=z=0; }
    //BinaryTreeNode(char c, BinaryTreeNode* left, BinaryTreeNode* right) { data = c; leftChild = left; rightChild = right; }

    string rownum ;
    BinaryTreeNode* a;BinaryTreeNode* b;BinaryTreeNode* c;BinaryTreeNode* d;BinaryTreeNode* e;BinaryTreeNode* f;
    BinaryTreeNode* g;BinaryTreeNode* h;BinaryTreeNode* i;BinaryTreeNode* j;BinaryTreeNode* k;BinaryTreeNode* l;
    BinaryTreeNode* m;BinaryTreeNode* n;BinaryTreeNode* o;BinaryTreeNode* p;BinaryTreeNode* q;BinaryTreeNode* r;
    BinaryTreeNode* s;BinaryTreeNode* t;BinaryTreeNode* u;BinaryTreeNode* v;BinaryTreeNode* w;BinaryTreeNode* x;
    BinaryTreeNode* y;BinaryTreeNode* z;

};


class Node  //队列类中用链表存
{
public:
    BinaryTreeNode *data;
    Node *next;
    Node() { next = NULL; }
    Node(BinaryTreeNode *item, Node* link = NULL) { data = item; next = link; }
};





//队列类，作为层次遍历的辅助数据结构用
class LinkQueue
{
private:
    Node *front, *rear;
public:
    LinkQueue() { rear = front = new Node; };
    bool empty() 
    { 
        return front == rear;
    }
    void outQueue(BinaryTreeNode * &e)//出队列
    {
        Node *tmpPtr = front->next;
        e = tmpPtr->data;
        front->next = tmpPtr->next;
        if (rear == tmpPtr) rear = front;
        delete tmpPtr;
    }
    void inQueue(BinaryTreeNode * &e)//入队列
    {
        Node *tmpPtr = new Node(e);
        rear->next = tmpPtr;
        rear = tmpPtr;
    }

};








//二叉树类
class BinaryTree
{
public:
    BinaryTree() { root = 0; }


    void insertaChild(BinaryTreeNode* t, string rownum)//插入A孩子
    {
        t->a = new BinaryTreeNode(rownum);
    }
    void insertbChild(BinaryTreeNode* t, string rownum)//插入B孩子
    {
        t->b = new BinaryTreeNode(rownum);
    }
    void insertcChild(BinaryTreeNode* t, string rownum)//插入C孩子
    {
        t->c = new BinaryTreeNode(rownum);
    }
     void insertdChild(BinaryTreeNode* t, string rownum)//插入D孩子
    {
        t->d = new BinaryTreeNode(rownum);
    }
    void inserteChild(BinaryTreeNode* t, string rownum)//插入E孩子
    {
        t->e = new BinaryTreeNode(rownum);
    }
    void insertfChild(BinaryTreeNode* t, string rownum)//插入F孩子
    {
        t->f = new BinaryTreeNode(rownum);
    }
    void insertgChild(BinaryTreeNode* t, string rownum)//插入G孩子
    {
        t->g = new BinaryTreeNode(rownum);
    }
    void inserthChild(BinaryTreeNode* t, string rownum)//插入H孩子
    {
        t->h = new BinaryTreeNode(rownum);
    }
    void insertiChild(BinaryTreeNode* t, string rownum)//插入I孩子
    {
        t->i = new BinaryTreeNode(rownum);
    }
     void insertjChild(BinaryTreeNode* t, string rownum)//插入J孩子
    {
        t->j = new BinaryTreeNode(rownum);
    }
    void insertkChild(BinaryTreeNode* t, string rownum)//插入K孩子
    {
        t->k = new BinaryTreeNode(rownum);
    }
    void insertlChild(BinaryTreeNode* t, string rownum)//插入L孩子
    {
        t->l = new BinaryTreeNode(rownum);
    }
    void insertmChild(BinaryTreeNode* t, string rownum)//插入M孩子
    {
        t->m = new BinaryTreeNode(rownum);
    }
    void insertnChild(BinaryTreeNode* t, string rownum)//插入N孩子
    {
        t->n = new BinaryTreeNode(rownum);
    }
    void insertoChild(BinaryTreeNode* t, string rownum)//插入O孩子
    {
        t->o = new BinaryTreeNode(rownum);
    }
     void insertpChild(BinaryTreeNode* t, string rownum)//插入P孩子
    {
        t->p = new BinaryTreeNode(rownum);
    }
    void insertqChild(BinaryTreeNode* t, string rownum)//插入Q孩子
    {
        t->q = new BinaryTreeNode(rownum);
    }
    void insertrChild(BinaryTreeNode* t, string rownum)//插入R孩子
    {
        t->r = new BinaryTreeNode(rownum);
    }
    void insertsChild(BinaryTreeNode* t, string rownum)//插入S孩子
    {
        t->s = new BinaryTreeNode(rownum);
    }
    void inserttChild(BinaryTreeNode* t, string rownum)//插入T孩子
    {
        t->t = new BinaryTreeNode(rownum);
    }
    void insertuChild(BinaryTreeNode* t, string rownum)//插入U孩子
    {
        t->u = new BinaryTreeNode(rownum);
    }
     void insertvChild(BinaryTreeNode* t, string rownum)//插入V孩子
    {
        t->v = new BinaryTreeNode(rownum);
    }
    void insertwChild(BinaryTreeNode* t, string rownum)//插入W孩子
    {
        t->w = new BinaryTreeNode(rownum);
    }
    void insertxChild(BinaryTreeNode* t, string rownum)//插入X孩子
    {
        t->x = new BinaryTreeNode(rownum);
    }
    void insertyChild(BinaryTreeNode* t, string rownum)//插入Y孩子
    {
        t->y = new BinaryTreeNode(rownum);
    }
    void insertzChild(BinaryTreeNode* t, string rownum)//插入Z孩子
    {
        t->z = new BinaryTreeNode(rownum);
    }

    //下面是接收一个单词储存到树中的方法
    void storeWord(string word ,string rownum)
    {
        int length=word.length();//获取当前单词的长度
        BinaryTreeNode* current = this->root;//current用来遍历树
        //下面将word的字母一个个取出来判断该单词在树中的位置
        for(int i=0;i<length;i++)
        {

            string first;
            first=word.substr(i,1);//依次获取字母
            cout << "当前的字母是："+first<< endl;
            if(i<length-1)//还没到最终的位置
            {
                if(first.compare("a")==0)
                {
                    if(current->a==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertaChild(current,"0");
                        current=current->a;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->a;
                    }
                }
                else if(first.compare("b")==0)
                {
                    if(current->b==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertbChild(current,"0");
                        current=current->b;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->b;
                    }
                }
                else if(first.compare("c")==0)
                {
                    if(current->c==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertcChild(current,"0");
                        current=current->c;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->c;
                    }
                }
                else if(first.compare("d")==0)
                {
                    if(current->d==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertdChild(current,"0");
                        current=current->d;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->d;

                    }
                }
                else if(first.compare("e")==0)
                {
                    if(current->e==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->inserteChild(current,"0");
                        current=current->e;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->e;
                    }
                }
                else if(first.compare("f")==0)
                {
                    if(current->f==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertfChild(current,"0");
                        current=current->f;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->f;

                    }
                }
                else if(first.compare("g")==0)
                {
                    if(current->g==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertgChild(current,"0");
                        current=current->g;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->g;
                    }
                }
                else if(first.compare("h")==0)
                {
                    if(current->h==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->inserthChild(current,"0");
                        current=current->h;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->h;

                    }
                }
                else if(first.compare("i")==0)
                {
                    if(current->i==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertiChild(current,"0");
                        current=current->i;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->i;
                    }
                }
                else if(first.compare("j")==0)
                {
                    if(current->j==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertjChild(current,"0");
                        current=current->j;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->j;

                    }
                }
                else if(first.compare("k")==0)
                {
                    if(current->k==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertkChild(current,"0");
                        current=current->k;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->k;
                    }
                }
                else if(first.compare("l")==0)
                {
                    if(current->l==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertlChild(current,"0");
                        current=current->l;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->l;

                    }
                }
                else if(first.compare("m")==0)
                {
                    if(current->m==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertmChild(current,"0");
                        current=current->m;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->m;
                    }
                }
                else if(first.compare("n")==0)
                {
                    if(current->n==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertnChild(current,"0");
                        current=current->n;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->n;

                    }
                }
                else if(first.compare("o")==0)
                {
                    if(current->o==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertoChild(current,"0");
                        current=current->o;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->o;
                    }
                }
                else if(first.compare("p")==0)
                {
                    if(current->p==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertpChild(current,"0");
                        current=current->p;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->p;

                    }
                }
                else if(first.compare("q")==0)
                {
                    if(current->q==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertqChild(current,"0");
                        current=current->q;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->q;
                    }
                }
                else if(first.compare("r")==0)
                {
                    if(current->r==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertrChild(current,"0");
                        current=current->r;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->r;

                    }
                }
                else if(first.compare("s")==0)
                {
                    if(current->s==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertsChild(current,"0");
                        current=current->s;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->s;
                    }
                }
                else if(first.compare("t")==0)
                {
                    if(current->t==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->inserttChild(current,"0");
                        current=current->t;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->t;

                    }
                }
                else if(first.compare("u")==0)
                {
                    if(current->u==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertuChild(current,"0");
                        current=current->u;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->u;
                    }
                }
                else if(first.compare("v")==0)
                {
                    if(current->v==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertvChild(current,"0");
                        current=current->v;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->v;

                    }
                }
                else if(first.compare("w")==0)
                {
                    if(current->w==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertwChild(current,"0");
                        current=current->w;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->w;
                    }
                }
                else if(first.compare("x")==0)
                {
                    if(current->x==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertxChild(current,"0");
                        current=current->x;


                    }
                    else//当前节点有该儿子
                    {
                        current=current->x;

                    }
                }
                else if(first.compare("y")==0)
                {
                    if(current->y==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertyChild(current,"0");
                        current=current->y;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->y;
                    }
                }
                else if(first.compare("z")==0)
                {
                    if(current->z==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertzChild(current,"0");
                        current=current->z;
                    }
                    else//当前节点有该儿子
                    {
                        current=current->z;
                    }
                }
            }
            else//到了最终的位置
            {
                if(first.compare("a")==0)
                {
                    if(current->a==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertaChild(current,word+":"+rownum);
                        current=current->a;
                    }
                    else
                    {
                         this->insertaChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("b")==0)
                {
                    if(current->b==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertbChild(current,word+":"+rownum);
                        current=current->b;
                    }
                    else
                    {
                         this->insertbChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("c")==0)
                {
                    if(current->c==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertcChild(current,word+":"+rownum);
                        current=current->c;
                    }
                    else
                    {
                         this->insertcChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("d")==0)
                {
                    if(current->d==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertdChild(current,word+":"+rownum);
                        current=current->d;
                    }
                    else
                    {
                         this->insertdChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("e")==0)
                {
                    if(current->e==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->inserteChild(current,word+":"+rownum);
                        current=current->e;
                    }
                    else
                    {
                         this->inserteChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("f")==0)
                {
                    if(current->f==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertfChild(current,word+":"+rownum);
                        current=current->f;
                    }
                    else
                    {
                         this->insertfChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("g")==0)
                {
                    if(current->g==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertgChild(current,word+":"+rownum);
                        current=current->g;
                    }
                    else
                    {
                         this->insertgChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("h")==0)
                {
                    if(current->h==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->inserthChild(current,word+":"+rownum);
                        current=current->h;
                    }
                    else
                    {
                         this->inserthChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("i")==0)
                {
                    if(current->i==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertiChild(current,word+":"+rownum);
                        current=current->i;
                    }
                    else
                    {
                         this->insertiChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("j")==0)
                {
                    if(current->j==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertjChild(current,word+":"+rownum);
                        current=current->j;
                    }
                    else
                    {
                         this->insertjChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("k")==0)
                {
                    if(current->k==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertkChild(current,word+":"+rownum);
                        current=current->k;
                    }
                    else
                    {
                         this->insertkChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("l")==0)
                {
                    if(current->l==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertlChild(current,word+":"+rownum);
                        current=current->l;
                    }
                    else
                    {
                         this->insertlChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("m")==0)
                {
                    if(current->m==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertmChild(current,word+":"+rownum);
                        current=current->m;
                    }
                    else
                    {
                         this->insertmChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("n")==0)
                {
                    if(current->n==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertnChild(current,word+":"+rownum);
                        current=current->n;
                    }
                    else
                    {
                         this->insertnChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("o")==0)
                {
                    if(current->o==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertoChild(current,word+":"+rownum);
                        current=current->o;
                    }
                    else
                    {
                         this->insertoChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("p")==0)
                {
                    if(current->p==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertpChild(current,word+":"+rownum);
                        current=current->p;
                    }
                    else
                    {
                         this->insertpChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("q")==0)
                {
                    if(current->q==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertqChild(current,word+":"+rownum);
                        current=current->q;
                    }
                    else
                    {
                         this->insertqChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("r")==0)
                {
                    if(current->r==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertrChild(current,word+":"+rownum);
                        current=current->r;
                    }
                    else
                    {
                         this->insertrChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("s")==0)
                {
                    if(current->s==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertsChild(current,word+":"+rownum);
                        current=current->s;
                    }
                    else
                    {
                         this->insertsChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("t")==0)
                {
                    if(current->t==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->inserttChild(current,word+":"+rownum);
                        current=current->t;
                    }
                    else
                    {
                         this->inserttChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("u")==0)
                {
                    if(current->u==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertuChild(current,word+":"+rownum);
                        current=current->u;
                    }
                    else
                    {
                         this->insertuChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("v")==0)
                {
                    if(current->v==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertvChild(current,word+":"+rownum);
                        current=current->v;
                    }
                    else
                    {
                         this->insertvChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("w")==0)
                {
                    if(current->w==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertwChild(current,word+":"+rownum);
                        current=current->w;
                    }
                    else
                    {
                         this->insertwChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("x")==0)
                {
                    if(current->x==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertxChild(current,word+":"+rownum);
                        current=current->x;
                    }
                    else
                    {
                         this->insertxChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("y")==0)
                {
                    if(current->y==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertyChild(current,word+":"+rownum);
                        current=current->y;
                    }
                    else
                    {
                         this->insertyChild(current,word+":"+rownum);
                    }
                }
                else if(first.compare("z")==0)
                {
                    if(current->z==NULL)//若当前节点没有儿子则插入新儿子
                    {
                        this->insertzChild(current,word+":"+rownum);
                        current=current->z;
                    }
                    else
                    {
                         this->insertzChild(current,word+":"+rownum);
                    }
                }


            }

        }

    }
    // 下面的方法用来查询一个单词返回单词的行号
    string queryWord(string word)
    {
        int length=word.length();//获取当前单词的长度
        BinaryTreeNode* current = this->root;//current用来遍历树
        //下面将word的字母一个个取出来判断该单词在树中的位置
        for(int i=0;i<length;i++)
        {
            string first;
            first=word.substr(i,1);//依次获取字母
            if(i<length-1)//还没到最终的位置
            {
                if(first.compare("a")==0)
                {
                    if(current->a==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->a;
                    }
                }
                else if(first.compare("b")==0)
                {
                    if(current->b==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->b;
                    }
                }
                else if(first.compare("c")==0)
                {
                    if(current->c==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->c;
                    }
                }
                else if(first.compare("d")==0)
                {
                    if(current->d==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->d;

                    }
                }
                else if(first.compare("e")==0)
                {
                    if(current->e==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->e;
                    }
                }
                else if(first.compare("f")==0)
                {
                    if(current->f==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->f;

                    }
                }
                else if(first.compare("g")==0)
                {
                    if(current->g==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->g;
                    }
                }
                else if(first.compare("h")==0)
                {
                    if(current->h==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->h;

                    }
                }
                else if(first.compare("i")==0)
                {
                    if(current->i==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->i;
                    }
                }
                else if(first.compare("j")==0)
                {
                    if(current->j==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->j;

                    }
                }
                else if(first.compare("k")==0)
                {
                    if(current->k==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->k;
                    }
                }
                else if(first.compare("l")==0)
                {
                    if(current->l==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->l;

                    }
                }
                else if(first.compare("m")==0)
                {
                    if(current->m==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->m;
                    }
                }
                else if(first.compare("n")==0)
                {
                    if(current->n==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->n;

                    }
                }
                else if(first.compare("o")==0)
                {
                    if(current->o==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->o;
                    }
                }
                else if(first.compare("p")==0)
                {
                    if(current->p==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->p;

                    }
                }
                else if(first.compare("q")==0)
                {
                    if(current->q==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->q;
                    }
                }
                else if(first.compare("r")==0)
                {
                    if(current->r==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->r;

                    }
                }
                else if(first.compare("s")==0)
                {
                    if(current->s==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->s;
                    }
                }
                else if(first.compare("t")==0)
                {
                    if(current->t==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->t;

                    }
                }
                else if(first.compare("u")==0)
                {
                    if(current->u==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->u;
                    }
                }
                else if(first.compare("v")==0)
                {
                    if(current->v==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->v;

                    }
                }
                else if(first.compare("w")==0)
                {
                    if(current->w==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->w;
                    }
                }
                else if(first.compare("x")==0)
                {
                    if(current->x==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->x;

                    }
                }
                else if(first.compare("y")==0)
                {
                    if(current->y==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->y;
                    }
                }
                else if(first.compare("z")==0)
                {
                    if(current->z==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//当前节点有该儿子
                    {
                        current=current->z;
                    }
                }
            }
            else//到了最终的位置
            {
                if(first.compare("a")==0)
                {
                    if(current->a==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                         levelOrder(current->a);
                         return current->a->rownum;
                    }
                }
                else if(first.compare("b")==0)
                {
                    if(current->b==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->b);
                        return current->b->rownum;

                    }
                }
                else if(first.compare("c")==0)
                {
                    if(current->c==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->c);
                        return current->c->rownum;

                    }
                }
                else if(first.compare("d")==0)
                {
                    if(current->d==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->d);
                         return current->d->rownum;

                    }
                }
                else if(first.compare("e")==0)
                {
                    if(current->e==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->e);
                         return current->e->rownum;

                    }
                }
                else if(first.compare("f")==0)
                {
                    if(current->f==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->f);
                         return current->f->rownum;
                    }
                }
                else if(first.compare("g")==0)
                {
                    if(current->g==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->g);
                         return current->g->rownum;
                    }
                }
                else if(first.compare("h")==0)
                {
                    if(current->h==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->h);
                         return current->h->rownum;
                    }
                }
                else if(first.compare("i")==0)
                {
                    if(current->i==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->i);
                         return current->i->rownum;
                    }
                }
                else if(first.compare("j")==0)
                {
                    if(current->j==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->j);
                         return current->j->rownum;
                    }
                }
                else if(first.compare("k")==0)
                {
                    if(current->k==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->k);
                         return current->k->rownum;
                    }
                }
                else if(first.compare("l")==0)
                {
                    if(current->l==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->l);
                         return current->l->rownum;
                    }
                }
                else if(first.compare("m")==0)
                {
                    if(current->m==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->m);
                         return current->m->rownum;
                    }
                }
                else if(first.compare("n")==0)
                {
                    if(current->n==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->n);
                         return current->n->rownum;
                    }
                }
                else if(first.compare("o")==0)
                {
                    if(current->o==NULL)//若当前节点没有儿子则表示没有这个单词
                    {

                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->o);
                         return current->o->rownum;
                    }
                }
                else if(first.compare("p")==0)
                {
                    if(current->p==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->p);
                         return current->p->rownum;
                    }
                }
                else if(first.compare("q")==0)
                {
                    if(current->q==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->q);
                         return current->q->rownum;
                    }
                }
                else if(first.compare("r")==0)
                {
                    if(current->r==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->r);
                         return current->r->rownum;
                    }
                }
                else if(first.compare("s")==0)
                {
                    if(current->s==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->s);
                         return current->s->rownum;
                    }
                }
                else if(first.compare("t")==0)
                {
                    if(current->t==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->t);
                         return current->t->rownum;
                    }
                }
                else if(first.compare("u")==0)
                {
                    if(current->u==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->u);
                         return current->u->rownum;
                    }
                }
                else if(first.compare("v")==0)
                {
                    if(current->v==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->v);
                         return current->v->rownum;
                    }
                }
                else if(first.compare("w")==0)
                {
                    if(current->w==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->w);
                         return current->w->rownum;
                    }
                }
                else if(first.compare("x")==0)
                {
                    if(current->x==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->x);
                         return current->x->rownum;
                    }
                }
                else if(first.compare("y")==0)
                {
                    if(current->y==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->y);
                         return current->y->rownum;
                    }
                }
                else if(first.compare("z")==0)
                {
                    if(current->z==NULL)//若当前节点没有儿子则表示没有这个单词
                    {
                        return "-1";//返回-1表示查询失败

                    }
                    else//查询成功，返回行号
                    {
                        levelOrder(current->z);
                         return current->z->rownum;
                    }
                } 
            }

        }
    }

    void levelOrder(BinaryTreeNode* t)//层次遍历
    {
        LinkQueue q;
        bool isNullAtFirst = true;
        while (t)
        {
            if(t->rownum.compare("0")!=0)//如果不是0表示有单词存储在这个位置
                cout << t->rownum<< endl;

            if (t->a) q.inQueue(t->a);
            if (t->b) q.inQueue(t->b);
            if (t->c) q.inQueue(t->c);
            if (t->d) q.inQueue(t->d);
            if (t->e) q.inQueue(t->e);
            if (t->f) q.inQueue(t->f);
            if (t->g) q.inQueue(t->g);
            if (t->h) q.inQueue(t->h);
            if (t->i) q.inQueue(t->i);
            if (t->j) q.inQueue(t->j);
            if (t->k) q.inQueue(t->k);
            if (t->l) q.inQueue(t->l);
            if (t->m) q.inQueue(t->m);
            if (t->n) q.inQueue(t->n);
            if (t->o) q.inQueue(t->o);
            if (t->p) q.inQueue(t->p);
            if (t->q) q.inQueue(t->q);
            if (t->r) q.inQueue(t->r);
            if (t->s) q.inQueue(t->s);
            if (t->t) q.inQueue(t->t);
            if (t->u) q.inQueue(t->u);
            if (t->v) q.inQueue(t->v);
            if (t->w) q.inQueue(t->w);
            if (t->x) q.inQueue(t->x);
            if (t->y) q.inQueue(t->y);
            if (t->z) q.inQueue(t->z);

            if (q.empty()) return;

            q.outQueue(t);
        }
    }
    // void preOrderForCount(BinaryTreeNode* t)//用了前序遍历的方法来计算二叉树节点数目
    // {
    //     if (t)
    //     {
    //         count++;
    //         preOrderForCount(t->leftChild);
    //         preOrderForCount(t->rightChild);
    //     }
    // }
    // int height(BinaryTreeNode* t)//返回一个节点的高度
    // {
    //     if (!t) return 0;
    //     int heightLeft = height(t->leftChild);
    //     int heightRight = height(t->rightChild);
    //     if (heightLeft > heightRight) return ++heightLeft;
    //     else return ++heightRight;
    // }
    // int size()//返回二叉树节点数目
    // {
    //     count = 0;
    //     preOrderForCount(root);
    //     return count;
    // }

    BinaryTreeNode* root;
    int count ;
};




int main()
{
    BinaryTree b;
    b.root = new BinaryTreeNode();
    // b.storeWord("boy","3");
    // b.storeWord("boyfriend","4");
    // b.levelOrder(b.root);
   // cout << b.queryWord("boy") << endl;

    ifstream in("input.txt");  
    string filename;  
    string line;  

    if(in) // 有该文件  
    {  
        int i=1;
        while (getline (in, line)) // line中不包括每行的换行符  
        {   //将int转string
            stringstream stream;     //声明一个stringstream变量 
            int n; 
            string str; 
            stream << i;     //向stream中插入整型数1234 
            stream >> str;   
            //将int转string

           // istringstream f(line);
           // std::vector<std::string> strings;
           // string s; 
           // while (std::getline(f, s, ' ')) 
           // {
                b.storeWord(line,str);

            //}


            i++; 
        }  
    }
    // else // 没有该文件  
    // {  
    //     cout <<"no such file" << endl;  
    // }  
    // b.levelOrder(b.root);
    cout << b.queryWord("boy") << endl;
    system("pause");
    return 0;
}

下面是版本二：


#include <stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
#include <stdio.h>
#include<string.h>
#include <iostream>  
#include <cstdlib>
#include <cstdio>
#include <stack>  
#include <string>
#include <fstream>  
#include <sstream>
#include <iostream>
#include <vector>
using namespace std; 

class BinaryTreeNode//树的节点类
{
public:
    BinaryTreeNode()
    {

    }
    //BinaryTreeNode(char c, BinaryTreeNode* left, BinaryTreeNode* right) { data = c; leftChild = left; rightChild = right; }
    char nodeChar;
    string rownum ;
    BinaryTreeNode *BinaryTreeNodes[26];

};


class Node  //队列类中用链表存
{
public:
    BinaryTreeNode *data;
    Node *next;
    Node() { next = NULL; }
    Node(BinaryTreeNode *item, Node* link = NULL) { data = item; next = link; }
};





//队列类，作为层次遍历的辅助数据结构用
class LinkQueue
{
private:
    Node *front, *rear;
public:
    LinkQueue() { rear = front = new Node; };
    bool empty() 
    { 
        return front == rear;
    }
    void outQueue(BinaryTreeNode * &e)//出队列
    {
        Node *tmpPtr = front->next;
        e = tmpPtr->data;
        front->next = tmpPtr->next;
        if (rear == tmpPtr) rear = front;
        delete tmpPtr;
    }
    void inQueue(BinaryTreeNode * &e)//入队列
    {
        Node *tmpPtr = new Node(e);
        rear->next = tmpPtr;
        rear = tmpPtr;
    }

};








//二叉树类
class BinaryTree
{
public:
    BinaryTree() { root = 0; }



    //下面是接收一个单词储存到树中的方法
    void storeWord(BinaryTreeNode* t,string word ,string rownum)
    {
        cout << word<< endl;

        //求字符地址，方便将该字符放入到26叉树中的哪一叉中
        int k = word[0] - 'a';
        cout<<k<<endl;
        cout<<(t->BinaryTreeNodes[k]==NULL)<< endl;
        //如果该叉树为空，则初始化
        if (t->BinaryTreeNodes[k]==NULL)
        {
            cout<<4<<endl;
            t->BinaryTreeNodes[k] = new BinaryTreeNode();
            cout<<3<<endl;
            //记录下字符
            cout<<2<<endl;
            if(word.length() ==1)
            {
                t->BinaryTreeNodes[k]->rownum = rownum;
                return;
            }
        }
        else if(t->BinaryTreeNodes[k]!=NULL)
        {
            cout<<5<<endl;
            t->BinaryTreeNodes[k] = new BinaryTreeNode();
            //记录下字符
            cout<<6<<endl;
            if(word.length() ==1)
            {
                t->BinaryTreeNodes[k]->rownum = rownum;
                cout<<7<<endl;
                return;
            }
        }


        string nextWord = word.substr(1);

        //说明是最后一个字符，统计该词出现的次数

        storeWord(t->BinaryTreeNodes[k],nextWord, rownum);

    }
    // 下面的方法用来查询一个单词返回单词的行号
    string queryWord(string word)
    {

    }

    void levelOrder(BinaryTreeNode* t)//层次遍历
    {

    }
    // void preOrderForCount(BinaryTreeNode* t)//用了前序遍历的方法来计算二叉树节点数目
    // {
    //     if (t)
    //     {
    //         count++;
    //         preOrderForCount(t->leftChild);
    //         preOrderForCount(t->rightChild);
    //     }
    // }
    // int height(BinaryTreeNode* t)//返回一个节点的高度
    // {
    //     if (!t) return 0;
    //     int heightLeft = height(t->leftChild);
    //     int heightRight = height(t->rightChild);
    //     if (heightLeft > heightRight) return ++heightLeft;
    //     else return ++heightRight;
    // }
    // int size()//返回二叉树节点数目
    // {
    //     count = 0;
    //     preOrderForCount(root);
    //     return count;
    // }

    BinaryTreeNode* root;
    int count ;
};




int main()
{
     BinaryTree b;
    b.root = new BinaryTreeNode();
    // b.storeWord("boy","3");
    // b.storeWord("boyfriend","4");
    // b.levelOrder(b.root);
   // cout << b.queryWord("boy") << endl;

    ifstream in("input.txt");  
    string filename;  
    string line;  

    if(in) // 有该文件  
    {  
        int i=1;
        while (getline (in, line)) // line中不包括每行的换行符  
        {   //将int转string
            stringstream stream;     //声明一个stringstream变量 
            int n; 
            string str; 
            stream << i;     //向stream中插入整型数1234 
            stream >> str;   
            //将int转string

           // istringstream f(line);
           // std::vector<std::string> strings;
           // string s; 
           // while (std::getline(f, s, ' ')) 
           // {
                b.storeWord(b.root,line,str);

            //}


            i++; 
        }  
    }
    // else // 没有该文件  
    // {  
    //     cout <<"no such file" << endl;  
    // }  
    // b.levelOrder(b.root);

    system("pause");
    return 0;
}
liyongqi_
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java哈希表(1).zip
03-27
由于它的高效性能，哈希表被广泛应用于数据库、缓存系统、编程语言的字典实现等场景。 哈希表的基本操作包括插入、删除和查找。在Java中，`HashMap`类就是对哈希表的一种实现，它是`java.util`包的一部分。`HashMap...
字典树及其应用 功能介绍及实现
09-07
在实际应用中，字典树可以与其他数据结构和算法结合使用，例如，使用哈希表来存储字典树的节点，使用Bloom filter来快速查询字符串是否存在于字典树中。同时，字典树也可以用来解决many-to-many关系的问题，例如，在...
208.实现Trie树（字典树与哈希表实现）
Linke66的博客
09-19 573
1 字典树 Trie树又称字典树，字典树的数据结构如下所示； 下面这颗字典树包含的字符串集合是{ab，aza}； 每一个类Trie中包含一个vector<Trie*>children(26)，和isEnd（标记一个字符串的尾）； 比如我们要插入abc，先看根节点node中的的children[a-‘a’]是否有指向下一个Trie的指针，有的话代表存在第一个字符为‘a’的前缀，那么往下走，node=node->children[a-'a‘]; 再看这个节点的children[b-‘a’]中.
字典树(前缀树)
最新发布
m0_53157173的博客
03-20 695
Trie树，即字典树,又称单词查找树或键树,是一种树形结构，是一种哈希树的变种，典型应用是用于统计和排序大量相同的字符串，所以经常被搜索引擎系统用于文本词频统计。它的优点是: 利用字符串的公共前缀来减少查询时间，最大限度地减少无谓字符串的比较。有些参考书将堆直接定义为序列，但是，从逻辑结构上讲，还是将堆定义为完全二叉树更好。虽然堆的典型实现方法是数组，但从逻辑的角度上讲，堆实际上是一种树结构。Trie的核心思想是空间换时间，利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。
基础数据结构(二):字典树、并查集、堆、哈希表、字符串的哈希方式、STL的常见容器及其接口
CS_boy的博客
02-23 933
基础数据结构(二):字典树、并查集、堆、哈希表、字符串的哈希方式、STL的常见容器及其接口
算法基础复盘笔记Day04【数据结构】—— KMP、字典树（Tire）、并查集、堆、哈希表
Java技术一点通
03-18 1879
并查集是一种树形的数据结构。并查集支持的两个操作：合并：将两个子集合并成一个集合。查找：确定某个元素在哪个集合。带路径压缩的查找：根节点是集合的代表，查找就是找到元素所在集合的根。1. 如果父节点等于自己，则找到了根并返回；2. 如果还没有找到根，则继续递归查找；3. 在返回的路上，顺带修改各节点的父节点为根。
字典树，前缀树，某方面比哈希表还厉害的玩意
Advsance的博客
10-31 510
前缀树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质： 根节点不包含字符，除根节点外每一个节点都只包含一个字符。 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。 每个节点的所有
数据结构（五）字典以及哈希表
m0_58847961的博客
04-21 1707
一、字典 字典（dictionary）是一些元素的集合。 字典的特点：①字典是通过见制度来保存的 ②字典的主要特点是一一对应的关系.、 ③字典里面的键不允许重复，但是值可以，key也是无序的 二、字典和映射的关系: 有些编程语言中称这种映射关系为字典，因为它确实和生活中的字典比较相似.(比如Swift中Dictionary, Python中的dict) 有些编程语言中称这种映射关系为Map,注意Map在这里不要翻译成地图，而是翻译成映射.(比如Java中就有HashMap&TreeMap等
字典树_字典树_
10-03
2. 空间效率：相比于哈希表，字典树在空间上可能稍大，但对内存的使用更有序，适合于内存有限的环境。 3. 自动补全：通过遍历以查询字符串为前缀的分支，可以轻易找到所有可能的补全选项。 4. 插入与删除操作：插入...
haxibiao.rar_名哈希表
09-23
哈希表，又称散列表，是一种非常重要的数据结构，它在计算机科学中广泛应用于快速查找、插入和删除操作。在给定的“haxibiao.rar_名哈希表”程序中，我们聚焦于利用哈希表来存储30个人名，并通过计算查找次数和平均...
哈希表与字典树原理入门
06-24
数据结构中介绍hash表与trie树的原理，图文并茂，一看就懂
DT_字典树前缀推荐_源码
10-04
在实际应用中，字典树可以与其他数据结构和算法结合使用，如哈希表用于快速查找，Bloom Filter用于空间效率，或者TF-IDF、余弦相似度等方法来提升推荐的相关性。在编码实现上，通常使用递归、迭代或者栈等数据结构来...
字典树
西木风落
03-09 305
一、字典树 Trie树，即字典树，又称单词查找树或键树，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质： 1）根节点不包含字符，除根节点外每一个节...
字典树（Trie）
qq_38765867的博客
03-10 223
1、Trie树的数据结构 Trie树，即字典树，又称单词查找数或者键数。是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不限于字符串），所有经常被搜索引擎系统用于文本词频统计。 优点：最大限度地减少无谓的字符串比较，查询效率高于哈希表。 2、Trie数的核心思想 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 3...
哈希(hash)比树(tree)更快，索引结构为什么要设计成树型？
小泽
03-02 823
加速查找速度的数据结构，常见的有两类： 哈希，例如HashMap，查询/插入/修改/删除的平均时间复杂度都是O(1)； 树，例如平衡二叉搜索树，查询/插入/修改/删除的平均时间复杂度都是O(lg(n))； 可以看到，不管是读请求，还是写请求，哈希类型的索引，都要比树型的索引更快一些，那为什么，索引结构要设计成树型呢 索引设计成树形，和SQL的需求相关。 对于这样一个单行查询的SQL需求： select * from t where name=”john”; 确实是哈希索引更快，因为每次都只查询一条记录。
字符串学习笔记·哈希（Hash）与字典树（Trie）
Orchidany‘s blog
03-03 1545
这篇博客我打算皮一下qwq，适合初学者阅读（因为讲的是在太细了） 一、首先理解字符串操作的意义： 没意义 emmmmmm其实字符串操作的意义是很浅显的，比如百度的推荐搜索啊，比如查找比对一篇题解里有多少个相同或者不同的脏字然后kkksc03再根据其数量、恶劣程度决定用多大的刀将博主kill掉。。。所以字符串操作很重要啊喂qwq。 再来考虑时间：如果百度对于一个人的一次“常搜”推荐...
【字典树Trie】1.空间换时间 2.比hashmap快(使用了公共前缀)
focus-unchanged-thing
11-28 212
1.原理：通过公共前缀，来降低查询时间的开销，是一种空间换时间的做法。 2.比：hashmap快，是一种树形结构。常用于：统计、排序、保存大量的字符串(不限于)。
字典树应用及用哈希表代替
weixin_30765505的博客
09-06 168
[LeetCode 30] Substring with Concatenation of All Words 题目 You are given a string s, and a list of words words, that are all of the same length. Find all starting indices of substring(s) in s that is ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值