问题 J: 单词检查(Ⅱ)- 二叉排序树实现

问题 J: 单词检查(Ⅱ)- 二叉排序树实现

题目描述
许多应用程序，如字处理软件，邮件客户端等，都包含了单词检查特性。单词检查是根据字典，找出输入文本中拼错的单词，我们认为凡是不出现在字典中的单词都是错误单词。不仅如此，一些检查程序还能给出类似拼错单词的修改建议单词。 例如字典由下面几个单词组成：
bake cake main rain vase
如果输入文件中有词vake ，检查程序就能发现其是一个错误的单词，并且给出 bake, cake或vase做为修改建议单词。
修改建议单词可以采用如下生成技术：
(1)在每一个可能位置插入‘a-‘z’中的一者
(2)删除单词中的一个字符
(3)用‘a’-'z’中的一者取代单词中的任一字符

很明显拼写检查程序的核心操作是在字典中查找某个单词，如果字典很大，性能无疑是非常关键的。

你写的程序要求读入字典文件，然后对一个输入文件的单词进行检查，列出其中的错误单词并给出修改建议。

本题要求使用使用二叉排序树维护字典。为了防止有些人取巧，本题要求输出相应的二叉排序树后序遍历。

输入
输入分为两部分。
第一部分是字典，每个单词占据一行，最后以仅包含’#'的一行表示结束。所有的单词都是不同的，字典中最多10000个单词。

输入的第二部分包含了所有待检测的单词，单词数目不超过50。每个单词占据一行，最后以仅包含’#'的一行表示结束。

字典中的单词和待检测的单词均由小写字母组成，并且单词最大长度为15。
输出
第一行输出二叉排序树字典的后序遍历，每一个单词后面跟一个空格。

然后按照检查次序每个单词输出一行，该行首先输出单词自身。如果单词在字典中出现，接着输出" is correct"。如果单词是错误的，那么接着输出’:‘，如果字典中有建议修改单词，则按照字典中出现的先后次序输出所有的建议修改单词（每个前面都添加一个空格），如果无建议修改单词，在’:'后直接换行。

样例输出 Copy

award contest be have has if me more too my is i 
me is correct
aware: award
m: i my me
contest is correct
hav: has have
oo: too
or:
i is correct
fi: i
mre: more me

实现过程

修改建议单词可以采用如下生成技术：
(1)在每一个可能位置插入‘a-‘z’中的一者
(2)删除单词中的一个字符
(3)用‘a’-'z’中的一者取代单词中的任一字符
很明显拼写检查程序的核心操作是在字典中查找某个单词，如果字典很大，性能无疑是非常关键的。
你写的程序要求读入字典文件，然后对一个输入文件的单词进行检查，列出其中的错误单词并给出修改建议。

本题要求：使用二叉排序树维护字典
1.将单词读入并存储为字典
2.将被查询单词读入并存储
3.将单词从左往右遍历并从单词表中查询
4.根据单词表判断单词是否正确
5.若单词不正确，再次遍历并在每个位置插入a~z得出修改意见
注：用string会方便不少，树结点结构需要有所变化，输出要求的是字典的输入先后次序

下面是对代码的详细解析：

1. 头文件和命名空间：

   • 包含 <bits/stdc++.h>，这是一个常用的头文件，包含了标准库中的大部分内容。
   • 使用 using namespace std; 来避免在标准库类型和函数前加 std::。

2. 常量和类型定义：

   • maxn 定义了数据的最大范围，这里设置为10万。
   • node 结构体定义了二叉树的节点，包含单词（string data）、深度（int d）、左子树（lc）和右子树（rc）指针。
   • ans 数组用于存储匹配的单词索引。
   • e、key 用于存储当前输入的单词和查询单词。
   • dex、cnt、dd 分别用于临时存储索引、单词计数和匹配单词计数。
   • n 用于存储查询单词的长度。
   • t 数组用于存储原始输入的单词。

3. Insert 函数：

   • 用于向二叉搜索树中插入新单词。

4. creat 函数：

   • 用于创建单词存储，读取输入直到遇到 #，将每个单词插入二叉搜索树。

5. display 函数：

   • 用于先序遍历二叉搜索树并打印所有单词。

6. Find 函数：

   • 用于在二叉搜索树中查找单词。

7. Search 函数：

   • 用于检查查询单词是否可以通过添加、删除或替换一个字母来匹配字典中的单词。它使用了一个简单的字符串匹配算法，并使用 ans 数组来存储找到的匹配单词的索引。

8. main 函数：

   • 初始化一个空的二叉搜索树。
   • 调用 creat 函数来创建单词存储。
   • 调用 display 函数来显示所有存储的单词。
   • 读取查询单词，直到遇到 #。
   • 对于每个查询单词，首先检查它是否是正确的。
   • 如果不正确，调用 Search 函数来查找可能的匹配单词。
   • 使用 sort 函数对找到的匹配单词索引进行排序。
   • 打印查询单词后跟冒号和所有匹配的单词。

9. 程序结束：

   • 主函数返回0，表示程序正常结束。

