第1关：实现散列查找

于 2024-12-27 11:49:39 发布
阅读量811 收藏 16
点赞数 10
CC 4.0 BY-SA版权
分类专栏： 头歌代码 文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dust_as_light/article/details/144764232

任务描述
相关知识
编程要求
测试说明
任务描述
本关要求通过补全函数ILH_InsKey和ILH_DelKey来分别实现插入和删除操作。

相关知识
本关讨论散列存储，散列函数使用除留余数法，冲突解决方法采用独立链表地址法。假设有 8 个关键码： 7 , 15 , 23 , 31 , 12 , 14 , 10 , 17 ，采用散列函数hash(key)=key%7，其存储结构图如图 1 所示，它由 7 个独立链表组成，散列值相同的关键码在同一个链表里，独立链表的头结点组成散列表，一共 7 行，编号 0 , 1 , … , 6 。独立链表的每个结点是一个 struct HNode 结构，其定义如下：

struct HNode {
    int key; //假设关键码为整数
    HNode* next;
};
在散列表中，如果表项的key字段等于 0 （假设有效的关键码值不等于 0 ），则表示该行是一条空链表，例如图 1 中编号为 4 和编号为 6 的行。

散列表的开始地址保存在pn中，散列表的行数为n（图 1 中，n=7），将pn和n组织成结构：

struct LHTable {
    HNode* pn;  //指向散列表，每个表结点是独立链表的表头结点
    int n; //散列表的长度，一般取（小于等于数据个数的最大）质数
};


定义如下操作，各操作函数的功能详见下面给出的代码文件 indLnkHash.cpp 的代码框架：

LHTable* ILH_Create(int n);
void ILH_Free(LHTable* pt);
bool ILH_InsKey(LHTable* pt, int x);
bool ILH_FindKey(LHTable* pt, int x);
bool ILH_DelKey(LHTable* pt, int x);
void ILH_Print(LHTable *pt);
编程要求
本关的编程任务是补全 step2/indLnkHash.cpp 文件中的ILH_InsKey和ILH_DelKey函数来分别实现插入和删除操作。

具体请参见后续测试样例。
本关涉及的代码文件 indLnkHash.cpp 的代码框架如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "indLnkHash.h"
LHTable* ILH_Create(int n)
//创建散列表, n为表长度，最佳取值：n取小于等于数据个数的最大质数
{
    HNode* pn=(HNode*)malloc(sizeof(HNode)*n);
    for (int i=0; i<n; i++) {
        pn[i].key=0;
        pn[i].next=NULL;
    }
    LHTable* pt=(LHTable*)malloc(sizeof(LHTable));
    pt-> pn=pn;
    pt->n=n;
    return pt;
}
void ILH_Free(LHTable* pt)
//释放散列表
{
    if (pt==NULL) return;
    for (int i=0; i<pt->n; i++) {
        HNode* curr=pt->pn[i].next;
        while (curr) {
            HNode* next=curr->next;
            free(curr);
            curr=next;
        }
    }
    free(pt->pn);
    free(pt);
}
bool ILH_InsKey(LHTable* pt, int x)
//插入关键码x
//返回true，表示插入成功
//返回false，表示插入失败(关键码已经存在)
{
    // 请在此添加代码，补全函数ILH_InsKey
    /********** Begin *********/
    /********** End **********/
}
bool ILH_FindKey(LHTable* pt, int x)
//查找关键码x
//返回true表示找到
//返回false表示没找到
{
    int d=x%pt->n;
    if (pt->pn[d].key==0) {
        return false;
    }
    else if (pt->pn[d].key==x) 
        return true;
    HNode* curr=pt->pn[d].next;
    while (curr && curr->key!=x) curr=curr->next;
    if (curr) return  true;
    else return false;
}
bool ILH_DelKey(LHTable* pt, int x)
//删除关键码
//返回true表示该关键码存在，且成功删除
//返回false表示该关键码不存在
{
    // 请在此添加代码，补全函数ILH_DelKey
    /********** Begin *********/
    /********** End **********/
}
void ILH_Print(LHTable *pt)
{
    for (int i=0; i<pt->n; i++) {
        printf("%5d:  ", i);
        if (pt->pn[i].key) {
            printf("%d  ", pt->pn[i].key);
            HNode* curr=pt->pn[i].next;
            while (curr) {
                printf("-> %d  ", curr->key);
                curr=curr->next;
            }
            printf("\n");
        }
        else 
            printf("-\n");
    }
}
测试说明
本关的测试文件是 step2/Main.cpp ，测试过程如下：

平台编译 step2/Main.cpp ，然后链接相关程序库并生成 exe 可执行文件；

平台运行该 exe 可执行文件，并以标准输入方式提供测试输入；

平台获取该 exe 可执行文件的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。

输入输出格式说明

