散列——实验及提升训练

计算机平台作业答案讲解

于 2023-05-15 22:10:33 发布

阅读量218

点赞数 1

文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_65628600/article/details/130693948

版权

这段代码实现了一个哈希表的初始化，包括使用线性探测再散列处理冲突和拉链法处理冲突的两种方式。哈希函数为H(key)=(key*3)MOD7，初始化时所有元素设为-1（线性探测再散列）或0（拉链法）。此外，还包括插入元素、输出哈希表和计算哈希地址的函数。

摘要由CSDN通过智能技术生成

第1关：哈希表初始化

任务描述

本关任务：初始化哈希表满足下面要求。将关键字序列（7、8、30、11、18、9、14）散列存储到散列表中，散列函数为： H(key) = (key*3) MOD 7，处理冲突采用线性探测再散列法，要求装填（载）因子为0.7。初始化的哈希表中元素均为-1。

编程要求

根据提示，在右侧编辑器补充代码，分别初始化符合线性探测再散列方法使用的哈希表和使用拉链法处理冲突使用的哈希表结构。

#include <stdio.h>
#include <stdlib.h>

/*哈希结构*/
struct hashTable
{
  int *element;//存放键值的连续空间起始地址
  int maxNum;// 哈希表长度 
  int curNum;//当前哈希表已有数据元素 
};

struct node
{
  int data ;
  struct node *next;
};

struct hashTable_link
{
  struct node *element;
  int maxNum;// 哈希表长度  
};

/*第一关*/
//初始化一个哈希表，能满足线性探测再散列处理冲突法使用，初始化哈希表元素均为-1，表示该位置为空，可插入
struct hashTable* initHashTable_linear()
{
    int maxNum=10;
    struct hashTable *table=(struct hashTable*)malloc(sizeof(struct hashTable)*1);
    table->element=(int*)malloc(sizeof(int)*maxNum);
    if(!(table->element))
    {
      return table;
    }
    table->maxNum=maxNum;
    table->curNum=0;
    for(int i=0;i<maxNum;i++)
    {
      table->element[i]=-1;
    }
    return table;
}

//初始化一个哈希表，能满足拉链法处理冲突法使用。初始化哈希表元素为0，用于计算该条链中数据个数，在插入时增加
struct hashTable_link * initHashTable_link()
{
    int maxNum=10;
    struct hashTable_link *table=(struct hashTable_link*)malloc(sizeof(struct hashTable_link)*1);
    table->element=(struct node*)malloc(sizeof(struct node)*maxNum);
    table->maxNum=maxNum;
    for(int i=0;i<maxNum;i++)
    {
      table->element[i].data=0;
      table->element[i].next=NULL;
    }
    return table;
}

/*第二关*/
//输出线性探测再散列法构建的哈希表,从下标为0的元素开始输出，每输出一个数据空一格
void printHashTable(struct hashTable *h)
{
    for(int i=0;i<h->maxNum;i++)
    {
      printf("%d ",h->element[i]);
    }

}



/*第三关*/
//哈希函数，h(key) = (key*3) %  7
int hashFun(int key)
{
    return (key*3)%7;
}

//函数功能：计算key的哈希地址，若发生冲突，则使用线性探测再散列的方法查找合适的插入位置下标，并返回该下标
int findPos(struct hashTable *h , int key)
{
    key=hashFun(key);
    while(h->element[key]!=-1)
    {
      key=(key+1)%h->maxNum;
    }
    h->curNum+=1;
    return key;
}

//插入键值函数,若哈希表空间已满，则返回-1，否则返回插入位置下标
int insertKey(struct hashTable *h , int key)
{
    if(h->curNum==h->maxNum)
    {
      return -1;
    }
    int pos=findPos(h,key);
    h->element[pos]=key;
    return pos;
}

第2关：输出哈希表

#include <stdio.h>
#include <stdlib.h>

/*哈希结构*/
struct hashTable
{
  int *element;//存放键值的连续空间起始地址
  int maxNum;// 哈希表长度 
  int curNum;//当前哈希表已有数据元素 
};

struct node
{
  int data ;
  struct node *next;
};

struct hashTable_link
{
  struct node *element;
  int maxNum;// 哈希表长度  
};

/*第一关*/
//初始化一个哈希表，能满足线性探测再散列处理冲突法使用，初始化哈希表元素均为-1，表示该位置为空，可插入
struct hashTable* initHashTable_linear()
{
    int maxNum=10;
    struct hashTable *table=(struct hashTable*)malloc(sizeof(struct hashTable)*1);
    table->element=(int*)malloc(sizeof(int)*maxNum);
    if(!(table->element))
    {
      return table;
    }
    table->maxNum=maxNum;
    table->curNum=0;
    for(int i=0;i<maxNum;i++)
    {
      table->element[i]=-1;
    }
    return table;
}

