散列表（哈希表)总结（C语言)

最新推荐文章于 2023-09-26 06:00:00 发布
最新推荐文章于 2023-09-26 06:00:00 发布
阅读量3.4k 收藏 110
点赞数 22
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46544385/article/details/116378169
版权

文章目录

散列表中的基本概念

散列表定义：
散列表（Hash table，也叫哈希表），是一种以常数时间执行插入、删除和查找的数据结构，它是是根据关键值(Key value)而直接进行访问的数据结构。也就是说它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

散列函数H(ElementType Key,HashTable H)的计算:
如果关键字Key是一个整形数字的话，那么我们对应的散列函数（或者哈希函数)主要有一下几种方法:
①折叠法
②直接定址法
③平方取中法
④除留余数法(更加常用):即关键字key在哈希表中的地址是key % H->TableSize。但也正因如此，使得在使用散列表的时候，会造成两个关键字会散列到哈希表中的同一个地址，这就是哈希冲突。所以我们需要解决哈希冲突是我们这章的关键。

解决哈希冲突的几种方案

分离链接法

所谓的分离链接法，就是采用数组+链表的形式,定义一个数组，并且每一个下标对应的都是一个链表的链表头。如果发生冲突的时候，并且这个新元素已经在哈希表中对应的链表中出现过了，那么就不执行任何的操作，反之，如果没有出现过，那么就将新的关键字插入到对应地址的链表头或者链表尾。如下图所示:
在这里插入图片描述

所以在采用分离链接法的时候，我们需要做的准备工作:
1、定义一个节点结构体Node，用于构建一个链表
2、定义一个结构体，表示哈希表HashTable，其中，这个结构体的成员变量主要有一个Node类型指针的数组，以及一个整形变量，表示这个哈希表的大小。

对应的代码:

#include<stdio.h>
#include<stdlib.h>
typedef struct NODE *Node;
typedef Node * List;
typedef struct HASHTABLE HashTable;

struct NODE{
   int data;
   Node next;
};
struct HASHTABLE{
   int size;//表示哈希表的大小
   List arr;
};
//初始化哈希表
void init(HashTable &H,int size){
   H.size = size;//初始化哈希表的大小
   H.arr = (List)malloc(sizeof(Node) * size);//给哈希表中的指针数组分配空间
   if(H.arr == NULL){
    printf("指针数组分配空间失败!!!\n");
    exit(0);
   }
   int i;
   for(i = 0; i < size; i++){
      H.arr[i] = (Node)malloc(sizeof(struct NODE));//给每一个节点分配空间
      if(H.arr[i] == NULL){
        printf("节点分配失败!!!\n");
        exit(0);
      }
      //每一个下标对应一条链表，并且这条链表是一个带有假节点的链表
      H.arr[i]->next = NULL;
   }
}
int hash(HashTable &H,int key){
    return key % H.size;//利用除留取余法，从而获取key在哈希表中的地址
}
/*
在哈希表中查找关键字key:
1、首先需要利用除留取余法获得key在哈希表中所处的链表位置
2、找到所处的链表之后，遍历链表，判断是否能找到值尾key的节点，如果能找到，
就将这个节点返回，否则返回null
*/
Node find(HashTable &H,int key){
    int pos;
    Node L,cur;
    pos = hash(H,key);//获取key在哈希表中的位置
    L = H.arr[pos];//获取key所在地址的链表
    cur = L->next;//由于L是一个带有假节点的链表，那么L->next才是链表真正的头结点
    while(cur != NULL && cur->data != key){
            //如果当前的节点不为空，并且当前节点的值不是要找的关键字，那么继续遍历链表
        cur = cur->next;
    }
    return cur;
}
/*
在哈希表中插入关键字
判断关键字是否已经存在哈希表中了，如果存在了，那么不进行任何操作，否则就将其
插入到对应的链表的链表头处
*/
void insert(HashTable &H,int key){
    Node L,p;
    p = find(H,key);
    if(p == NULL){
        //如果p为空，说明哈希表中并不存在这个这个关键字的节点，那么就将这个新节点插入到对应的链表头的位置
        L = H.arr[key % H.size];//获取关键字所处的链表
        p = (Node)malloc(sizeof(struct NODE));
        p->next = L->next;
        p->data = key;
        L->next = p;
        printf("插入成功!!!\n");
    }else{
        printf("关键字%d已经在哈希表中存在，所处的链表下标为%d\n",key,key % H.size);
    }
}
void deleteElement(HashTable &H,int key){
    Node L,p,tmp;
    p = find(H,key);
    if(p != NULL){
        //如果p不为空，说明哈希表中不存在这个这个关键字的节点
        L = H.arr[key % H.size];//获取关键字所处的链表
        p = L;
        while(p->next != NULL && p->next->data != key){
                //找到删除节点的前一个节点
            p = p->next;
        }
        tmp = p->next;//找到了删除的节点
        p->next = p->next->next;
        free(tmp);//释放待删除的节点
        printf("删除成功!!!\n");
    }else{
        printf("关键字%d在哈希表中不存在\n",key);
    }
}
void display(HashTable &H){
  int i;
  Node L;
  for(i = 0; i < H.size; i++){
    L = H.arr[i]->next;
    if(L == NULL){
        printf("NULL\n");
    }else{
       while(L != NULL){
         printf("%5d",L->data);
         L = L->next;
       }
       printf("\n");
    }
  }
}
int main(){
  HashTable h;
  int n,i,key;
  printf("请输入哈希表的大小:");
  scanf("%d",&n);
  init(h,n);
  printf("请输入元素的个数:");
  scanf("%d",&n);
  printf("请输入各个关键字:");
  for(i = 0; i < n; i++){
    scanf("%d",&key);
    insert(h,key);
  }
  while(1){
    printf("请输入选项: 1、插入 2、查找 3、删除 4、遍历哈希表 0、退出\n");
    scanf("%d",&n);
    switch(n){
      case 1:
        printf("请输入待插入数字:");
        scanf("%d",&key);
        insert(h,key);
        break;
      case 2:
        printf("请输入待查找数字:");
        scanf("%d",&key);
        if(find(h,key)){
            printf("找到了，所处的链表下标为%d\n",key % h.size);
        }else{
            printf("哈希表中无法找到%d\n",key);
        }
        break;
      case 3:
        printf("请输入待删除数字:");
        scanf("%d",&key);
        deleteElement(h,key);
        break;
      case 4:
        display(h);
        break;
      case 0:
        printf("退出系统");
        exit(0);
    }
  }
  return 0;
}

