Linux自学day22-实现简单的单词及单词含义查询的功能

鱼嘻2025-02-19 9:04

一 查询单词及单词含义

这里有一个单词表，以下是单词表的一部分：

由单词和单词后的释义构成，中间用空格隔开。

根据单词表中的内容，完成让用户输入单词就获得单词含义的功能。

二 方法一 链表

dict.c代码：

复制代码 
#include "dict.h"
#include "public.h"

// 加载字典文件，返回链表头指针
struct list_head *load_dict_list(char *pfilename)
{
    // 定义链表头指针，初始化为 NULL
    struct list_head *phead = NULL;
    // 定义文件指针，初始化为 NULL
    FILE *fp = NULL;
    // 定义临时节点指针，初始化为 NULL
    word_t *ptmpnode = NULL;
    // 定义临时字符指针，初始化为 NULL
    char *ptmp = NULL;
    // 定义临时缓冲区，初始化为 0
    char tmpbuff[4096] = {0};
    // 定义 fgets 函数的返回值指针，初始化为 NULL
    char *pret = NULL;

    // 为链表头分配内存
    phead = malloc(sizeof(struct list_head));
    if (NULL == phead)
    {
        // 内存分配失败，输出错误信息
        ERR_MSG("fail to malloc");
        return NULL;
    }

    // 初始化链表头
    INIT_LIST_HEAD(phead);

    // 以只读方式打开字典文件
    fp = fopen(pfilename, "r");
    if (NULL == fp)
    {
        // 文件打开失败，输出错误信息
        ERR_MSG("fail to fopen");
        return NULL;
    }

    // 循环读取文件中的每一行
    while (1)
    {
        // 读取一行数据到临时缓冲区
        pret = fgets(tmpbuff, sizeof(tmpbuff), fp);
        if (NULL == pret)
        {
            // 读取到文件末尾，退出循环
            break;
        }

        // 将临时字符指针指向临时缓冲区
        ptmp = tmpbuff;
        // 找到第一个空格或字符串结束符
        while (*ptmp != ' ' && *ptmp != '\0')
        {
            ptmp++;
        }
        // 将空格替换为字符串结束符
        *ptmp = '\0';
        // 跳过空格
        ptmp++;
        while (*ptmp == ' ')
        {
            ptmp++;
        }

        // 为临时节点分配内存
        ptmpnode = malloc(sizeof(word_t));
        if (NULL == ptmpnode)
        {
            // 内存分配失败，输出错误信息
            ERR_MSG("fail to malloc");
            return NULL;
        }

        // 将单词复制到临时节点的 word 字段
        strcpy(ptmpnode->word, tmpbuff);
        // 将含义复制到临时节点的 mean 字段
        strcpy(ptmpnode->mean, ptmp);

        // 将临时节点添加到链表尾部
        list_add_tail(&ptmpnode->node, phead);
    }
    
    // 关闭文件
    fclose(fp);

    // 返回链表头指针
    return phead;
}

// 查找单词的含义，返回含义的指针
char *search_word_mean(struct list_head *phead, char *pword)
{
    // 定义临时节点指针，初始化为 NULL
    word_t *ptmpnode = NULL;

    // 遍历链表中的每个节点
    list_for_each_entry(ptmpnode, phead, node)
    {
        // 比较节点中的单词和要查找的单词是否相等
        if (0 == strcmp(ptmpnode->word, pword))
        {
            // 找到匹配的单词，返回含义的指针
            return ptmpnode->mean;
        }
    }

    // 没有找到匹配的单词，返回 NULL
    return NULL;
}

// 释放字典链表占用的内存
int free_dict_list(struct list_head *phead)
{
    // 定义两个临时节点指针，初始化为 NULL
    word_t *ptmpnode1 = NULL;
    word_t *ptmpnode2 = NULL;

    // 安全地遍历链表中的每个节点
    list_for_each_entry_safe(ptmpnode1, ptmpnode2, phead, node)
    {
        // 从链表中删除当前节点
        list_del(&ptmpnode1->node);
        // 释放当前节点占用的内存
        free(ptmpnode1);
    }
    // 释放链表头占用的内存
    free(phead);

    // 函数执行成功，返回 0
    return 0;
}

  • malloc 函数用于动态分配内存，需要检查返回值是否为 NULL。

  • fopen 函数用于打开文件，fclose 函数用于关闭文件。

  • fgets 函数用于从文件中读取一行数据。

  • strcpy 函数用于复制字符串。

  • list_add_tail 函数用于将节点添加到链表尾部。

  • list_for_each_entry 宏用于遍历链表中的每个节点。

  • list_for_each_entry_safe 宏用于安全地遍历链表中的每个节点，避免在删除节点时出现错误。