输入格式：
首先输入一个正整数n，创建一个长n的散列表。
然后输入多个操作：如果输入 “insert” ，则后面跟一个数x，表示将x插入；如果输入 “delete” ，则后面跟一个数x，表示将x删除；如果输入 “end” ，表示输入结束。

输出格式：
输出n个独立链表。

以下是平台对 step2/Main.cpp 的样例测试集：

样例输入：
11
insert 54
insert 77
insert 94
insert 89
insert 14
insert 45
insert 76
insert 23
insert 43
insert 47
end

样例输出：
    0:  77
    1:  89  -> 45  -> 23
    2:  -
    3:  14  -> 47
    4:  -
    5:  -
    6:  94
    7:  -
    8:  -
    9:  -
   10:  54  -> 76  -> 43

开始你的任务吧，祝你成功

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "indLnkHash.h"

LHTable* ILH_Create(int n)
//创建散列表, n为表长度，最佳取值：n取小于等于数据个数的最大质数
{
    HNode* pn=(HNode*)malloc(sizeof(HNode)*n);
    for (int i=0; i<n; i++) {
        pn[i].key=0;
        pn[i].next=NULL;
    }
    LHTable* pt=(LHTable*)malloc(sizeof(LHTable));
    pt-> pn=pn;
    pt->n=n;
    return pt;
}

void ILH_Free(LHTable* pt)
//释放散列表
{
    if (pt==NULL) return;
    for (int i=0; i<pt->n; i++) {
        HNode* curr=pt->pn[i].next;
        while (curr) {
            HNode* next=curr->next;
            free(curr);
            curr=next;
        }
    }
    free(pt->pn);
    free(pt);
}

bool ILH_InsKey(LHTable* pt, int x)
//插入关键码x
//返回true，表示插入成功
//返回false，表示插入失败(关键码已经存在)
{
    /*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
    HNode *p,*s;
    int i,y,n;

    n=pt->n;
    y=x-(x/n)*n;

    for(i=0;i<n;i++){
        if(y==i){
            if(!pt->pn[i].next&&pt->pn[i].key==0){
                pt->pn[i].key=x;
            }
            else{
                if(pt->pn[i].key==x){
                    return false;
                }

                p=pt->pn[i].next;
                while(p){
                    if(p->key==x){
                        return false;
                    }
                    p=p->next;
                }
                s=(HNode*)malloc(sizeof(HNode));
                s->key=x;
                s->next=NULL;

                p=pt->pn[i].next;
                if(p){
                    while(p->next) p=p->next;
                    p->next=s;
                }else{
                    pt->pn[i].next=s;
                }
            }
            return true;
        }
    }
    return false;
    
    /******END******/
    /*请不要修改[BEGIN,END]区域外的代码*/
}

bool ILH_FindKey(LHTable* pt, int x)
//查找关键码x
//返回true表示找到
//返回false表示没找到
{
    int d=x%pt->n;
    if (pt->pn[d].key==0) {
        return false;
    }
    else if (pt->pn[d].key==x) 
        return true;

    HNode* curr=pt->pn[d].next;
    while (curr && curr->key!=x) curr=curr->next;

    if (curr) return  true;
    else return false;
}

bool ILH_DelKey(LHTable* pt, int x)
//删除关键码
//返回true表示该关键码存在，且成功删除
//返回false表示该关键码不存在
{
    /*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
    HNode *p,*q;
    int i,y,n;

    n=pt->n;
    y=x-(x/n)*n;

    for(i=0;i<n;i++){
        if(y==i){
            if(pt->pn[i].key!=x){
                p=pt->pn[i].next;
                if(p&&p->key==x){
                    pt->pn[i].next=p->next;
                    free(p);
                    return true;
                }

                while(p&&p->next){
                    if(p->next->key==x){
                        q=p->next;
                        p->next=q->next;
                        free(p);
                    }
                    p=p->next;
                }
                return true;
            }
            else{
                if(pt->pn[i].next){
                    p=pt->pn[i].next;
                    q=p->next;
                    pt->pn[i].key=p->key;
                    pt->pn[i].next=q;
                    free(p);
                }
                else{
                    pt->pn[i].key=0;
                    pt->pn[i].next=NULL;
                }
                return true;
            }    
        }
    }
    return false;
    
    /******END******/
    /*请不要修改[BEGIN,END]区域外的代码*/
}

void ILH_Print(LHTable *pt)
{
    for (int i=0; i<pt->n; i++) {
        printf("%5d:", i);
        if (pt->pn[i].key) {
            printf("%d", pt->pn[i].key);
            HNode* curr=pt->pn[i].next;
            while (curr) {
                printf("->%d", curr->key);
                curr=curr->next;
            }
            printf("\n");
        }
        else 
            printf("-\n");
    }
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值