运行结果:
在这里插入图片描述

开放地址法

开放地址法是利用数组来实现的，它的基本思路是:如果发生冲突的时候，那么就需要寻找一个为空的单元进行存放这个关键字即可。所以第i次发生冲突的时候，关键字在哈希表中的下标是:hash =( hash(key) + F(i)) % H.tableSize

线性探测法

所谓的线性探测法，就是在上面的基本公式中，F（i) = 1,2,3,4,......n的形式后移。也就是说，如果发生冲突的话，他是在当前下标(即key % tableSize)的基础上加上F(i)。
对应的代码:

/*
线性探测法:
发生冲突的时候，往后移，知道找到第一个空的
单元，那么就将数字压入到这个单元即可
*/
#include<stdio.h>
#include<stdlib.h>
#define Empty 0
#define Occupy 1
typedef struct HASHTABLE HashTable;
typedef struct ELEMENT Element;
struct ELEMENT{
   int val;//值
   int state;//表示这个元素是否为空，如果是0，表示空，否则不为空
};
struct HASHTABLE{
   Element *arr;//用一个整形数组来表示哈希表
   int size;//哈希表的大小
};
//初始化哈希表
void init(HashTable &H,int size){
   H.arr = (Element *)malloc(sizeof(Element) * size);
   if(H.arr == NULL){
     printf("哈希表数组分配空间失败!!!\n");
     exit(0);
   }
   int i;
   //初始化哈希表，表示是一个空表
   for(i = 0; i < size; i++){
      H.arr[i].state = Empty;
   }
   H.size = size;
}
//定义哈希函数
int hash(HashTable &H,int key){
    return key % H.size;
}
//查找哈希表中key对应的下标
int findElement(HashTable &H,int key){
    int pos;
    pos = hash(H,key);//找到关键字在哈希表中散列的地址
    while(H.arr[pos].state != Empty && H.arr[pos].val != key){
        //如果当前下标不为空，并且对应的值不是我们要找的关键字，那么就后移
        pos++;
        /*
        pos %= H.size;
        */
        if(pos >= H.size)
            pos -= H.size;//如果后移的时候，对应的pos大于等于H.size，那么我们需要回到下标为pos - H.size的位置
    }
    /*
    这时候返回的pos有两种情况，可能是哈希表中pos下标为空，那么我们
    在进行相应的操作的时候，需要判断当前的元素是否为空才可以进行，
    也有可能pos下标不为空，同时这个下标对应的元素值就是我们要找的关键字
    */
    return pos;
}
//插入元素
void insertElement(HashTable &H,int key){
    int pos;
    pos = findElement(H,key);//查找key在哈希表中的位置
    /*
    判断pos下标在哈希表中是否为空，如果为空，那么就说明没有找到
    这时候我们将key压入到pos下标，否则不用进行任何操作，从而避免了
    插入重复数字
    */
    if(H.arr[pos].state == Empty){
        H.arr[pos].val = key;
        H.arr[pos].state = Occupy;//插入元素之后，同时需要说明这个下标已经有值了
    }
}
/*
删除元素：利用懒惰删除，我们并没有真正的将这个元素从
哈希表中删除，然后删除元素后的数都要往前移，相反，我们只是
将当前删除元素对应的状态标记为Empty，这时候，下次插入元素的时候，就可以
在这个下标插入了，从而达到删除的效果
*/
void deleteElement(HashTable &H,int key){
    int pos;
    pos = findElement(H,key);
    if(H.arr[pos].state == Occupy){
        //判断是否能找到要删除的元素，如果是Occupy，说明找到了
        printf("删除的元素%d在哈希表中的下标为%d\n",key,pos);
        H.arr[pos].state = Empty;//删除之后，将这个下标对应的状态标记为Empty
    }
}
void display(HashTable &H){
    int i;
    for(i = 0; i < H.size; i++){
        if(H.arr[i].state == Empty){
            printf("%5d: NULL\n",i);
        }else{
            printf("%5d: %d\n",i,H.arr[i].val);
        }
    }
}
int main(){
    HashTable h;
  int n,i,key,pos;
  printf("请输入哈希表的大小:");
  scanf("%d",&n);
  init(h,n);//初始化哈希表
  printf("请输入元素的个数:");
  scanf("%d",&n);
  printf("请输入各个关键字:");
  for(i = 0; i < n; i++){
    scanf("%d",&key);
    insertElement(h,key);
  }
  while(1){
    printf("请输入选项: 1、插入 2、查找 3、删除 4、遍历哈希表 0、退出\n");
    scanf("%d",&n);
    switch(n){
      case 1:
        printf("请输入待插入数字:");
        scanf("%d",&key);
        insertElement(h,key);
        break;
      case 2:
        printf("请输入待查找数字:");
        scanf("%d",&key);
        pos = findElement(h,key);
        if(h.arr[pos].state == Occupy){
        /*
        获取key的关键字之后，我们需要判断这个下标在哈希表中是否为空，如果
        为空，说明没有办法在哈希表中找到key，否则找到了
        */
            printf("找到了，所处的哈希表下标为%d\n",pos);
        }else{
            printf("哈希表中无法找到%d\n",key);
        }
        break;
      case 3:
        printf("请输入待删除数字:");
        scanf("%d",&key);
        deleteElement(h,key);
        break;
      case 4:
        display(h);
        break;
      case 0:
        printf("退出系统");
        exit(0);
    }
  }
  return 0;
}