main.c 代码：

复制代码 
#include <stdio.h>
#include "public.h"
#include "dict.h"

// 主函数，程序的入口点
// argc 是命令行参数的数量，argv 是命令行参数的数组
int main(int argc, const char **argv)
{
    // 定义一个链表头指针，初始化为 NULL
    struct list_head *phead = NULL;
    // 定义一个字符数组，用于存储用户输入的单词，初始化为 0
    char word[256] = {0};
    // 定义一个字符指针，用于存储查找到的单词含义，初始化为 NULL
    char *pmean = NULL;

    // 调用 load_dict_list 函数加载字典文件，返回链表头指针
    phead = load_dict_list("./dict.txt");

    // 进入无限循环，等待用户输入
    while (1)
    {   
        // 提示用户输入要查询的单词
        printf("请输入要查询的单词:\n");
        // 读取用户输入的单词
        gets(word);

        // 如果用户输入的是 .quit，则退出循环
        if (0 == strcmp(word, ".quit"))
        {
            break;
        }

        // 调用 search_word_mean 函数查找单词的含义
        pmean = search_word_mean(phead, word);
        // 如果没有找到单词的含义
        if (NULL == pmean)
        {
            // 输出提示信息
            printf("臣妾查不到 %s\n", word);
        }
        else 
        {
            // 输出单词的含义
            printf("含义:%s\n", pmean);
        }
    }
    
    // 释放字典链表占用的内存
    free_dict_list(phead);
    // 将链表头指针置为 NULL
    phead = NULL;

    // 程序正常结束，返回 0
    return 0;
}

三 方法二 哈希表

