hash桶


  1 #include <stdio.h>
2 #include <stdlib.h>
3 #include "chain.c" //include the chain.c to create chain and list
4 #define NUMBER_SCOPE 69000
5 #define ARRAY_SIZE 100000000
6 #define PLUS_RESULT 5
7
8 int *createArray(long length){
9 int i;
10 int *array=(int*)malloc(length*sizeof(int));
11 srand((int)time(0));
12 printf("Array:");
13 for(i = 0;i<length;i++){
14 array[i]=rand()%NUMBER_SCOPE - (NUMBER_SCOPE)/2;
15 //printf("%d,",array[i]);
16 }
17 return array;
18 }
19
20 /*
21 find the max number from a array
22 */
23 int maxNum(int *array,int length){
24 int i,max;
25 max = array[0];
26 for(i = 1;i<length;i++){
27 if(array[i] > max){
28 max = array[i];
29 }
30 }
31 return max;
32 }
33 /*
34 find the min number from a array
35 */
36 int minNum(int *array,int length){
37 int i,min;
38 min = array[0];
39 for(i = 1;i<length;i++){
40 if(array[i] < min){
41 min = array[i];
42 }
43 }
44 return min;
45 }
46 /*
47 this function to fill barrel ,first parameter is the barrel,second is array
48 */
49 int *fillBarrel(int *barrel,int *array){
50 int i,site;
51 for(i = 0;i < ARRAY_SIZE;i++){
52 site = array[i] - barrel[1] + 3;
53 barrel[site] = 1;
54 }
55 return barrel;
56 }
57 /*
58 this function get a barrel array ,return a result chain,
59 it create by Quick Sort
60 */
61 struct chain *createResult(int *barrel){
62 int l_site,r_site,l_index,r_index;
63 struct chain *result;
64 struct list lst;
65 l_index = 3;
66 r_index = barrel[0] - 1;
67 while(l_index < r_index && 1){
68 if((barrel[l_index] == 1) && (barrel[r_index] == 1)){
69 l_site = l_index - 3 + barrel[1];
70 r_site = r_index - 3 + barrel[1];
71 // printf("\nl_site = %d\tr_site = %d",l_site,r_site);
72 // printf("\nbarrel[%d] = %d \nbarrel[%d] = %d",l_index,barrel[l_index],r_index,barrel[r_index]);
73 if((l_site + r_site) == PLUS_RESULT){
74 lst.firstNum = l_site;
75 lst.secondNum = r_site;
76 /*add in chain*/
77 result = addlink(result,lst);
78 l_index ++;
79 r_index --;
80 }
81 else if((l_site + r_site) > PLUS_RESULT){
82 r_index--;
83 }
84 else{
85 l_index++;
86 }
87 }else if(barrel[l_index] != 1){
88 l_index ++;
89 }
90 else{
91 r_index --;
92 }
93 }
94 return result;
95 }
96 /*
97 this function well create a barrel array by the array in the parameters
98 */
99 int *createBarrel(int *array,int length){
100 int min,max,capacity,*barrel,i;
101 min = minNum(array,length);
102 max = maxNum(array,length);
103 capacity = max - min + 4; //+4,because save capacity,min and max.
104 barrel = (int*)malloc(capacity*sizeof(int));
105 for(i = 0;i<capacity;i++){
106 barrel[i] = 0;
107 }
108 barrel[0] = capacity; //save barrel capacity in barrel[0]
109 barrel[1] = min; //save min number in barrel[1]
110 barrel[2] = max; //save max number in barrel[2]
111 return barrel;
112 }
113
114 /*
115 this function could display the information about the barrel and the content
116 */
117 void showBarrel(int *barrel){
118 int i;
119 // for(i = 3;i < barrel[0];i++){
120 // printf("%d\t",barrel[i]);
121 // }
122 printf("\narray_length = %d\ncapacity = %d\nmin = %d\nmax = %d\n",ARRAY_SIZE,barrel[0],barrel[1],barrel[2]);
123 }
124
125 main(){
126 int *array,*barrel;
127 long length;
128 struct chain *result;
129 //int a[] = {1,2,3,4,5,7,7,7,7,0};
130 printf("======main() begin=======\n");
131 length = ARRAY_SIZE;
132 array = createArray(length);
133 //array = a;
134 //printf("\n====create array over=======");
135 barrel = createBarrel(array,length);
136 //printf("\n====create barrel over=======");
137 barrel = fillBarrel(barrel,array);
138 //printf("\n====fill barrel over=======\n");
139 showBarrel(barrel);
140 //printf("\n====show barrel over=======\n");
141 result = create();
142 //printf("\n====create result over=======\n");
143 result = createResult(barrel);
144 printf("\n====computer result over=======\n");
145 /* the function to display the result chain*/
146 showChain(result);
147 }

hash桶,布布扣,bubuko.com

时间: 2024-10-09 13:41:02

hash桶的相关文章

数据结构:hash桶结构