运行结果:
在这里插入图片描述

平方探测法

所谓的平方探测法，就是在上面的基本公式中，以F（i) = 1²,-1²,2²,-2²的形式后移。也就是说，如果发生冲突的话，他是在当前下标(即key % tableSize)的基础上加上F(i)。
对应的代码:

#include<stdio.h>
#include<stdlib.h>
#define Empty 0
#define Occupy 1
typedef struct HASHTABLE HashTable;
typedef struct ELEMENT Element;
struct ELEMENT{
   int val;//值
   int state;//表示这个元素是否为空，如果是0，表示空，否则不为空
};
struct HASHTABLE{
   Element *arr;//用一个整形数组来表示哈希表
   int size;//哈希表的大小
};
//初始化哈希表
void init(HashTable &H,int size){
   H.arr = (Element *)malloc(sizeof(Element) * size);
   if(H.arr == NULL){
     printf("哈希表数组分配空间失败!!!\n");
     exit(0);
   }
   int i;
   //初始化哈希表，表示是一个空表
   for(i = 0; i < size; i++){
      H.arr[i].state = Empty;
   }
   H.size = size;
}
//定义哈希函数
int hash(HashTable &H,int key){
    return key % H.size;
}
//查找哈希表中key对应的下标
int findElement(HashTable &H,int key){
    int pos,oldPos,d,count;
    count = 0;
    oldPos = hash(H,key);//找到关键字在哈希表中散列的地址
    pos = oldPos;
    while(H.arr[pos].state != Empty && H.arr[pos].val != key){
        //如果当前下标不为空，并且对应的值不是我们要找的关键字，那么就后移
        count++;//冲突次数
        if(count % 2 == 0){
            //冲突次数是偶数，我们需要减去F(i)的平方
            d = count / 2;
            pos = oldPos - d * d;
            while(pos < 0)
                pos += H.size;
       }else{
           //冲突次数是一个奇数，我们需要加上F(i)的平方
            d = (count + 1) / 2;
            pos = oldPos + d * d;
            while(pos >= H.size)
                pos -= H.size;
       }
    }
    /*
    这时候返回的pos有两种情况，可能是哈希表中pos下标为空，那么我们
    在进行相应的操作的时候，需要判断当前的元素是否为空才可以进行，
    也有可能pos下标不为空，同时这个下标对应的元素值就是我们要找的关键字
    */
    return pos;
}
//插入元素
void insertElement(HashTable &H,int key){
    int pos;
    pos = findElement(H,key);//查找key在哈希表中的位置
    /*
    判断pos下标在哈希表中是否为空，如果为空，那么就说明没有找到
    这时候我们将key压入到pos下标，否则不用进行任何操作，从而避免了
    插入重复数字
    */
    if(H.arr[pos].state == Empty){
        H.arr[pos].val = key;
        H.arr[pos].state = Occupy;//插入元素之后，同时需要说明这个下标已经有值了
    }
}
/*
删除元素：利用懒惰删除，我们并没有真正的将这个元素从
哈希表中删除，然后删除元素后的数都要往前移，相反，我们只是
将当前删除元素对应的状态标记为Empty，这时候，下次插入元素的时候，就可以
在这个下标插入了，从而达到删除的效果
*/
void deleteElement(HashTable &H,int key){
    int pos;
    pos = findElement(H,key);
    if(H.arr[pos].state == Occupy){
        //判断是否能找到要删除的元素，如果是Occupy，说明找到了
        printf("删除的元素%d在哈希表中的下标为%d\n",key,pos);
        H.arr[pos].state = Empty;//删除之后，将这个下标对应的状态标记为Empty
    }
}
void display(HashTable &H){
    int i;
    for(i = 0; i < H.size; i++){
        if(H.arr[i].state == Empty){
            printf("%5d: NULL\n",i);
        }else{
            printf("%5d: %d\n",i,H.arr[i].val);
        }
    }
}
int main(){
    HashTable h;
  int n,i,key,pos;
  printf("请输入哈希表的大小:");
  scanf("%d",&n);
  init(h,n);
  printf("请输入元素的个数:");
  scanf("%d",&n);
  printf("请输入各个关键字:");
  for(i = 0; i < n; i++){
    scanf("%d",&key);
    insertElement(h,key);
  }
  while(1){
    printf("请输入选项: 1、插入 2、查找 3、删除 4、遍历哈希表 0、退出\n");
    scanf("%d",&n);
    switch(n){
      case 1:
        printf("请输入待插入数字:");
        scanf("%d",&key);
        insertElement(h,key);
        break;
      case 2:
        printf("请输入待查找数字:");
        scanf("%d",&key);
        pos = findElement(h,key);
        if(h.arr[pos].state == Occupy){
            printf("找到了，所处的哈希表下标为%d\n",pos);
        }else{
            printf("哈希表中无法找到%d\n",key);
        }
        break;
      case 3:
        printf("请输入待删除数字:");
        scanf("%d",&key);
        deleteElement(h,key);
        break;
      case 4:
        display(h);
        break;
      case 0:
        printf("退出系统");
        exit(0);
    }
  }
  return 0;
}