hashtable.c 代码：

  • 文件功能：实现哈希表的创建、插入、查找、删除和销毁等操作。

  • 代码逻辑步骤 ：

    1. 创建哈希表 ：分配包含 MAXNUM 个链表头的数组内存，使用 INIT_LIST_HEAD 初始化每个链表头，并返回该数组指针。
    2. 插入单词到哈希表 ：
      • 为新节点分配内存，将单词和含义复制到节点中。
      • 根据单词首字母计算哈希键值，确定该节点应插入的链表。
      • 使用 list_add_order 将节点按字母升序插入到对应的链表中。
    3. 打印哈希表 ：遍历每个链表，使用 list_for_each 遍历链表中的每个节点，输出节点中的单词。
    4. 查找单词 ：根据单词首字母计算哈希键值，遍历对应的链表，使用 strcmp 比较节点中的单词和要查找的单词，若匹配则返回该节点指针；若遍历完链表仍未找到，则返回 NULL。
    5. 删除单词 ：循环调用 find_hashtable 查找匹配的节点，若找到则使用 list_del 从链表中删除该节点并释放其内存，直到未找到匹配节点为止，最后返回删除的节点数量。
    6. 销毁哈希表 ：遍历每个链表，使用 list_for_each_entry_safe 安全地遍历链表，删除每个节点并释放其内存，最后释放链表头数组的内存。

    #include "hashtable.h"
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>

    // 创建哈希表函数
    // 该函数会分配一个包含MAXNUM个链表头的数组，用于存储哈希表的链表
    struct list_head *create_hashtable(void)
    {
    int i = 0;
    struct list_head *pheadlist = NULL;

    复制代码 
      // 分配MAXNUM个链表头的内存空间
  pheadlist = malloc(MAXNUM * sizeof(struct list_head));
  if (NULL == pheadlist)
  {
      return NULL;  // 分配失败则返回NULL
  }

  // 初始化每个链表头
  for (i = 0; i < MAXNUM; i++)
  {
      INIT_LIST_HEAD(&pheadlist[i]);
  }

  return pheadlist;

    }

    // 比较函数，用于按字母升序比较两个节点中的单词
    // 参数pnew和pnode是两个链表节点指针
    static int asc_compare(struct list_head *pnew, struct list_head *pnode)
    {
    // 通过list_entry宏获取节点对应的hashnode_t结构体指针，再比较其中的单词
    if (strcmp(list_entry(pnew, hashnode_t, node)->word, list_entry(pnode, hashnode_t, node)->word) > 0)
    {
    return 1; // pnew的单词大于pnode的单词
    }
    else if (strcmp(list_entry(pnew, hashnode_t, node)->word, list_entry(pnode, hashnode_t, node)->word) < 0)
    {
    return -1; // pnew的单词小于pnode的单词
    }
    else
    {
    return 0; // 两个单词相等
    }
    }

    // 插入函数，将单词及其含义插入到哈希表中
    // 参数pheadlist是哈希表链表头数组，pword是要插入的单词，pmean是单词的含义
    int insert_hashtable(struct list_head *pheadlist, char *pword, char *pmean)
    {
    int key = 0;
    hashnode_t *ptmpnode = NULL;

    复制代码 
      // 分配一个新的hashnode_t节点的内存空间
  ptmpnode = malloc(sizeof(hashnode_t));
  if (NULL == ptmpnode)
  {
      return -1;  // 分配失败则返回-1
  }

  // 复制单词和含义到新节点
  strcpy(ptmpnode->word, pword);
  strcpy(ptmpnode->mean, pmean);

  // 根据单词首字母计算哈希键值
  if (*pword >= 'a' && *pword <= 'z')
  {
      key = *pword - 'a';
  }
  else if (*pword >= 'A' && *pword <= 'Z')
  {
      key = *pword - 'A' + 26;
  }
  else 
  {
      key = 52;
  }

  // 将新节点按升序插入到对应的链表中
  list_add_order(&ptmpnode->node, &pheadlist[key], asc_compare);

  return 0;

    }

    // 打印哈希表函数，将哈希表中的所有单词按链表顺序打印出来
    // 参数pheadlist是哈希表链表头数组
    int show_hashtable(struct list_head *pheadlist)
    {
    int i = 0;
    struct list_head *ptmpnode = NULL;

    复制代码 
      // 遍历每个链表
  for (i = 0; i < MAXNUM; i++)
  {
      printf("%d:", i);
      // 遍历链表中的每个节点
      list_for_each(ptmpnode, &pheadlist[i])
      {
          // 通过list_entry宏获取节点对应的hashnode_t结构体指针，打印其中的单词
          printf("%s ", list_entry(ptmpnode, hashnode_t, node)->word);
      }
      printf("\n");
  }

  return 0;

    }

    // 查找函数，根据单词查找对应的节点
    // 参数pheadlist是哈希表链表头数组，pword是要查找的单词
    hashnode_t *find_hashtable(struct list_head *pheadlist, char *pword)
    {
    int key = 0;
    struct list_head *ptmpnode = NULL;

    复制代码 
      // 根据单词首字母计算哈希键值
  if (*pword >= 'a' && *pword <= 'z')
  {
      key = *pword - 'a';
  }
  else if (*pword >= 'A' && *pword <= 'Z')
  {
      key = *pword - 'A' + 26;
  }
  else 
  {
      key = 52;
  }

  // 遍历对应的链表
  list_for_each(ptmpnode, &pheadlist[key])
  {
      // 通过list_entry宏获取节点对应的hashnode_t结构体指针，比较其中的单词
      if (strcmp(list_entry(ptmpnode, hashnode_t, node)->word, pword) == 0)
      {
          return list_entry(ptmpnode, hashnode_t, node);  // 找到则返回该节点
      }
      else if (strcmp(list_entry(ptmpnode, hashnode_t, node)->word, pword) > 0)
      {
          break;  // 若当前节点的单词大于要查找的单词，则停止查找
      }
  }
  
  return NULL;  // 未找到则返回NULL

    }

    // 删除函数，删除哈希表中所有匹配的单词节点
    // 参数parray是哈希表链表头数组，pword是要删除的单词
    int delete_hashtable(struct list_head *parray, char *pword)
    {
    hashnode_t *ptmpnode = NULL;
    int cnt = 0;

    复制代码 
      while (1)
  {
      // 查找匹配的节点
      ptmpnode = find_hashtable(parray, pword);
      if (NULL == ptmpnode)
      {
          break;  // 未找到则退出循环
      }

      // 从链表中删除该节点并释放内存
      list_del(&ptmpnode->node);
      free(ptmpnode);
      cnt++;
  }
  
  return cnt;  // 返回删除的节点数量

    }

    // 销毁函数，释放哈希表的所有内存
    // 参数parray是哈希表链表头数组
    int destroy_hashtable(struct list_head *parray)
    {
    int i = 0;
    hashnode_t *ptmpnode = NULL;
    hashnode_t *pnextnode = NULL;

    复制代码 
      // 遍历每个链表
  for (i = 0; i < MAXNUM; i++)
  {
      // 安全地遍历链表中的每个节点并释放内存
      list_for_each_entry_safe(ptmpnode, pnextnode, &parray[i], node)
      {
          free(ptmpnode);
      }
  }

  // 释放链表头数组的内存
  free(parray);

  return 0;

    }

