HASH表中解决冲突的方法（链址法）————双链表

最新推荐文章于 2022-05-23 22:15:00 发布
最新推荐文章于 2022-05-23 22:15:00 发布
阅读量205 收藏
点赞数
分类专栏： CBAP学习笔记 文章标签： EXT J#
  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 2000
  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. }data_list[DATASIZE],*data_hash[HASHSIZE];
  31. struct _data *data_head;
  32. struct _data *data_tail;
  33. int  alloc_data_inode(__u16 sport, __u32 saddr ,__u32  ext_isn,__u32 index)
  34. {
  35.  struct _data *pcb_p;
  36.  if(DATACOUNT>1){
  37.  /*CUT DATA_TAIL OF DATA_LINK*/
  38.  if(data_tail!=NULL){
  39.   pcb_p=data_tail;
  40.   (pcb_p->prev)->next=NULL;
  41.   data_tail=pcb_p->prev;
  42.   pcb_p->prev=NULL;
  43.   DATACOUNT--;
  44.  }
  45.  else if(data_tail==data_head){
  46.   pcb_p=data_tail=data_head;
  47.  }
  48.  else{
  49.   printf("inodes have been used!!");
  50.  }
  51.   
  52.  /*add to the hashtable's collision link table*/
  53.    if( data_hash[index] != NULL )  
  54.     {
  55.      data_hash[index]->prev=pcb_p;
  56.      pcb_p->next = data_hash[index];
  57.      pcb_p->prev=NULL;
  58.      data_hash[index]=pcb_p;
  59.      HASHCOUNT++;
  60.     }
  61.     else if(data_hash[index]==NULL)
  62.      {
  63.      data_hash[index]=pcb_p;
  64.      pcb_p->next=NULL;
  65.      pcb_p->prev=NULL;
  66.      HASHCOUNT++;
  67.     }
  68.    /*init the data into the pcb_p;*/
  69.     pcb_p->saddr=saddr;
  70.     pcb_p->sport=sport;
  71.     pcb_p->ext_isn=ext_isn;
  72.     pcb_p->three_shake=1;
  73.     pcb_p->head=index;
  74.     pcb_p->flag=I_USED;
  75.      return 0;
  77.  }else{
  78.   printf("inodes have been used!!");
  79.   
  80.  }
  82. }
  84. int detach_pcb(struct _data *pcb_p,__u32 index,__u16 sport,__u32 saddr)
  85. {
  86. // char j;
  87.  while( data_hash[index] != NULL )
  88.  {
  89.    
  90.   if( pcb_p->saddr==saddr && pcb_p->sport==sport )
  91.   {
  92.    //delete it from data_link and add to the data_tail
  93.    //MIDDLE
  94.    if(pcb_p->next !=NULL&&pcb_p->prev !=NULL )
  95.     {
  96.      
  97.      (pcb_p->prev)->next=pcb_p->next;
  98.      (pcb_p->next)->prev=pcb_p->prev;
  99.      data_head->prev=pcb_p;
  100.      pcb_p->prev=NULL;
  101.      pcb_p->next=data_head;
  102.      data_head=pcb_p;
  103.         
  104.    }//TAIL
  105.    else if(pcb_p->next==NULL&&pcb_p->prev!=NULL)
  106.     { 
  107.      (pcb_p->prev)->next=NULL;
  108.      pcb_p->prev=NULL;
  109.      data_head->prev=pcb_p;
  110.      pcb_p->prev=NULL;
  111.      pcb_p->next=data_head;
  112.      data_head=pcb_p;
  113.    }//HEAD
  114.       else if(pcb_p->next!=NULL&&pcb_p->prev==NULL)
  115.     { 
  116.      data_hash[index]=data_hash[index]->next;
  117.      (pcb_p->next)->prev=NULL;
  118.      pcb_p->next=NULL;
  119.      data_head->prev=pcb_p;
  120.      pcb_p->prev=NULL;
  121.      pcb_p->next=data_head;
  122.      data_head=pcb_p;
  123.    }
  124.   /* else if(pcb_p->next==NULL && pcb_p->prev){ 
  125.     data_hash[index]=NULL;
  126.     data_head->prev=pcb_p;
  127.     pcb_p->prev=NULL;
  128.     pcb_p->next=data_head;
  129.     data_head=pcb_p;
  130.    }*/
  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!
  142.   }else{
  143.    if(pcb_p->next!=NULL){
  144.     pcb_p=pcb_p->next;
  145.    }else{
  146.     printf("NO INODE!!!");
  147.     break;
  148.    }
  149.   }
  150.   
  151.  }
  152.  return -1;
  154. }
  155. struct _data * lookup_pcb(__u32 saddr,__u16  sport,__u32 index)
  156. {
  157.  struct _data *pcb_p;
  158.  if( data_hash[index] != NULL )
  159.  {
  160.   pcb_p = data_hash[index];
  161.   while( pcb_p != NULL )
  162.   {
  163.    if( pcb_p->saddr==saddr && pcb_p->sport==sport )
  164.    {
  165.     
  166.     return pcb_p;
  167.    }
  168.    else
  169.    {
  170.     pcb_p = pcb_p->next;
  171.    }
  172.   }
  173.  }
  174.  return NULL;
  175. }
  177. void init_data(int i)
  178. {
  179.  data_head=&data_list[0];
  180.  data_tail=&data_list[DATASIZE-1];
  181.  for(i=0;i<DATASIZE;i++)
  182.  {
  183.   if(i == 0)
  184.   {
  185.    data_list[i].prev = NULL;
  186.    data_list[i].next = &data_list[1];
  187.   }
  188.   else if(i == (DATASIZE-1))
  189.   {
  190.    data_list[i].next= NULL;
  191.    data_list[i].prev=&data_list[i-1];
  192.   }
  193.   else
  194.   {
  195.    data_list[i].next= &data_list[i+1];
  196.    data_list[i].prev=&data_list[i-1];
  197.   }
  198.   
  199.   data_list[i].int_ok=0;
  200.   data_list[i].three_shake=0;
  201.   data_list[i].sport=0;
  202.   data_list[i].saddr=0;
  203.   data_list[i].ext_isn=0;
  204.   data_list[i].int_isn=0;
  205.   data_list[i].fin_count=0;
  206.   data_list[i].head=0;
  207.   data_list[i].flag=I_UNUSED;
  208.    }
  209.  for(i=0;i<HASHSIZE;i++)
  210.   data_hash[i]=NULL;
  211. }
  212. int main(int argc, char* argv[])
  213. {
  214.  int i;
  215.  int j=0;
  216.  int x=0;
  217.  __u32 saddr;
  218.  __u16 sport;
  219.  struct _data *pPtr;
  220.  init_data(1);
  221.  printf("data_init sucessful\n");
  222.  for(i=0;i<DATASIZE;i++)
  223.  {
  224.   
  225.   alloc_data_inode(123+i,987654+i,98765432+i,123456);
  226.   printf("i=%d\n",i);
  227.  }
  228.  printf("-------------------------\nDATACOUNT=%d\n",DATACOUNT);
  229.  printf("-------------------------\nHASHCOUNT=%d\n",HASHCOUNT);
  230.  pPtr=data_hash[123456];
  231.  while(pPtr!=NULL)
  232.  {
  233.   printf("(%d)%p:prev=%p,next=%p[saddr=%d,sport=%d]\n",x,pPtr,pPtr->prev,pPtr->next,pPtr->saddr,pPtr->sport);
  234.   pPtr=pPtr->next;
  235.   x++;
  236.  }
  237.  printf("-----------------------------------------\n");
  238.  x=0;
  239.  pPtr=data_hash[123456];
  240.  for(i=0;i<DATASIZE;i++)
  241.  {
  242.   saddr=987654+i;
  243.   sport=123+i;
  244.   detach_pcb(pPtr,123456,sport,saddr);
  245.   printf("(%d)delect:%d,pPtr=%p,pPtr->sport=%p\n",x,i,pPtr,pPtr->sport);
  246.   x++;
  247.  }
  248. printf("-----------------------------------------\n");
  249.   pPtr=data_hash[123456];
  250.   x=0;
  251.  while(pPtr!=NULL)
  252.  {
  253.   printf("(%d)%p:prev=%p,next=%p[saddr=%d,sport=%d]\n",x,pPtr,pPtr->prev,pPtr->next,pPtr->saddr,pPtr->sport);
  254.   pPtr=pPtr->next;
  255.   x++;
  256.  }
  257.  printf("-----------------------------------------\n");
  258.  for(i=0;i<DATASIZE-1;i++)
  259.  {
  260.  pPtr=lookup_pcb(987654+i,123+i,123456);
  261.  if(pPtr!=NULL)
  262.  {
  263.   j++;
  264.   printf("i=%d found it\n",i);
  265.  }
  266.  if(pPtr==NULL)
  267.   printf("i=%d not found\n",i);
  268.  }
  269.  pPtr=data_hash[123456];
  270.  while(pPtr!=NULL)
  271.  {
  272.   printf("(%d)%p:prev=%p,next=%p[saddr=%d,sport=%d]\n",x,pPtr,pPtr->prev,pPtr->next,pPtr->saddr,pPtr->sport);
  273.   pPtr=pPtr->next;
  274.   x++;
  275.  }
  276.  //exit(0);
  277.  return 0;
  278. }
 