运行结果:
在这里插入图片描述

双散列

所谓的双散列，就是F(i) = i * hash2(key),并且hash2(key) = p - (key % p)，其中p是一个素数.
对应的代码:


#include<stdio.h>
#include<stdlib.h>
#define Empty 0
#define Occupy 1
typedef struct HASHTABLE HashTable;
typedef struct ELEMENT Element;
struct ELEMENT{
   int val;//值
   int state;//表示这个元素是否为空，如果是0，表示空，否则不为空
};
struct HASHTABLE{
   Element *arr;//用一个整形数组来表示哈希表
   int size;//哈希表的大小
};
//初始化哈希表
void init(HashTable &H,int size){
   H.arr = (Element *)malloc(sizeof(Element) * size);
   if(H.arr == NULL){
     printf("哈希表数组分配空间失败!!!\n");
     exit(0);
   }
   int i;
   //初始化哈希表，表示是一个空表
   for(i = 0; i < size; i++){
      H.arr[i].state = Empty;
   }
   H.size = size;
}
//定义哈希函数
int hash(HashTable &H,int key){
    return key % H.size;
}
int hash2(int key,int p){
    return p - (key % p);
}
//查找哈希表中key对应的下标
int findElement(HashTable &H,int key){
    int pos,oldPos,d,count;
    count = 0;//count表示冲突次数
    oldPos = hash(H,key);//找到关键字在哈希表中散列的地址
    d = hash2(key,7);//这里将p的值为7
    pos = oldPos;
    while(H.arr[pos].state != Empty && H.arr[pos].val != key){
        //如果当前元素不为空，并且不是要找的关键字，那么继续散列
        count++;
        //双散列
        pos = oldPos + count * d;
        while(pos >= H.size)
            pos -= H.size;
    }
    /*
    这时候返回的pos有两种情况，可能是哈希表中pos下标为空，那么我们
    在进行相应的操作的时候，需要判断当前的元素是否为空才可以进行，
    也有可能pos下标不为空，同时这个下标对应的元素值就是我们要找的关键字
    */
    return pos;
}
//插入元素
void insertElement(HashTable &H,int key){
    int pos;
    pos = findElement(H,key);//查找key在哈希表中的位置
    /*
    判断pos下标在哈希表中是否为空，如果为空，那么就说明没有找到
    这时候我们将key压入到pos下标，否则不用进行任何操作，从而避免了
    插入重复数字
    */
    if(H.arr[pos].state == Empty){
        H.arr[pos].val = key;
        H.arr[pos].state = Occupy;//插入元素之后，同时需要说明这个下标已经有值了
    }
}
/*
删除元素：利用懒惰删除，我们并没有真正的将这个元素从
哈希表中删除，然后删除元素后的数都要往前移，相反，我们只是
将当前删除元素对应的状态标记为Empty，这时候，下次插入元素的时候，就可以
在这个下标插入了，从而达到删除的效果
*/
void deleteElement(HashTable &H,int key){
    int pos;
    pos = findElement(H,key);
    if(H.arr[pos].state == Occupy){
        //判断是否能找到要删除的元素，如果是Occupy，说明找到了
        printf("删除的元素%d在哈希表中的下标为%d\n",key,pos);
        H.arr[pos].state = Empty;//删除之后，将这个下标对应的状态标记为Empty
    }
}
void display(HashTable &H){
    int i;
    for(i = 0; i < H.size; i++){
        if(H.arr[i].state == Empty){
            printf("%5d: NULL\n",i);
        }else{
            printf("%5d: %d\n",i,H.arr[i].val);
        }
    }
}
int main(){
    HashTable h;
  int n,i,key,pos;
  printf("请输入哈希表的大小:");
  scanf("%d",&n);
  init(h,n);
  printf("请输入元素的个数:");
  scanf("%d",&n);
  printf("请输入各个关键字:");
  for(i = 0; i < n; i++){
    scanf("%d",&key);
    insertElement(h,key);
  }
  while(1){
    printf("请输入选项: 1、插入 2、查找 3、删除 4、遍历哈希表 0、退出\n");
    scanf("%d",&n);
    switch(n){
      case 1:
        printf("请输入待插入数字:");
        scanf("%d",&key);
        insertElement(h,key);
        break;
      case 2:
        printf("请输入待查找数字:");
        scanf("%d",&key);
        pos = findElement(h,key);
        if(h.arr[pos].state == Occupy){
            printf("找到了，所处的哈希表下标为%d\n",pos);
        }else{
            printf("哈希表中无法找到%d\n",key);
        }
        break;
      case 3:
        printf("请输入待删除数字:");
        scanf("%d",&key);
        deleteElement(h,key);
        break;
      case 4:
        display(h);
        break;
      case 0:
        printf("退出系统");
        exit(0);
    }
  }
  return 0;
}