dict.c 代码：

  • 文件功能：将字典文件加载到链表中，并提供查找单词含义和释放链表内存的功能。

  • 代码逻辑步骤 ：

    1. 加载字典到链表 ：
      • 分配链表头内存并初始化。
      • 打开字典文件，若打开失败则输出错误信息并返回 NULL。
      • 逐行读取文件内容，使用 strtok 分割每行内容，提取单词和含义。
      • 为每个单词和含义分配节点内存，将其复制到节点中，并使用 list_add_tail 将节点添加到链表尾部。
      • 关闭文件并返回链表头指针。
    2. 查找单词含义 ：遍历链表，使用 strcmp 比较节点中的单词和要查找的单词，若匹配则返回该节点中的含义；若遍历完链表仍未找到，则返回 NULL。
    3. 释放链表内存 ：使用 list_for_each_entry_safe 安全地遍历链表，删除每个节点并释放其内存，最后释放链表头的内存。

    #include "dict.h"
    #include "public.h"

    // 加载字典文件到链表中
    // 参数pfilename是字典文件的文件名
    struct list_head *load_dict_list(char *pfilename)
    {
    struct list_head *phead = NULL;
    FILE *fp = NULL;
    word_t *ptmpnode = NULL;
    char *ptmp = NULL;
    char tmpbuff[4096] = {0};
    char *pret = NULL;

    复制代码 
      // 分配链表头的内存空间
  phead = malloc(sizeof(struct list_head));
  if (NULL == phead)
  {
      ERR_MSG("fail to malloc");
      return NULL;
  }

  // 初始化链表头
  INIT_LIST_HEAD(phead);

  // 打开字典文件
  fp = fopen(pfilename, "r");
  if (NULL == fp)
  {
      ERR_MSG("fail to fopen");
      return NULL;
  }

  while (1)
  {
      // 从文件中读取一行
      pret = fgets(tmpbuff, sizeof(tmpbuff), fp);
      if (NULL == pret)
      {
          break;  // 读取到文件末尾则退出循环
      }

      ptmp = tmpbuff;
      // 找到单词和含义的分隔符
      while (*ptmp != ' ' && *ptmp != '\0')
      {
          ptmp++;
      }
      *ptmp = '\0';
      ptmp++;
      // 跳过多余的空格
      while (*ptmp == ' ')
      {
          ptmp++;
      }

      // 分配一个新的word_t节点的内存空间
      ptmpnode = malloc(sizeof(word_t));
      if (NULL == ptmpnode)
      {
          ERR_MSG("fail to malloc");
          return NULL;
      }

      // 复制单词和含义到新节点
      strcpy(ptmpnode->word, tmpbuff);
      strcpy(ptmpnode->mean, ptmp);

      // 将新节点添加到链表尾部
      list_add_tail(&ptmpnode->node, phead);
  }
  
  fclose(fp);  // 关闭文件

  return phead;

    }

    // 查找单词的含义
    // 参数phead是链表头指针，pword是要查找的单词
    char *search_word_mean(struct list_head *phead, char *pword)
    {
    word_t *ptmpnode = NULL;

    复制代码 
      // 遍历链表
  list_for_each_entry(ptmpnode, phead, node)
  {
      // 比较单词是否匹配
      if (0 == strcmp(ptmpnode->word, pword))
      {
          return ptmpnode->mean;  // 找到则返回含义
      }
  }

  return NULL;  // 未找到则返回NULL

    }

    // 释放字典链表的内存
    // 参数phead是链表头指针
    int free_dict_list(struct list_head *phead)
    {
    word_t *ptmpnode1 = NULL;
    word_t *ptmpnode2 = NULL;

    复制代码 
      // 安全地遍历链表并删除节点
  list_for_each_entry_safe(ptmpnode1, ptmpnode2, phead, node)
  {
      list_del(&ptmpnode1->node);
      free(ptmpnode1);
  }
  free(phead);  // 释放链表头的内存

  return 0;

    }