#include <iostream> #include <stdlib.h> #define _SIZE_ 7 using namespace std; template<typename Type> struct Node { Type data; Node *next; Node(Type d = Type()) :data(d), next(NULL){} }; template<typename Type> struct myNode { Node

协议栈处理中的conntrack HASH查找/Bloom过滤/CACHE查找/大包与小包/分层处理风格

1.路由CACHE的优势与劣势 分级存储体系已经存在好多年了,其精髓在于"将最快的存储器最小化,将最慢的存储器最大化",这样的结果就使资源利用率的最大化,既提高了访问效率,又节省了资源.这是所有的CACHE设计的基本原则. 对于内存访问,几乎所有的CPU都内置了一级cache,二级cache,亲和力好的几个核心甚至设计了三级cache乃至四级cache,然后才是物理 内存,然后是经过精密优化的磁盘交换分区,最后是远程的存储器,这些存储空间逐级变大,访问开销也逐级变大,构成了一个金字塔型

海量路由表的快速检索问题-Hash/Trie/快速交换

在论坛上经常会有人问,到底是使用Trie算法保存路由表还是用Hash算法.那么我首先要明白,你要保存多大的路由表.简单的答案如下:少量:Hash算法大量:Trie算法但是,仅仅这么回答会显得很业余,真的很业余.但是如果回答多了,恐怕也不是什么好事,关键看问者是谁,目的做甚.因此简单且完整的回答必须毫无针对性,只能写作日志供日后回忆了. 以Linux内核为例,如果是少量的路由表,Hash算法的性能会很高,一共32个Hash桶,每一个前缀一个,所有的路由表项挂在这些Hash桶的冲突 链表上,由于路由

Hash概率问题

Hash是把锋利的刀子,处理海量数据时经常用到,大家可能经常用hash,但hash的有些特点你是否想过.理解过.我们可以利用我们掌握的概率和期望的知识,来分析Hash中一些有趣的问题,比如: 平均每个桶上的项的个数 平均查找次数 平均冲突次数 平均空桶个数 使每个桶都至少有一个项的项个数的期望 本文hash的采用链地址法发处理冲突,即对hash值相同的不同对象添加到hash桶的链表上. 每个桶上的项的期望个数 将n个不同的项hash到大小为k的hash表中,平均每个桶会有多少个项?首先,对于任意

php Hash Table(一) Hash Table的结构

Hash Table的结构图: 在上图中发现:Bucket1和Bucket2是hash冲突的双向链表,但是后添加的Bucket2是添加到头部的,可以看到Bucket2的pListLast和pNext指向Bucket1. 对HashTable结构体的字段解释: 1.nTableSize.顾名思义这个是整个哈希表分配的大小(在内部实现的C中分配的数组大小,PHP是动态的但到底层数组是有大小的是静态的),他的大小有一个固定的申请算法,一般是最接近并且大于当前这个数值的2的乘方,描述的可能有点模糊,举个

hash bucket

什么是bucket bucket的英文解释: Hash table lookup operations are often O(n/m) (where n is the number of objects in the table and m is the number of buckets), which is close to O(1), especially when the hash function has spread the hashed objects evenly throug

【连载】关系型数据库是如何工作的?(6) - Hash表

最后我们介绍的重要数据结构就是Hash表.当你需要快速查找的时候非常有用,而且理解Hash表会有助于我们以后理解常用数据库Join方式之一Hash join.这种数据结构常被数据库用作存储内部数据结构:表锁或缓存池(后续章节会介绍). Hash表能够通过元素Key快速找到元素的,为了构建一张Hash表,你需要定义: 一个元素的Key: 一个关于Key的Hash函数,Key的hash值就代表元素所在的位置(我们通常称为Hash桶): 一个关于Key的比较函数,一旦你找到了正确的桶,你就可以通过比较

为什么Java的hash表的长度一直是2的指数次幂?为什么这个(hash&amp;(h-1)=hash%h)位运算公式等价于取余运算?

1.什么是hash表? 答:简单回答散列表,运算在hash结构散列(分散)存放. 2.如何散列排布,如果均匀排布? 答:取余运算 3.Java中如何实现? 答:hash&(h-1) 4.为什么hash&(h-1)=等价于hash%h java的h(表长)一定是2的指数次幂,2的指数次幂2n 2n的结果:一定长这样10000...(n个0) 2n-1的结果:一定这样1111(n-1)个1 举个例子: 当h=16,对应的二进制:00010000 h-1=15,对应的二进制:00001111 可

Hash一致性算法底层原理

大纲 Hash取余算法 判定哈希算法好坏的四个定义 一致性Hash算法的两大设计 Hash取余算法 hash(Object.key)%N,hash值随Object.key.N的变化而变化. 如果有节点(集群中节点增减太正常)发生变化,几乎重新分配,意味着所有已经分配好的数据都要迁移到新的节点上. 一致性Hash算法提出了在动态变化的Cache环境中,判定哈希算法好坏的四个定义: 1.平衡性(Balance):平衡性是指哈希的结果能够尽可能分布在所有的缓冲(Cache)中去,这样可以使得所有的缓冲