运行结果:
在这里插入图片描述

再散列

对于使用平方探测的开放地址散列法，如果表填的太满，那么操作的运行时间将会消耗过程，并且insert操作可能会失败，因为有可能没有办法找到合适的位置插入，从而发生太多的移动（即可能陷入死循环中，从而造成超时）。这时候，我们就需要重新散列，即建立另一个大约2倍大小的表，扫描原始的散列表，计算原始散列表中每一个没有删除的元素在新表中的地址，然后将其插入新表中,之所以需要重新计算原始散列表中每一个没有删除元素在新表中的地址，是因为由于表的大小发生了变化，从而导致新旧两表中的元素地址不同。

奋斗的龙猫
关注
  • 22
    点赞
  • 踩
  • 110
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
深入浅出数据结构C语言版（14）——散列表
词语大杂烩
09-04 395
我们知道，由于二叉树的特性（完美情况下每次比较可以排除一半数据），对其进行查找算是比较快的了，时间复杂度为O(logN)。但是，是否存在支持时间复杂度为常数级别的查找的数据结构呢？答案是存在，那就是散列表（hash table，又叫哈希表）。散列表可以支持O(1)的插入，理想情况下可以支持O(1)的查找与删除。   　　散列表的基本思想很简单： 　　1.设计一个散列函数，其输入为
哈希表（散列表）c语言
wxlwxllxw的博客
03-27 4224
冲突：对不同的关键字可能得到同一哈希地址，即key1≠key2面f（key1）=f（key2）这种现象称冲突（collision）。具有相同函数值的关键词对该哈希函数来说称作同义词（synonym）。 一 哈希函数 （1）除留余数法(K%P P一般情况下取小于表长的最大素数 表长是100则p取97 若表长是25则p取23) （2）数字分析法 （3）平方取中法 （4）直接定址法 二 解决冲突的方法 ...
【数据结构】散列表（哈希表）的学习知识总结
小人物，大梦想！
09-26 707
散列函数的构造：除留余数法；直接定址法；数字分析法；平方取中法 处理冲突的方法：拉链法（链接法）；开放定址法 C语言实现散列表
C语言实现散列表（哈希Hash表)实例详解
01-01
C语言实现散列表（哈希Hash表) 实例代码： //散列表查找算法（Hash） #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define SUCCESS 1 #define UNSUCCESS 0 #define HASHSIZE 7 #define NULLKEY -32768 typedef int Status; typedef struct { int *elem; //基址 int count;
哈希表的c语言实现1
03-01
哈希表的哈希取余法和链表地址法来实现哈希表的基本操作。。。
C语言基于哈希表实现通讯录
08-27
按照以上思路建立的表称为哈希表或散列表。 在本案例中，我们主要考察散列表的建立、查找和修改。 三、详细设计 在详细设计中，我们首先定义了一个结构体node，用于存储电话号码、姓名、地址、城市、其他信息等。...
C语言设计哈希表实现图书查找
10-26
C语言设计哈希表实现图书查找系统，完成相应的建表和查表程序。从键盘输入各图书相关信息，分别以图书编号为关键字建立散列表。待填入哈希表的书号至少30个；构造合适的哈希函数。 1） 记录由外部输入。 2） 将生成...
c语言面试题之哈希表赎金信.zip
最新发布
03-29
哈希表，又称散列表，是计算机科学中一种非常重要的数据结构，它通过关联键（key）和值（value）来实现快速的数据存取。在C语言面试中，哈希表赎金信的问题通常考察面试者对哈希表的理解、算法设计及优化能力。以下...
hash表C语言实现
07-26
这是百度一位大牛写的hash结构
C语言实现哈希函数
Hxy_666的博客
08-17 2444
在除留取余基础上使用线性探测或者二次探测解决冲突的哈希函数（包括计算ASL）C语言实现
线性探测法和拉链法处理散列表冲突
05-29
对于给定的一组整数和散列函数，分别采用线性探测法和拉链法处理冲突构造散列表，并在这两种方法构建的散列表中查找整数K，比较两种方法的时间和空间性能。
散列表实现
07-04
数据结构课程中的散列表的编程实现，c语言
C语言库函数的哈希表使用方法
qq_43599515的博客
04-14 4665
C语言库函数的哈希表使用方法
散列算法c语言_C的散列库
cuma2369的博客
07-28 496
散列算法c语言I try to find some Hashing libraries for C and find several good ones. 我尝试找到一些用于C的哈希库，并找到几个好的库。 The hsearch function in the GNU C library. GNU C库中的hsearch函数 。 There are other methods to organ...
散列表的C语言实现-开放定址法
浮生Spider
08-09 1941
头文件： #ifndef __HASHTABLE_H #define __HASHTABLE_H /*********************（平方）开放定址散列法***************/ //如果有冲突发生，那么就尝试另外的单元，直到找到空的单元为止 typedef unsigned int index; typedef index position; typedef int E
数据结构：散列表
ruanhao1203的专栏
08-02 174
概念 散列是一种用于以常数平均时间执行插入、删除和查找的技术。 理想的散列表数据结构是一个包含一些项的具有固定大小的数组。 散列函数 key值通过散列函数计算出位置，插入或者查询散列表。 如果计算出的位置相同，那么就产生一个冲突，解决这种冲突的方法有几种，其中最简单的两种是：分离链接法和开放定位法。 分离链接法 其做法是将散列到同一个值的所有元素保存到一个表（双向链表）中。 ...
散列表的基本概念及其运算
热门推荐
tanglinux
03-26 2万+
参考文献： 《数据结构（C语言版）》  严蔚敏 吴伟民 编著      开发平台：Ubuntu11.04     编译器：gcc version4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu4)       散列表（也叫哈希表）是一种查找算法，与链表、树等算法不同的是，散列表算法在查找时不需要进行一系列和关键字（关键字是数据元素中某个数据项的值，用以标识一个数据元素）
数据结构之散列表
hty46565的博客
11-07 380
概述 散列表的英文名叫“Hash Table”，所以，我们也叫它为哈希表。 散列表利用数组支持下标随机访问数据的特性，是数组的一种扩展，由数组演化而来。 散列函数 我们需要把键值key映射为数组的下标。所以需要一个映射的函数，这个映射的函数就是散列函数。 散列函数有三个基本要求： 散列函数计算得到的散列值是一个非负整数 如果key1=key2key1=key2key1=key2，那么hash(k...
散列表解释
Vincent
02-12 1052
散列表（也叫哈希表）是一种查找算法，与链表、树等算法不同的是，散列表算法在查找时不需要进行一系列和关键字（关键字是数据元素中某个数据项的值，用以标识一个数据元素）的比较操作。 散列表算法希望能尽量做到不经过任何比较，通过一次存取就能得到所查找的数据元素，因而必须要在数据元素的存储位置和它的关键字（可用key表示）之间建立一个确定的对应关系，使每个关键字和散列表中一个唯一的存储位置相对应。因
c语言哈希表就基本操作
05-16
哈希表（Hash Table）是一种又称为散列表的数据结构，它的主要目的是用于快速查找，它能够通过关键字快速确定唯一的数据位置，从而实现常数时间复杂度的查找。在C语言中，哈希表也拥有基本操作，下面是我对这些操作的简介： 1. 初始化哈希表：初始化哈希表需要确定哈希表的大小（通常是质数），并申请一块连续的内存空间用来存储哈希表的数据。同时，需要设置哈希表的散列函数。 2. 插入数据：首先，需要通过散列函数计算出数据所应该存储的位置，然后将数据存入哈希表中。如果该位置已经被占用，则需要进行解决冲突的处理，通常使用的是开放地址法或链地址法。 3. 查找数据：同样需要通过散列函数计算出数据所存储的位置，然后在哈希表中查找是否存在该数据。如果该位置为空，表示数据不存在；如果不为空，需要比较关键字是否与要查找的一致。 4. 删除数据：与插入数据类似，需要先计算出数据所存储的位置，然后将该位置设置为空。如果该位置处存在多个数据，同时需要将后续的数据重新散列。 总的来说，哈希表是C语言中比较常见的数据结构之一，它有着高效的查找操作，同时适用于大多数的数据类型。在实际开发中，我们可以通过调用现有库或手写代码，来完成相关的哈希表操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值