数据结构哈希表

#ifndef __HEAD_H_
#define __HEAD_H_
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//定义结点
typedef struct Node
{
//数据域
 int data;
 struct Node *next;
}*node;
#endif
/*
 * function:    对哈希表初始化NULL
 * @param [ in] 哈希表 哈希表长度
 * @param [out] 
 * @return    无返回  
 */
void Init(node hash[],int hash_len)
{
for(int i=0;i<hash_len;i++)
  {
  hash[i]=NULL;
   }
}
/*
 * function:    计算p
 * @param [ in] 哈希表长度hash_len
 * @param [out] 
 * @return      返回p
 */
int max_prme(int m)//m哈希表长度
{
for(int i=m;i>=2;i--)//循环小于等于m的所有数
{
	int count=0;
//判断i是否是素数
 for(int j=1;j<=i;j++)//循环所有小于等于i的数
 {
   if(i%j==0)
    {
     count++;
   }
 }
  if(count==2)
  {
  return i;
  }
}
}
/*
 * function:    创建结点
 * @param [ in] 
 * @param [out] 
 * @return      成功返回地址失败返回NULL
 */
node create_node()
{
node p=(node)malloc(sizeof(struct Node));
if(p==NULL)
return NULL;
p->data=0;
p->next=NULL;
return p;

}

/*
 * function:    把数组元素插入的哈希表
 * @param [ in] 哈希表 插入的值
 * @param [out] 
 * @return      无返回值函数
 */
void insert_hash(node hash[],int key,int hash_len)
{
//构建哈希函数
    int s=max_prme(hash_len);
	int sub=key%s;
  //把key存到sub对应的位置
	// hash[sub];
   //创建新结点p
     node p=create_node();
   if(p==NULL) 
   return;
  p->data=key;
  if(hash[sub]==NULL)
  {
  hash[sub]=p;
  
  }
  else
  {
  p->next=hash[sub]->next;
  hash[sub]->next=p;
  
  }
}
/*
 * function:    遍历哈希表
 * @param [ in] 哈希表的长度 哈希表
 * @param [out] 
 * @return      无
 */
void output(node hash[],int hash_len)
{
  for(int i=0;i<hash_len;i++)//循环每一个链表
    {
		printf("%d\n",i);
	   node p=hash[i];
	   while(p!=NULL)
	   {
	   printf("%d\t",p->data);
	   p=p->next;
	   }
     printf("NULL\n");
	}

}
/*
 * function:    哈希表查找
 * @param [ in] 哈希表 查找的值
 * @param [out] 
 * @return  成功返回0失败返回-1    
 */
int search_hash(node hash[],int k,int hash_len)
{
   int p=max_prme(hash_len);
   int sub=k%p;
  node s=hash[sub];
  while(s!=NULL)
  {
   if(s->data==k)
   {
   return 0;
   }
   s=s->next;
  }
   return -1;
}

int main (int argc, const char *argv[])
{
   //哈希表:把数据的元素存到哈希表,借助哈希表查找
      int arr[]={23,5,467,444,666,775,223,445,45,57};
          int len= sizeof(arr)/sizeof(int);
           int hash_len=len*4/3;//哈希表的长度
		  node hash[hash_len];
		  //防止哈希表是野指针,初始化为NULL
		    Init(hash,hash_len);
			//把数组元素存到哈希表
			for(int i=0;i<len;i++)
			{
			insert_hash(hash,arr[i],hash_len);
			}
			//遍历哈希表
			output(hash,hash_len);
			//查找
              int k;
			printf("请输入你要查找的:\n");
			scanf("%d",&k);
              int flag=search_hash(hash,k,hash_len); 
			  if(flag==-1)
			  {
			    printf("没找到\n");
			  }
			  else{
			  printf("找到了\n");
			  }
	return 0;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈希表是一种基于哈希函数进行快速查找的数据结构,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。哈希表的设计思路如下: 1. 哈希函数的设计:哈希函数是哈希表的核心,它将关键字映射到哈希表中的位置。一个好的哈希函数应该具有以下特点: - 映射范围广:哈希函数应该将关键字均匀地映射到哈希表中的位置,避免出现大量的哈希冲突。 - 计算速度快:哈希函数的计算速度应该尽可能快,以提高哈希表的访问速度。 - 低冲突率:哈希函数应该尽可能地避免哈希冲突,以提高哈希表的访问效率。 2. 哈希冲突的解决:由于哈希函数的映射范围是有限的,所以不同的关键字可能会映射到同一个位置,这就是哈希冲突。哈希冲突的解决方法有以下两种: - 链地址法:将哈希表中的每个位置都连接一个链表,当发生哈希冲突时,将新的关键字插入到链表的末尾。 - 开放地址法:当发生哈希冲突时,通过某种算法找到哈希表中的下一个空位置,将新的关键字插入到该位置。 3. 哈希表的增删查改操作:哈希表的增删查改操作都需要先通过哈希函数找到关键字在哈希表中的位置,然后再进行相应的操作。具体操作如下: - 插入操作:将新的关键字插入到哈希表中的对应位置,如果发生哈希冲突,则按照链地址法或开放地址法进行解决。 - 删除操作:将关键字从哈希表中对应位置删除,如果该位置上有链表,则需要遍历链表找到对应的关键字进行删除。 - 查找操作:通过哈希函数找到关键字在哈希表中的位置,如果该位置上有链表,则需要遍历链表找到对应的关键字进行查找。 - 修改操作:通过哈希函数找到关键字在哈希表中的位置,如果该位置上有链表,则需要遍历链表找到对应的关键字进行修改。 下面是一个使用链地址法实现的哈希表的Python代码示例: ```python class ListNode: def __init__(self, key=None, value=None): self.key = key self.value = value self.next = None class MyHashMap: def __init__(self): self.size = 1000 self.table = [None] * self.size def _hash(self, key): return key % self.size def put(self, key, value): index = self._hash(key) if not self.table[index]: self.table[index] = ListNode(key, value) else: node = self.table[index] while node: if node.key == key: node.value = value return if not node.next: break node = node.next node.next = ListNode(key, value) def get(self, key): index = self._hash(key) node = self.table[index] while node: if node.key == key: return node.value node = node.next return -1 def remove(self, key): index = self._hash(key) node = prev = self.table[index] if not node: return if node.key == key: self.table[index] = node.next else: node = node.next while node: if node.key == key: prev.next = node.next break node, prev = node.next, prev.next ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值