main.c 代码：

  • 文件功能：提供用户交互界面，让用户输入单词并从字典文件中查找其含义，同时记录查找耗时。

  • 代码逻辑步骤 ：

    1. 打开字典文件 ：使用 fopen 以只读模式打开 dict.txt 文件，若打开失败则输出错误信息并退出程序。
    2. 用户交互循环 ：不断提示用户输入要查找的单词，当用户输入 .quit 时退出循环。
    3. 查找单词 ：每次用户输入单词后，将文件指针重置到文件开头，逐行读取文件内容，使用 strtok 分割每行内容，比较单词是否匹配。若匹配则输出单词含义，并标记该单词已找到；若遍历完文件仍未找到，则输出未找到的提示信息。
    4. 记录查找耗时 ：使用 GET_START_TIME 和 GET_END_TIME 宏记录查找开始和结束时间，通过 GET_CONST_TIME 计算并输出查找耗时。
    5. 关闭文件 ：用户退出循环后，使用 fclose 关闭文件。

    #include <stdio.h>
    #include <string.h>
    #include "public.h"

    // 主函数，实现从文件中查找单词含义的功能
    int main(int argc, const char **argv)
    {
    FILE *fp = NULL;
    char *pret = NULL;
    char word[256] = {0};
    char tmpbuff[4096] = {0};
    int is_exist = 0;

    复制代码 
      // 打开字典文件
  fp = fopen("dict.txt", "r");
  if (NULL == fp)
  {
      ERR_MSG("fail to fopen");
      return -1;
  }

  while (1)
  {
      printf("请输入要查找的单词:\n");
      gets(word);

      if (strcmp(word, ".quit") == 0)
      {
          break;  // 输入.quit则退出循环
      }

      GET_START_TIME;  // 记录开始时间
      rewind(fp);  // 将文件指针重置到文件开头
      while (1)
      {
          // 从文件中读取一行
          pret = fgets(tmpbuff, sizeof(tmpbuff), fp);
          if (NULL == pret)
          {
              break;  // 读取到文件末尾则退出循环
          }

          // 查找单词是否匹配
          if (0 == strcmp(word, strtok(tmpbuff, " ")))
          {
              printf("含义:%s\n", strtok(NULL, "\r"));
              is_exist = 1;
              break;
          }
      }
      GET_END_TIME;  // 记录结束时间
      
      if (!is_exist)
      {
          printf("我没有找到 %s 单词\n", word);
      }
      printf("耗时: %.3lfms\n", GET_CONST_TIME);  // 输出查找耗时
  }
      
  fclose(fp);  // 关闭文件

  return 0;

    }

相关推荐
FAREWELL0007538 分钟前
C#进阶学习（九）委托的介绍
开发语言·学习·c#·委托
哈哈幸运1 小时前
MySQL运维三部曲初级篇：从零开始打造稳定高效的数据库环境
linux·运维·数据库·mysql·性能优化
俊俏的萌妹纸1 小时前
FLinkSQL流-小试牛刀
flink·c#·linq
soulermax2 小时前
数字ic后端设计从入门到精通2（含fusion compiler, tcl教学）
java·linux·服务器
黑心老人2 小时前
Mac OS系统下kernel_task占用大量CPU资源导致系统卡顿
linux·运维·服务器·macos
Zenexus2 小时前
Linux学习笔记协议篇（六）：SPI FLASH设备驱动
linux·笔记·arm
口嗨农民工2 小时前
ubuntu18.04启动不了修复
linux·运维·ubuntu
浅陌sss2 小时前
设计模式 --- 装饰器模式
设计模式·c#
du fei2 小时前
C# 单例模式
java·单例模式·c#
爱吃巧克力的程序媛3 小时前
C# 的 字符串插值（$） 和 逐字字符串（@） 功能
c#
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02我决定放弃搞 Java 了03RAG 实践- Ollama+RagFlow 部署本地知识库04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05YOLOv8改进 | 细节创新篇 | iAFF迭代注意力特征融合助力多目标细节涨点06DeepSeek各版本说明与优缺点分析07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08Scipy||第三章 线性代数 (scipy.linalg)09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10苍穹外卖面试总结