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

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
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
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
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. }