代码逻辑分析：

• 这段代码实现了一个基于二叉搜索树的单词检索系统，它可以快速地插入和查找单词。
• 它还实现了一个简单的算法来检查查询单词是否可以通过简单的修改来匹配字典中的单词。

改进建议：

• 考虑将函数和变量封装到类或命名空间中，以提高代码的模块化。
• 对 Search 函数的字符串匹配算法进行优化，以更准确地处理添加、删除和替换字母的情况。
• 考虑使用异常处理来管理输入错误和程序错误。

部分代码

代码如下（定义结构体判断单词）：

typedef struct node
{
    string data;
    int d;
    struct node *lc;
    struct node *rc;
} node,*judge;

代码如下（定义结构体存储单词）：

struct nod
{
    string ss;
}t[maxn];

代码如下（搜索单词）：

void Insert(judge &ro,int dex)
{
    if(!ro)
    {
        judge s=new node;
        s->data=e;
        s->d=dex;
        s->lc=s->rc=NULL;
        ro=s;
    }
    else if(e<ro->data) Insert(ro->lc,dex);
    else if(e>ro->data) Insert(ro->rc,dex);
}

代码如下（创建单词存储）：

void creat(judge &ro)
{
    cin>>e;
    cnt=0;
    while(e[0]!='#')
    {
        t[cnt].ss=e;
        Insert(ro,cnt);
        cnt++;
        cin>>e;
    }
}

代码如下（寻找单词）：

judge Find(judge ro)
{
    if(!ro||key==ro->data) return ro;
    else if(key<ro->data) Find(ro->lc);
    else Find(ro->rc);
}

代码如下（判断单词是否正确并依靠排序算法将单词书写序改正）：

void Search(judge ro)
{
    if(ro)
    {
        int length=(ro->data).size();
        int h=0,flag=0;
        int x=0,y=0;
        if(n-length==1||length-n==1||length==n)
        {
            while(x<n&&y<length)
            {
                if(key[x]==ro->data[y]) x++,y++,h++;
                else if(length-n==1) y++;
                else if(n-length==1) x++;
                else x++,y++;
            }
            if(length-n==1)
            {if(h==n) flag=1; }
            else if(n-length==1)
            {if(h==length) flag=1;}
            else{if(h==(n-1)) flag=1; }
            if(flag) ans[dd++]=ro->d;
        }
        Search(ro->lc);
        Search(ro->rc);
    }
}

---

AC代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5;
//定义数据最大范围
typedef struct node
{
    string data;
    int d;
    struct node *lc;
    struct node *rc;
} node,*judge;
//定义结构体判断单词
int ans[maxn];
string e,key;
int dex,cnt,dd;
int n;
struct nod
{
    string ss;
}t[maxn];
//定义结构体存储单词
 
void Insert(judge &ro,int dex)//搜索单词
{
    if(!ro)
    {
        judge s=new node;
        s->data=e;
        s->d=dex;
        s->lc=s->rc=NULL;
        ro=s;
    }
    else if(e<ro->data) Insert(ro->lc,dex);
    else if(e>ro->data) Insert(ro->rc,dex);
}
 
void creat(judge &ro)//创建单词存储
{
    cin>>e;
    cnt=0;
    while(e[0]!='#')
    {
        t[cnt].ss=e;
        Insert(ro,cnt);
        cnt++;
        cin>>e;
    }
}
 
void display(judge ro)//删除单词
{
    if(ro)
    {
        display(ro->lc);
        display(ro->rc);
        cout<<ro->data<<' ';
    }
}
 
judge Find(judge ro)//寻找单词
{
    if(!ro||key==ro->data) return ro;
    else if(key<ro->data) Find(ro->lc);
    else Find(ro->rc);
}
 
void Search(judge ro)//判断单词是否正确并依靠排序算法将单词书写序改正
{
    if(ro)
    {
        int length=(ro->data).size();
        int h=0,flag=0;
        int x=0,y=0;
        if(n-length==1||length-n==1||length==n)
        {
            while(x<n&&y<length)
            {
                if(key[x]==ro->data[y]) x++,y++,h++;
                else if(length-n==1) y++;
                else if(n-length==1) x++;
                else x++,y++;
            }
            if(length-n==1)
            {if(h==n) flag=1; }
            else if(n-length==1)
            {if(h==length) flag=1;}
            else{if(h==(n-1)) flag=1; }
            if(flag) ans[dd++]=ro->d;
        }
        Search(ro->lc);
        Search(ro->rc);
    }
}
int main()
{
    judge ro;
    ro=NULL;
    creat(ro);
    display(ro);
    cout<<"\n";
    while(cin>>key&&key[0]!='#')
    {
        cout<<key;
        int flag=0;
        if(Find(ro)!=NULL)
        {cout<<" is correct"<<endl; continue; }
        cout<<':';
        n=key.size();
        dd=0;
        Search(ro);
        sort(ans,ans+dd);
        for(int i=0;i<dd;i++) cout<<' '<<t[ans[i]].ss;
        cout<<"\n";
    }
}