//初始化一个哈希表，能满足拉链法处理冲突法使用。初始化哈希表元素为0，用于计算该条链中数据个数，在插入时增加
struct hashTable_link * initHashTable_link()
{
    int maxNum=10;
    struct hashTable_link *table=(struct hashTable_link*)malloc(sizeof(struct hashTable_link)*1);
    table->element=(struct node*)malloc(sizeof(struct node)*maxNum);
    table->maxNum=maxNum;
    for(int i=0;i<maxNum;i++)
    {
      table->element[i].data=0;
      table->element[i].next=NULL;
    }
    return table;
}

/*第二关*/
//输出线性探测再散列法构建的哈希表,从下标为0的元素开始输出，每输出一个数据空一格
void printHashTable(struct hashTable *h)
{
    for(int i=0;i<h->maxNum;i++)
    {
      printf("%d ",h->element[i]);
    }

}



/*第三关*/
//哈希函数，h(key) = (key*3) %  7
int hashFun(int key)
{
    return (key*3)%7;
}

//函数功能：计算key的哈希地址，若发生冲突，则使用线性探测再散列的方法查找合适的插入位置下标，并返回该下标
int findPos(struct hashTable *h , int key)
{
    key=hashFun(key);
    while(h->element[key]!=-1)
    {
      key=(key+1)%h->maxNum;
    }
    h->curNum+=1;
    return key;
}

//插入键值函数,若哈希表空间已满，则返回-1，否则返回插入位置下标
int insertKey(struct hashTable *h , int key)
{
    if(h->curNum==h->maxNum)
    {
      return -1;
    }
    int pos=findPos(h,key);
    h->element[pos]=key;
    return pos;
}

第3关：插入键值（线性探测再散列法处理冲突）

#include <stdio.h>
#include <stdlib.h>

/*哈希结构*/
struct hashTable
{
  int *element;//存放键值的连续空间起始地址
  int maxNum;// 哈希表长度 
  int curNum;//当前哈希表已有数据元素 
};

struct node
{
  int data ;
  struct node *next;
};

struct hashTable_link
{
  struct node *element;
  int maxNum;// 哈希表长度  
};

/*第一关*/
//初始化一个哈希表，能满足线性探测再散列处理冲突法使用，初始化哈希表元素均为-1，表示该位置为空，可插入
struct hashTable* initHashTable_linear()
{
    int maxNum=10;
    struct hashTable *table=(struct hashTable*)malloc(sizeof(struct hashTable)*1);
    table->element=(int*)malloc(sizeof(int)*maxNum);
    if(!(table->element))
    {
      return table;
    }
    table->maxNum=maxNum;
    table->curNum=0;
    for(int i=0;i<maxNum;i++)
    {
      table->element[i]=-1;
    }
    return table;
}

//初始化一个哈希表，能满足拉链法处理冲突法使用。初始化哈希表元素为0，用于计算该条链中数据个数，在插入时增加
struct hashTable_link * initHashTable_link()
{
    int maxNum=10;
    struct hashTable_link *table=(struct hashTable_link*)malloc(sizeof(struct hashTable_link)*1);
    table->element=(struct node*)malloc(sizeof(struct node)*maxNum);
    table->maxNum=maxNum;
    for(int i=0;i<maxNum;i++)
    {
      table->element[i].data=0;
      table->element[i].next=NULL;
    }
    return table;
}

/*第二关*/
//输出线性探测再散列法构建的哈希表,从下标为0的元素开始输出，每输出一个数据空一格
void printHashTable(struct hashTable *h)
{
    for(int i=0;i<h->maxNum;i++)
    {
      printf("%d ",h->element[i]);
    }

}



/*第三关*/
//哈希函数，h(key) = (key*3) %  7
int hashFun(int key)
{
    return (key*3)%7;
}

//函数功能：计算key的哈希地址，若发生冲突，则使用线性探测再散列的方法查找合适的插入位置下标，并返回该下标
int findPos(struct hashTable *h , int key)
{
    key=hashFun(key);
    while(h->element[key]!=-1)
    {
      key=(key+1)%h->maxNum;
    }
    h->curNum+=1;
    return key;
}

//插入键值函数,若哈希表空间已满，则返回-1，否则返回插入位置下标
int insertKey(struct hashTable *h , int key)
{
    if(h->curNum==h->maxNum)
    {
      return -1;
    }
    int pos=findPos(h,key);
    h->element[pos]=key;
    return pos;
}