JudyZLF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ hash.zip
04-23
接下来，我们谈谈处理冲突的方法——分离链表法。在散列中，冲突是指不同的输入值经过散列函数计算后得到相同的数组索引。分离链表法是一种有效的解决冲突的策略，它在每个数组槽内维护一个链表。当发生冲突时，...
哈希表(解决循环冲突链表问题)
flameboy的博客
05-06 2195
哈希表 哈希表是基于数组的顺序结构，每一个存储目标都会存在一个key值，哈希表也称为散列表。为解决冲突问题（多个目标用hash函数计算出相同的位置），本代码用了拉链法，另外本代码还解决了字符串插入哈希表循环冲突拉链的问题。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #de...
06 数据结构与算法之哈希表(拉链法) （C语言实现）
sinat_36002055的博客
05-23 1393
注：只给出C语言实现代码，涉及到的数据结构相关概念请自行阅读相关书籍或参考其他博文； 将哈希表理解为一个顺序表，顺序表里面存储的是一个链表(拉链法解决碰撞） 注：(hash & 0x7FFFFFFF)的作用：让hash值一直保持为正。 Because -1 % 10 == -1 which you certainly don’t want for indexing into an array. Forcing the sign bit to 0 avoids this problem. 0.
HashMap hash碰撞分析
yongfeng596的专栏
05-06 2203
HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。当程序执行 map.put(String,Obect)方法 时，系统将调用String的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法，都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后，系统会根据该 hashCode
HASH表解决冲突———双链表循环使用
朱朱的足迹
11-20 804
// 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冲突四种方法
姚明锋的博客
06-18 4万+
一）哈希表简介 非哈希表的特点：关键字在表中的位置和它之间不存在一个确定的关系，查找的过程为给定值一次和各个关键字进行比较，查找的效率取决于和给定值进行比较的次数。 哈希表的特点：关键字在表中位置和它之间存在一种确定的关系。哈希函数：一般情况下，需要在关键字与它在表中的存储位置之间建立一个函数关系，以f(key)作为关键字为key的记录在表中的位置，通常称这个函数f(key)为哈希函数。has
HASH 索引——用C语言实现
10-24
有多种解决冲突的方法，如开放寻址法（线性探测、二次探测或双哈希法）、链地址法（每个桶内是一个链表，存储哈希冲突的键值对）等。这里我们将使用链地址法，因为它是处理冲突的常见方法且易于实现。 4. **插入...
haxibiao.zip_哈希表
09-20
常见的冲突解决方法有开放寻址法（线性探测再散列、二次探测再散列、双哈希法等）和链地址法（每个桶存储一个链表，冲突的键被链接在一起）。 3. **装载因子**：装载因子是哈希表中已用元素数量与总容量的比值，...
北京师范大学数据结构教学资料第7章——搜索结构.ppt
09-28
理想情况下，散列函数应确保均匀分布，避免冲突，但当冲突发生时，可以采用开放寻址法或链地址法等解决策略。 总结起来，本章内容涵盖了静态搜索表、二叉搜索树（包括AVL树）和散列表等多种搜索结构，这些是数据...
Hash-table
03-16
2. 冲突处理优化：选择合适的冲突解决策略，如使用开放寻址法时的二次探测或双哈希，链地址法时的短链优化等。 3. 负载因子控制：维持适当的负载因子以保持较低的冲突率，同时避免频繁的扩容操作。 总结来说，哈希...
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
解决哈希冲突的三种方法（拉链法、开放地址法、再哈希法）
热门推荐
小猛同学的博客
06-12 6万+
上篇博客我们说到了，什么是哈希冲突，其实就是再采用哈希函数对输入域进行映射到哈希表的时候，因为哈希表的位桶的数目远小于输入域的关键字的个数，所以，对于输入域的关键字来说，很可能会产生这样一种情况，也就是，一个关键字会映射到同一个位桶中的情况，这种情况就就叫做哈希冲突，解决哈希冲突的有三种方案，一种叫做拉链法（也叫作链接法、链地址法，一个意思），另外三种分别为开发地址法和再散列法。 一、拉链法 ...
链表法解决hash冲突
weixin_30527323的博客
10-15 798
/* @链表法解决hash冲突 * 大单元数组，小单元链表 */ #pragma once #include <string> using namespace std; template<typename map_t> struct Node { size_t key; map_t content; ...
哈希（hash）表－－链地址法解决冲突
空大白
02-15 2140
首先要感谢下面博主:　mark　一下 https://www.cnblogs.com/s-b-b/p/6208565.html 说的很清楚，代码也能直接用，只是做了一点点小改进： HashList3.h的代码如下 #include &amp;quot;stdio.h&amp;quot; #include &amp;quot;stdlib.h&amp;quot; #include &amp;quot;string.h&amp;quot; #de
对散列冲突的处理——开放定址法
qq_37721485的博客
10-05 2071
对散列冲突的处理——开放定址法 之前聊了聊用分离链接法解决散列冲突的问题，这次就来聊聊对散列冲突的另一种解决办法：开放定址法。开放定址法分为线性探测，平方探测，双散列三种方法。 开放定址法 分离链接法是有一些不足的，它使用了一些链表，给新单元分配地址是需要时间的，这就导致算法的速度有些慢，同时这种方法实际上还要求对第二种数据结构的实现。而开放地址法不使用链表。开放定址法的思想是当发生冲突时，...
hashmap冲突的解决方法以及原理分析
weixin_36448423的博客
04-25 2430
白开水大佬实在写的是太好了，忍不住保存下来，让我对hashmap的原理有了更好的理解，可以反复看 https://www.cnblogs.com/peizhe123/p/5790252.html
hashmap冲突的解决方法以及原理分析：
weixin_30813225的博客
08-20 5054
在Java编程语言中，最基本的结构就是两种，一种是数组，一种是模拟指针(引用),所有的数据结构都可以用这两个基本结构构造，HashMap也一样。当程序试图将多个 key-value 放入 HashMap 中时，以如下代码片段为例： HashMap<String,Object> m=new HashMap<String,Object>();m.put("a", "rrr1...
哈希冲突解决方法
yangyang3401的博客
09-01 187
Java知识 解决哈希冲突的常用方法： （1）开放定址法：当关键字的哈希地址 p=H（key）出现冲突时，以 p 为基础，产生另一个哈希地址 p1，如果 p1 仍然冲突，再以 p 为基础，产生另一个哈希地址 p2，循环此过程直到找出一个不冲突的哈希地址，将相应元素存入其中； （2）再哈希法：这种方法是同时构造多个不同的哈希函数，当哈希地址 Hi=RH1（key）发生冲突时，再计算 Hi=RH2（k...
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
最新发布
07-17
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值