HASH表解决冲突———双链表循环使用

最新推荐文章于 2022-07-26 14:06:15 发布
最新推荐文章于 2022-07-26 14:06:15 发布
阅读量804 收藏
点赞数
分类专栏： 数据结构练习-VC 文章标签： null list struct ext
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/judyloveld/article/details/3341366
版权
  1. // DEBUG2.cpp : Defines the entry point for the console application.
  2. //
  3. // data.cpp : 定义控制台应用程序的入口点。
  4. //
  5. #include "stdafx.h"
  6. #include "stdio.h"
  7. #include "stdlib.h"
  8. #define HASHSIZE 6999999
  9. #define DATASIZE 20
  10. #define I_USED 1
  11. #define I_UNUSED 0
  12. typedef unsigned int __u32;
  13. typedef unsigned short __u16;
  14. typedef unsigned char __u8;
  15. int DATACOUNT=DATASIZE;
  16. int HASHCOUNT=0;
  17. struct _data
  18. {
  19. __u32 saddr; 
  20. __u32 ext_isn;
  21. __u32 int_isn;
  22. __u16 sport; 
  23. __u8 int_ok;
  24. __u8 three_shake;
  25. __u8 fin_count;
  26. char flag;
  27. __u32 head;
  28. struct _data *next;
  29. struct _data *prev;
  30. struct _data *cl_next;
  31. struct _data *cl_prev;
  32. }data_list[DATASIZE],*data_hash[HASHSIZE];
  33. struct _data *data_head;
  34. struct _data *data_tail;
  35. //cut cl_prev and cl_next form data_hash
  36. void  del_coll(struct _data *pcb_p,__u32 index){
  37.  if(data_hash[index]!=NULL){
  38.   if(pcb_p->cl_prev==NULL && pcb_p->cl_next==NULL){
  39.    data_hash[index]=NULL;
  40.   }else if(pcb_p->cl_prev==NULL && pcb_p->cl_next!=NULL){
  41.    (pcb_p->cl_next)->cl_prev=NULL;
  42.    data_hash[index]=pcb_p->cl_next;
  43.    pcb_p->cl_next=NULL;
  44.   }else if(pcb_p->cl_prev!=NULL && pcb_p->cl_next!=NULL){
  45.    
  46.    (pcb_p->cl_next)->cl_prev=pcb_p->cl_prev;
  47.    (pcb_p->cl_prev)->cl_next=pcb_p->cl_next;
  48.    pcb_p->cl_next=NULL;
  49.    pcb_p->cl_prev=NULL;
  50.   }else if(pcb_p->cl_prev!=NULL && pcb_p->cl_next==NULL){
  51.    
  52.    (pcb_p->cl_prev)->cl_next=NULL;
  53.    pcb_p->cl_prev=NULL;
  54.   }
  55.  }
  56. }
  57. int  alloc_data_inode(__u16 sport, __u32 saddr ,__u32  ext_isn,__u32 index)
  58. {
  59.  struct _data *pcb_p;
  61.  /*CUT DATA_TAIL OF DATA_LINK*/
  62.    if(data_tail->flag&I_USED){
  63.     
  64.     del_coll(data_tail,index);
  65.    }
  66.    pcb_p=data_tail;
  67.    (data_tail->prev)->next=NULL;
  68.    data_tail=data_tail->prev;
  69.    pcb_p->prev=NULL;
  70.    pcb_p->next=data_head;
  71.    data_head->prev=pcb_p;
  72.    data_head=pcb_p;
  73.    pcb_p->prev=NULL;
  74.   
  75.  /*add to the hashtable's collision link table*/
  76.    if( data_hash[index] != NULL )  
  77.     {
  78.      data_hash[index]->cl_prev=pcb_p;
  79.      pcb_p->cl_next = data_hash[index];
  80.      pcb_p->cl_prev=NULL;
  81.      data_hash[index]=pcb_p;
  82.      HASHCOUNT++;
  83.     }
  84.     else if(data_hash[index]==NULL)
  85.      {
  86.      data_hash[index]=pcb_p;
  87.      pcb_p->cl_next=NULL;
  88.      pcb_p->cl_prev=NULL;
  89.      HASHCOUNT++;
  90.     }
  91.    /*init the data into the pcb_p;*/
  92.     pcb_p->saddr=saddr;
  93.     pcb_p->sport=sport;
  94.     pcb_p->ext_isn=ext_isn;
  95.     pcb_p->three_shake=1;
  96.     pcb_p->head=index;
  97.     pcb_p->flag=I_USED;
  98.     
  99.      return 0;
  101.   
  102. }
  104. int detach_pcb(struct _data *pcb_p,__u32 index,__u32 saddr,__u16  sport) 
  105. {
  106.  while(data_hash[index]!=NULL){
  107.   if( pcb_p->saddr==saddr && pcb_p->sport==sport )
  108.   { 
  109.    
  110.    printf("%p:prev=%p,next=%p,cl_prev=%p,cl_next=%p[saddr=%d,sport=%d]/n",pcb_p,pcb_p->prev,pcb_p->next,pcb_p->cl_prev,pcb_p->cl_next,pcb_p->saddr,pcb_p->sport); 
  111.    
  112.    del_coll(pcb_p,index);
  113.    if(pcb_p->next!=NULL && pcb_p->prev==NULL){
  114.     (pcb_p->next)->prev=NULL;
  115.     data_head=pcb_p->next;
  116.     pcb_p->next=NULL;
  117.     pcb_p->prev=data_tail;
  118.     data_tail->next=pcb_p;
  119.     data_tail=pcb_p;
  120.     pcb_p->next=NULL;
  121.    }else if(pcb_p->next!=NULL && pcb_p->prev!=NULL){
  122.     (pcb_p->next)->prev=pcb_p->prev;
  123.     (pcb_p->prev)->next=pcb_p->next;
  124.     pcb_p->next=pcb_p->prev=NULL;
  125.     pcb_p->prev=data_tail;
  126.     data_tail->next=pcb_p;
  127.     data_tail=pcb_p;
  128.     pcb_p->next=NULL;
  129.    }
  131.      pcb_p->saddr=0;
  132.      pcb_p->sport=0;
  133.      pcb_p->three_shake=0;
  134.      pcb_p->ext_isn=0;
  135.      pcb_p->fin_count=0;
  136.      pcb_p->int_isn=0;
  137.      pcb_p->int_ok=0;
  138.      pcb_p->flag=I_UNUSED;
  139.      pcb_p->head=0; 
  140.      return 0; //detach sucessful!
  141.   }
  142.   else{
  143.    if(pcb_p->cl_next!=NULL)
  144.     pcb_p=pcb_p->cl_next;
  145.    else{ 
  146.     return -1;
  147.    } 
  148.   }
  149.  }
  150.  if(data_hash[index]==NULL){
  151.   printf("out of delete size!/n");
  152.   return -1;
  153.  }
  154.    
  155.  return -1;
  156. }
  157. struct _data * lookup_pcb(__u32 saddr,__u16  sport,__u32 index)
  158. {
  159.  struct _data *pcb_p;
  160.  if( data_hash[index] != NULL )
  161.  {
  162.   pcb_p = data_hash[index];
  163.   while( pcb_p != NULL )
  164.   {
  165.    if( pcb_p->saddr==saddr && pcb_p->sport==sport )
  166.    {
  167.     
  168.     return pcb_p;
  169.    }
  170.    else
  171.    {
  172.     pcb_p = pcb_p->cl_next;
  173.    }
  174.   }
  175.  }
  176.  return NULL;
  177. }
  179. void init_data(int i)
  180. {
  181.  data_head=&data_list[0];
  182.  data_tail=&data_list[DATASIZE-1];
  183.  for(i=0;i<DATASIZE;i++)
  184.  {
  185.   if(i == 0)
  186.   {
  187.    data_list[i].prev = NULL;
  188.    data_list[i].next = &data_list[1];
  189.   }
  190.   else if(i == (DATASIZE-1))
  191.   {
  192.    data_list[i].next= NULL;
  193.    data_list[i].prev=&data_list[i-1];
  194.   }
  195.   else
  196.   {
  197.    data_list[i].next= &data_list[i+1];
  198.    data_list[i].prev=&data_list[i-1];
  199.   }
  200.   data_list[i].cl_next=NULL;
  201.   data_list[i].cl_prev=NULL;
  202.   data_list[i].int_ok=0;
  203.   data_list[i].three_shake=0;
  204.   data_list[i].sport=0;
  205.   data_list[i].saddr=0;
  206.   data_list[i].ext_isn=0;
  207.   data_list[i].int_isn=0;
  208.   data_list[i].fin_count=0;
  209.   data_list[i].head=0;
  210.   data_list[i].flag=I_UNUSED;
  211.    }
  212.  for(i=0;i<HASHSIZE;i++)
  213.   data_hash[i]=NULL;
  214. }
  216. int main(int argc, char* argv[])
  217. {
  218.  int i;
  219.  int j=0;
  220.  int x=0;
  221.  struct _data *pPtr;
  222.  __u32 saddr;
  223.  __u16 sport; 
  224.  init_data(1);
  225.  printf("data_init sucessful/n");
  226.  //ALLOC
  227.  for(i=0;i<99999;i++)
  228.  {
  229.   alloc_data_inode(123+i,987654+i,98765432+i,123456);
  230.   printf("i=%d/n",i);
  231.  }
  232.  pPtr=data_hash[123456];
  233.  //分配
  234.  while(pPtr!=NULL)
  235.  { printf("<<%d>>",x);
  236.   printf("%p:prev=%p,next=%p,cl_prev=%p,cl_next=%p[saddr=%d,sport=%d]/n",pPtr,pPtr->prev,pPtr->next,pPtr->cl_prev,pPtr->cl_next,pPtr->saddr,pPtr->sport);
  237.   pPtr=pPtr->cl_next;
  238.   x++;
  239.  }
  240.  printf("------------------------------------------------/n");
  241.  pPtr=data_head;
  242.  //dell
  243.  for(i=0;i<7;i++)
  244.  {
  245.   saddr=1087635+i;
  246.   sport=34568+i;
  247.   detach_pcb(pPtr,123456,saddr,sport);
  248.  }
  249.  for(i=0;i<DATASIZE;i++)
  250.  {
  251.  pPtr=lookup_pcb(1087633+i,34566+i,123456);
  252.  if(pPtr!=NULL)
  253.  {
  254.   j++;
  255.   printf("i=%d found it/n",i);
  256.  }
  257.  if(pPtr==NULL)
  258.   printf("i=%d not found/n",i);
  259.  }
  260.  pPtr=data_head;
  261.  while(pPtr!=NULL)
  262.  {
  263.   printf("%p:prev=%p,next=%p,cl_prev=%p,cl_next=%p[saddr=%d,sport=%d]/n",pPtr,pPtr->prev,pPtr->next,pPtr->cl_prev,pPtr->cl_next,pPtr->saddr,pPtr->sport);
  264.   pPtr=pPtr->cl_next;
  265.  }
  266.  printf("found %d inode/n",j);
  267.   scanf("%d",&i);
  268.  return 0;
  269. }
