散列查找——分离链接法

已于 2023-03-22 17:59:03 修改
阅读量193 收藏 4
点赞数 1
分类专栏： 数据结构-练习集 文章标签： 数据结构 链表 算法 Powered by 金山文档
于 2023-03-22 15:59:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54731568/article/details/129711911
版权

字符串类型的关键词

一、分离链接法的结构声明

#define KeyLength 15//关键词字符串的最大长度
typedef char ElementType[KeyLength+1];//关键词类型用字符串
typedef int Index;//散列地址类型

/*-----------单链表定义-------------*/ 
typedef struct LNode *PtrToLNode; 
struct LNode{
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

/*-------------散列表定义-----------------*/
typedef struct TblNode *HashTable;
struct TblNode{
    int TableSize;//表的最大长度 
    List Heads; //指向链表头结点的数组 
};

二、分离链接法的初始化函数

int Prime(int N)
{
    //返回小于等于N的最大素数
    int i,p;
    if(N>=1&&N<=3)p=N;
    else p=(N%2)?N:N-1;//取奇数 
    while(p<=N&&p>4){
        for(i=(int)sqrt(p);i>2;i--)
            if(!(p%i))break;//p不是素数
        if(i==2)break;//p是素数
        else p-=2; 
    } 
    return p;
}
/*-------------创建-----------------*/
HashTable CreateTable(int TableSize)
{
    HashTable H;
    int i;
    H=(HashTable)malloc(sizeof(struct TblNode)) ;
    //保证散列表最大长度是素数 
    H->TableSize =Prime(TableSize);
    //分配链表头结点数组
    H->Heads =(List)malloc(sizeof(struct LNode)*H->TableSize );
    //初始化表头结点
    for(i=0;i<H->TableSize ;i++){
        H->Heads[i].Data [0]='\0';
        H->Heads[i].Next =NULL;
    }
 return H;
}

三、查找

/*----------哈希函数-----------*/
int Hash(const char *Key,int TableSize)
{
    unsigned int H=0;
    while(*Key!='\0')//位移映射 
        H=(H<<5)+*Key++;
        //左移5相对于*2^5 
    return H%TableSize;
}

/*----------查找-----------*/
Position Find(HashTable H,ElementType Key)
{
    Position P;
    Index Pos;
    Pos=Hash(Key,H->TableSize );
    P=H->Heads[Pos].Next ;//从链表的第一个结点开始
    //当未到表尾并且Key未被找到时
    while(P&&strcmp(P->Data ,Key))
        P=P->Next ;
    return P;//此时p指向找到的结点，或者NULL 
    
 }

四、插入

/*----------插入-----------*/
bool Insert(HashTable H,ElementType Key)
{
    //如果关键词已存在就不需要插入
    //如果不存在插入单链表的第一个结点 
    Position P,NewCell;
    Index Pos;
    P=Find(H,Key);
    if(!P){
        //关键词未被找到，插入链表的第一个结点
        NewCell=(Position) malloc(sizeof(struct LNode)) ;
        strcpy(NewCell->Data ,Key);
        Pos=Hash(Key,H->TableSize );//初识散列位置 
        //将NewCell插入为H->Heads[Pos]链表的第一个结点 
        NewCell->Next =H->Heads[Pos].Next;
        H->Heads[Pos].Next =NewCell ;
        return true;
     } 
    else{
        //关键词被找到
        printf("关键词已存在\n");
        return false; 
    }
 }

五、删除

过程：

找到需要删除的关键词在散列表中的位置：遍历散列地址+链表

找到关键词删除：找到需要删除的关键词的前驱,删除关键词的前驱结点

未找到关键词： 打印错误信息

bool Delete(HashTable H,ElementType Key)
{
     Position P,temp;
     Index Pos;
     Pos=Hash(Key,H->TableSize );
     P=H->Heads+Pos;//注意：是H->Heads+Pos不是H->Heads[Pos] 
     //当未到链表的结尾并且p的下一个结点不是Key时,对比下一个结点 
     while(P->Next&&strcmp(P->Next->Data,Key))
         P=P->Next ;
    if(!P->Next){
        printf("Not Find Key!\n");
        return false;
    }else{//找到了 ，p的下一个结点就是Key 
        temp=P->Next ;
        P->Next =temp->Next ;
        free(temp); 
        printf("%s is deleted from list Heads[%d]\n",Key,Pos);
        return true;
    }
 }

六、销毁

/*----------释放-----------*/
void DestroyTable(HashTable H)
{
    //释放CreateTable函数所占用的所以内存空间 
    int i;
    Position P,Tmp;
    //释放每一个链表的结点
    for(i=0;i<H->TableSize ;i++){
        P=H->Heads[i].Next;//从第一个结点开始 
        while(P){
            Tmp=P->Next ;
            free(P);
            P=Tmp;
        }
    } 
    free(H->Heads );//释放头结点数组 
    free(H);//释放散列表结点 
}

七、完整代码

//分离链接法
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h> 
#include<math.h>

//关键词类型用字符串，字符串的长度不超过15

/*--------分离链接法的结构声明----------*/ 

#define KeyLength 15//关键词字符串的最大长度
typedef char ElementType[KeyLength+1];//关键词类型用字符串
typedef int Index;//散列地址类型

/*-----------单链表定义-------------*/ 
typedef struct LNode *PtrToLNode; 
struct LNode{
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

/*-------------散列表定义-----------------*/
typedef struct TblNode *HashTable;
struct TblNode{
    int TableSize;//表的最大长度 
    List Heads; //指向链表头结点的数组 
};

int Prime(int N)
{
    //返回小于等于N的最大素数
    int i,p;
    if(N>=1&&N<=3)p=N;
    else p=(N%2)?N:N-1;//取奇数 
    while(p<=N&&p>4){
        for(i=(int)sqrt(p);i>2;i--)
            if(!(p%i))break;//p不是素数
        if(i==2)break;//p是素数
        else p-=2; 
    } 
    return p;
}
/*-------------创建-----------------*/
HashTable CreateTable(int TableSize)
{
    HashTable H;
    int i;
    H=(HashTable)malloc(sizeof(struct TblNode)) ;
    //保证散列表最大长度是素数 
    H->TableSize =Prime(TableSize);
    //分配链表头结点数组
    H->Heads =(List)malloc(sizeof(struct LNode)*H->TableSize );
    //初始化表头结点
    for(i=0;i<H->TableSize ;i++){
        H->Heads[i].Data [0]='\0';
        H->Heads[i].Next =NULL;
    }
 return H;
}

/*----------哈希函数-----------*/
int Hash(const char *Key,int TableSize)
{
    unsigned int H=0;
    while(*Key!='\0')//位移映射 
        H=(H<<5)+*Key++;
        //左移5相对于*2^5 
    return H%TableSize;
}

/*----------查找-----------*/
Position Find(HashTable H,ElementType Key)
{
    Position P;
    Index Pos;
    Pos=Hash(Key,H->TableSize );
    P=H->Heads[Pos].Next ;//从链表的第一个结点开始
    //当未到表尾并且Key未被找到时
    while(P&&strcmp(P->Data ,Key))
        P=P->Next ;
    return P;//此时p指向找到的结点，或者NULL 
    
 } 

/*----------插入-----------*/
bool Insert(HashTable H,ElementType Key)
{
    //如果关键词已存在就不需要插入
    //如果不存在插入单链表的第一个结点 
    Position P,NewCell;
    Index Pos;
    P=Find(H,Key);
    if(!P){
        //关键词未被找到，插入链表的第一个结点
        NewCell=(Position) malloc(sizeof(struct LNode)) ;
        strcpy(NewCell->Data ,Key);
        Pos=Hash(Key,H->TableSize );//初识散列位置 
        //将NewCell插入为H->Heads[Pos]链表的第一个结点 
        NewCell->Next =H->Heads[Pos].Next;
        H->Heads[Pos].Next =NewCell ;
        return true;
     } 
    else{
        //关键词被找到
        printf("关键词已存在\n");
        return false; 
    }
 } 
/*----------删除-----------*/
/*
过程：
找到需要删除的关键词在散列表中的位置：遍历散列地址+链表
找到关键词删除：找到需要删除的关键词的前驱,删除关键词的前驱结点
未找到关键词： 打印错误信息 
*/ 
bool Delete(HashTable H,ElementType Key)
{
     Position P,temp;
     Index Pos;
     Pos=Hash(Key,H->TableSize );
     P=H->Heads+Pos;//注意：是H->Heads+Pos不是H->Heads[Pos] 
     //当未到链表的结尾并且p的下一个结点不是Key时,对比下一个结点 
     while(P->Next&&strcmp(P->Next->Data,Key))
         P=P->Next ;
    if(!P->Next){
        printf("Not Find Key!\n");
        return false;
    }else{//找到了 ，p的下一个结点就是Key 
        temp=P->Next ;
        P->Next =temp->Next ;
        free(temp); 
        printf("%s is deleted from list Heads[%d]\n",Key,Pos);
        return true;
    }
 } 


/*----------释放-----------*/
void DestroyTable(HashTable H)
{
    //释放CreateTable函数所占用的所以内存空间 
    int i;
    Position P,Tmp;
    //释放每一个链表的结点
    for(i=0;i<H->TableSize ;i++){
        P=H->Heads[i].Next;//从第一个结点开始 
        while(P){
            Tmp=P->Next ;
            free(P);
            P=Tmp;
        }
    } 
    free(H->Heads );//释放头结点数组 
    free(H);//释放散列表结点 
}

//打印结果 
void PrintResult(HashTable H)
{
    int i;
    printf("散列表:散列地址：关键词\n"); 
    for(i=0;i<H->TableSize ;i++){
        printf("       %d       ：",i);
        Position P=H->Heads[i].Next;
        if(!P)printf(" NULL");
        while(P){
            printf(" %s",P->Data );
            P=P->Next ;
        }
        printf("\n");
    } 
 } 
 
int main()
{
    HashTable H;
    printf("请输入散列表的长度：");
    int N,i;
    scanf("%d",&N);
    //创建
    H=CreateTable(N);
    printf("散列表的真实长度（地址空间大小）:%d\n",H->TableSize );
    //插入 
    ElementType Key;
    printf("请输入插入的关键词的个数："); 
    scanf("%d",&N);
    getchar();
    printf("请输入%d个关键词：\n",N); 
    for(i=0;i<N;i++){
        scanf("%s",Key);
        Insert(H,Key);
    } 
    //打印
    PrintResult(H);
    
    //删除
    printf("请输入删除的关键词的个数："); 
    scanf("%d",&N);
    getchar();
    printf("请输入%d个关键词：\n",N); 
    for(i=0;i<N;i++){
        scanf("%s",Key);
        Delete(H,Key);
    } 
    PrintResult(H);
    
    //销毁 
    DestroyTable(H);
    printf("散列表已销毁\n");
    
    return 0;
}

八、运行

f-f-g
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ hash.zip
04-23
接下来，我们谈谈处理冲突的方法——分离链表法。在散列中，冲突是指不同的输入值经过散列函数计算后得到相同的数组索引。分离链表法是一种有效的解决冲突的策略，它在每个数组槽内维护一个链表。当发生冲突时，...
数据结构学习笔记
weixin_30762087的博客
06-06 701
数据结构 第一章 概 论 1.数据：信息的载体,能被计算机识别、存储和加工处理。 2.数据元素：数据的基本单位，可由若干个数据项组成，数据项是具有独立含义的最小标识单位。 3.数据结构：数据之间的相互关系，即数据的组织形式。 它包括：1）数据的逻辑结构，从逻辑关系上描述数据，与数据存储无关，独立于计算机； 2）数据的存储结构，是逻辑结构用计算机语言的实现，依赖于计算机语言。 3）数...
散列表—分离链接法
suitaox26456的博客
03-17 1330
分离链接法
分离链接法实现散列表
YXj13419349201的博客
12-11 398
　　散列表是一种用于查找的数据结构。其基本思想来自于索引，也可以看成是数组的一种扩展。对于一些数据信息，比如说图片文件名，如果我们要查找某张图片，通常将图片名作为关键字进行搜索。这个时候是不可能把图片名直接当成数组下标的，因此可以将图片名关键字通过某个函数映射为某个地址，或地址偏移量。那么每次要查找图片的时候直接输入关键字就能直接计算得出存储地址。其定义 　　　　　　　　　　　　　　　...
1190303027-杨文昊-lab21
08-03
如果发生冲突，采用链表链接冲突的元素，形成开放寻址法或链地址法的解决冲突策略。 - **散列表接口**：提供了`initTable()`用于初始化两个全局表格，`insertTable()`用于插入变量，`insertFunc()`用于插入函数，`...
【数据结构】单链表的增删改查
2302_78914800的博客
07-25 760
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 636
【代码】c语言（7.23）
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 773
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
《Java初阶数据结构》----7.＜优先级队列PriorityQueue＞
最新发布
m0_73456341的博客
07-25 836
本篇博客主要讲解Java基础语法中的 优先级队列、PriorityQueue的特性、常用方法介绍、编程题练习
数据结构：顺序表的实现
2303_81073778的博客
07-25 279
3.test.c文件。
数据结构：（1）线性表
weixin_71751116的博客
07-24 1058
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
EXT4 数据结构
弥川的博客
07-25 340
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
数据结构：数据类型与抽象数据类型
Weiki的博客
07-25 1203
数据结构：数据类型与抽象数据类型
【初阶数据结构】复杂度算法题篇
2301_79849925的博客
07-24 353
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
数据结构--二叉树详解
2302_81705247的博客
07-24 772
二叉树的分类、二叉树的遍历。一棵树的节点个数，求叶子节点的个数，获取k层节点的个数，树的高度，找到某个节点，检查两棵树是否相同，第二棵树是否是第一棵树的子树，翻转二叉树，判断一棵二叉树是否是平衡二叉树，对称二叉树
数据结构之《队列》
2303_81098358的博客
07-25 1502
章节中学习了线性表中除了顺序表和链表外的另一种结构——栈，在本篇中我们将继续学习另一种线性表的结构——队列，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【C语言】【数据结构】二分查找（数组的练习）
2401_86272648的博客
07-23 772
记录数组的三个位置：low、high、mid分别记录当前查找的数组子集的起始位置、结束位置、中间位置。当前数组子集的mid = (low + high) / 2，注意：C语言中整型数相除，结果会舍去小数部分。每次将要查找的数key与mid位置的数比较：如果key大于mid位置的数，说明key是在数组右半子集的范围里，那么更新子集的范围，low更新为mid+1；如果key小于mid位置的数，说明key是在数组左半子集的范围里，那么更新子集的范围，high更新为mid - 1。
【Java版数据结构】初识泛型
2302_81249757的博客
07-25 831
好久没有更新文章了，大概断更了20天，想着今天就写一下文章吧！最近也是又温习了一下数据结构，其实之前我写过关于数据结构的一个专栏那个专栏是写了顺序表，链表，栈和队列，但是那时是用C语言实现的，虽然数据结构不局限于语言，但是总归在语言的使用上有所不同，毕竟面向不同，一个是面向过程的C语言，一个是面向对象的Java。所以这次我打算起一个数据结构的Java专栏，当然由于之前已经写过有些地方会写得简洁一点，模糊的话大家可以去看一下前面得文章哦。今天是关于泛型的哦！
详解数据结构之二叉树(堆)
sparrowfart的博客
07-22 2185
如图：这两颗树就不是树形结构，根节点父节点：若一个节点含有子节点，则称这个节点为字节的的父节点，如图9为12个父节点。子节点/孩子节点：一个节点含有父节点那这个节点就为孩子节点，如图12.节点的度：一个节点右多少个孩子节点那他的度就为多少。树的层次：从根开始定义为第一层，根节点的子节点为第二层，以此类推。树的深度、高度：树的最大层次，如图，树最大有4层，那树的深度为4。叶子节点：度为0的节点为叶子节点。分支节点：度不为0的节点。兄弟节点：具有相同父节点的节点互称为兄弟节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值