JUDYLOVELD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向循环链表实现hash表操作
u010807313的专栏
05-27 1157
本题为我们公司前一段时间技术评级的考题，先让实现一个双向循环链表的一些操作，然后实现一个hash表，其hash结点为双向循环链表结点。hash函数为最简单的除数留余法 处理冲突的方式为链地址法。 /** 采用双向循环链表实现HASH表 */ #include #include #include #include #define RS_OK 0 #define RS_WRONG
HASH表中解决冲突的方法（链址法）————双链表
朱朱的足迹
11-20 1112
// DEBUG2.cpp : Defines the entry point for the console application. // // data.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "stdio.h" #include "stdlib.h" #define HASHSIZE 69
HASH表解决冲突———双链表循环使用…
JudyZLF的博客
10-11 514
// DEBUG2.cpp : Defines the entry point for the console application. // // data.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "stdio.h" #include "stdlib.h" #define HASHSIZE 6999999 #define DATA
基于双向循环链表构建的hash表
dp__mcu的专栏
12-09 147
/* * vim: ai ts=4 sts=4 sw=4 cinoptions=>4 expandtab */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <sys/mman.h> #include <sys/types.h> #include <sy..
list_code.rar_hash unix_单向链表
09-22
`list_code.rar_hash unix_单向链表`这个标题暗示了我们有一个压缩包，包含了相关代码示例，适用于Unix系统，包含单向链表和哈希表的操作。 首先，让我们深入理解单向链表。单向链表是一种线性数据结构，每个元素...
如何解决hash冲突
09-02
哈希冲突是哈希表操作中常见的问题，由于哈希函数的非完美性质，不同的关键字可能会...例如，在分析GIF文件结构时，理解哈希表和解决冲突的方法可以帮助我们更好地设计和实现解析算法，提高读取和操作GIF文件的效率。
oracle分区表之hash分区表的使用及扩展
09-10
Oracle分区表中的Hash分区是一种基于哈希算法的分区策略，适用于处理无法清晰定义分区范围的大型数据表。这种分区方式通过计算分区键的哈希值来决定数据存储在哪个分区，以此达到数据分散和负载均衡的目的。Hash分区...
浅谈哈希表及哈希冲突.ppt
最新发布
09-20
哈希表是一种数据结构，它通过使用哈希函数将键（Key）映射到一个固定大小的数组（也称为哈希表或散列表）中的特定位置，以此实现快速的查找、插入和删除操作。哈希表的核心在于哈希函数，它能将任意大小的键转化...
hash链表
IT_Linux
03-23 2076
hash链表概述 hash链表是hash表和链表的结合，使用比较方便。 hash链表实现 本文的hash链表实现：hash头部用单链表、其他的hash节点用双向链表。实现主要取自Linux内核实现，本文做了移植。本文代码可从http://download.csdn.net/detail/it_pcode/6632905下载。 hash实现 #ifndef HLIST_H_ #define
哈希表的地址链表法
flying0033的专栏
12-12 5284
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。   下面的哈希表函数使用了(除留余数)   头文件:HashTable.h #ifndef HASHTABLE_H #define HASHTABLE_H
哈希表(解决循环冲突链表问题)
flameboy的博客
05-06 2193
哈希表 哈希表是基于数组的顺序结构，每一个存储目标都会存在一个key值，哈希表也称为散列表。为解决冲突问题（多个目标用hash函数计算出相同的位置），本代码用了拉链法，另外本代码还解决了字符串插入哈希表循环冲突拉链的问题。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #de...
总结哈希链表储存冲突
u013519020的专栏
06-05 539
这个题寒假的时候做过，当时用的线性探测
一步一步写算法（之hash表）
jusll的专栏
05-27 310
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     hash表，有时候也被称为散列表。个人认为，hash表是介于链表和二叉树之间的一种中间结构。链表使用十分方便，但是数据查找十分麻烦；二叉树中的数据严格有序，但是这是以多一个指针作为代价的结果。hash表既满足了数据的查找方便，同时不占用太多的内容空间，使用也十分方便。
哈希表/哈希冲突及解决方法（较全）
不算太晚
08-06 8154
前导（题外话）： 关于哈希函数的选取，可以参见这篇文章，另外常见的字符串哈希函数及c++代码实现可以看这里 主要有：常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。 常用字符串哈希函数有BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等。 BKDRHash无论是在实
算法精解----9、链式哈希表
张勇1234的博客
08-08 3202
1、哈希表 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)
哈希表及哈希冲突避免
weixin_45975659的博客
07-20 2646
一、哈希表概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过 程中元素的比较次数。 如果构造一种存储结构，通过某种函 数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快 找到该元素。 当向该结构插入、搜索元素，此方法即为哈希（散列）方法。 哈希方法中使用的转换函数称为哈希 (散列) 函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表) 。
解决哈希冲突的办法
JohnJim的博客
10-23 1281
哈希冲突(Hash Collision)指的是对应不同的输入值产生了相同的哈希值从而引起的冲突。常用解决哈希冲突的方法有以下几种。 开放定址法(Open Addressing) 也叫再散列(Rehashing)方法，其基本思想是：当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中。这种方法有一个通用的再散列函数形式： pi=(H(key)+f(i))(mod
解决哈希冲突的几种方式
机械工程跑路哥
07-26 3425
哈希函数是一个映像，把任意长度的输入，通过Hash算法变换成固定长度的输出，这个输出就是Hash值；当两个不同的输入，产生了同一个输出值即为哈希冲突。
java hashmap 使用链表解决hash冲突？
07-13
是的，Java中的HashMap使用链表解决哈希冲突。当两个不同的键映射到相同的哈希桶时，它们将被放置在同一个桶中，形成一个链表。这种链表被称为"链表法"或"开链法"。当发生哈希冲突时，新的键值对将会被追加到链表的末尾。 然而，从Java 8开始，HashMap在链表长度达到一定阈值（默认为8）之后，将使用红黑树来替代链表。这是为了提高在较长链表中查找元素的效率，因为红黑树的查找时间复杂度为O(log n)，而链表的查找时间复杂度为O(n)。这个优化称为"树化"操作。 通过使用链表和红黑树来解决哈希冲突，HashMap可以在大多数情况下实现常数时间的插入和检索操作。然而，在极端情况下，如果所有的键都映射到相同的哈希桶上，HashMap的性能可能会退化为O(n)。因此，在设计哈希函数时，应尽量避免产生过多的哈希冲突。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值