[c語言實現]雜湊表

阿新 • • 發佈：2019-02-03

我們在這篇部落格雜湊表初探
已經初步瞭解了雜湊表的作用,那麼接下來就應該自己實現一下雜湊表了.

同樣的,實現兩種不同的解決雜湊衝突的方案1,閉雜湊 2,雜湊桶

閉雜湊

標頭檔案

#pragma once
#include<stdio.h>
//這個結構體表示雜湊表中的一個元素
//這個元素中同時包含了鍵值對
typedef int KeyType;
typedef char ValType;

typedef enum State
{

  Empty, //空狀態
  Vaild,//有效狀態
  Deleted,//服務於remove
}State;
struct HashTable;
typedef 
 size_t (*HashFunc)(KeyType key,struct HashTable* );

typedef struct HashElem{
  KeyType key;
  ValType val;
//每個hashtable內元素的狀態``
  State state;
}HashElem;
typedef struct HashTable{
  HashElem* data;
  size_t size;
  size_t capacity;
  // 填裝因子
  float Load_Factor;
    //雜湊函式
  HashFunc func;
}HashTable;
void 
 HashInit(HashTable* ht,HashFunc hash_func);
void HashDestory(HashTable* ht);
void HashInsert(HashTable* ht,HashElem elem);
ValType HashFind(HashTable* ht,  KeyType key);
size_t hash_func( KeyType key,HashTable*ht);
void  HashRemove(HashTable* ht,  KeyType key);
void HashPrint(HashTable* ht);

各個函式的實現

void HashInit(HashTable* ht,HashFunc hash_func);

初始化雜湊表的工作很簡單,分配儲存雜湊元素的陣列,然後初始化雜湊表內各個成員的初始值,
值得注意的是我們在申請雜湊表空間之後,陣列內的元素是隨機值,我們要標識該元素是否有效,那麼得把陣列內每個元素的狀態都至為Empty,(簡單的把元素都至為0是不行的,萬一要插入的key是0,那麼會出現此位置已經被佔用的錯誤)

size_t GetHashTableCapacity(HashTable* ht)
{
  if(ht  == NULL)
    return -1;
  return ht->capacity;
}
size_t hash_func( KeyType key,HashTable*ht)
{
  return key % GetHashTableCapacity(ht); 
}

void HashInit(HashTable* ht,HashFunc hash_func)
{
  if(ht == NULL || hash_func == NULL)
    return;
  ht->capacity = 1000;
  ht->data= (HashElem*) malloc(sizeof(size_t)* ht->capacity);
  ht->size = 0;
  ht->func = hash_func;
  size_t i = 0;
  for( ; i < ht->size; i++ )
  {
    ht->data[i].state  = Empty;
  }
}

void HasDestory(HashTable* ht)

銷燬很簡單,不提

void HashInsert(HashTable* ht,HashElem elem)

在雜湊表內插入元素,需要考慮的問題有
1.雜湊表滿了,2插入的key已經存在,3雜湊衝突的問題

void HashInsert(HashTable* ht,HashElem elem)
{
  KeyType key = elem.key;
  if(ht == NULL)
    return;
  if(ht->size >= ht->capacity * ht->Load_Factor)
  {
      //雜湊表已經滿了
      return;
  }
  size_t offset = (*ht->func)(key,ht);
    //雜湊衝突
  while(ht->data[offset].state == Vaild  )
  {
    offset++;
    //在佔用中找到了重複元素
    if(ht->data[offset].key == key)
    {
      //重複元素
      printf("重複元素\n");
      return;

    }
      //從頭開始找
    if( offset == ht->capacity )
    {
      //有填充因子存在 不會死迴圈
      offset = 0;
    }
  }


  //找到第一個狀態不是 已經佔用的位置插入
  ht->data[offset] = elem;`
  ht->data[offset].state = Vaild;
  ht->size++;
}

ValType HashFind(HashTable* ht,  KeyType key)
void  HashRemove(HashTable* ht,  KeyType key)

查詢要注意的點是:雜湊衝突,往後如果找到empty還沒找到key,就表明key不在雜湊表中,

因為這一點,當我們刪除時不能將key的狀態置為empty,這樣會使再次查詢key以後的元素失敗,所以我們應該為刪除元素獨立設立一個狀態Deleted

ValType HashFind(HashTable* ht,  KeyType key)
{
  if(ht == NULL)
    return -1;
  size_t offset = (*hash_func)(key,ht);
  //不為空但是又不是 key offset ++
  while(1)
  {
    //碰到查詢的元素是delete狀態
    //其實可以忽略,往後找空的就行
    if(ht->data[offset].state == Empty)
    {
      printf("not found \n");
      return -1;
    }
    //排除delete狀態
    if(ht->data[offset].key == key && ht->data[offset].state == Vaild ) 
    {
     return ht->data[offset].val; 
    }
    offset++;
    if(offset == ht->capacity)
      offset = 0;
  }
  //遇到刪除的狀態還得往後找(刪除後面元素的狀態可能是vaild)
  //只有遇到空狀態才表示查詢失敗(空表示此位置肯定沒有進行插入,它後面的元素就不可能是雜湊衝突造成的vaild狀態)
}

void  HashRemove(HashTable* ht,  KeyType key)
{
  if(ht == NULL)
    return ;
  size_t offset = (*hash_func)(key, ht);
  while(ht->data[offset].state != Empty)
  {
    if(ht->data[offset].key == key && ht->data[offset].state == Vaild)
    {
      ht->data[offset].state = Deleted;
      return;
    }
    offset++;
    if(offset == ht->capacity)
    {
      offset = 0;
    }
  }
  printf("not found \n");
  return;
}
void HashPrint(HashTable* ht)
{
  if(ht == NULL)
    return;
  size_t i = 0;
  for( ;  i < ht->capacity; i++ )
  {
    if(ht->data[i].state != Vaild)
    {
      continue;
    }
    printf("[%lu|%d|%d] " ,i, ht->data[i].key, ht->data[i].val);
  }
  printf("\n");
}

雜湊桶


#pragma once
#include<stdio.h>
#define HashMaxSize 1000
typedef int KeyType;
typedef char ValType;
typedef size_t (*HashFunc)(KeyType key );
typedef struct HashEelem{
  KeyType key;
  ValType val;
  struct HashEelem* next;
}HashEelem;
typedef struct HashTable{
  HashEelem* data[HashMaxSize];
  size_t size;
  //雜湊桶不需要填裝因子和狀態列舉

  HashFunc func;
}HashTable;
size_t hash_func( KeyType key);
void HashInit(HashTable* ht,HashFunc hash_func);
void HashDestory(HashTable* ht);
void HashInsert(HashTable* ht,HashEelem elem);
ValType HashFind(HashTable* ht,  KeyType key);
size_t hash_func( KeyType key);
void  HashRemove(HashTable* ht,  KeyType key);
void HashPrint(HashTable* ht);

#include"hash.h"
#include<stdlib.h>
#include<unistd.h>
size_t hash_func( KeyType key)
{
  return key % HashMaxSize; 
}
void HashInit(HashTable* ht,HashFunc hash_func)
{
  if(ht == NULL)
    return;
  int i = 0;
  for( ; i < HashMaxSize; i++ )
  {
    ht->data[i] = NULL;
  }
  ht->size = 0;
  ht->func = hash_func;
}
void HashDestory(HashTable* ht)
{
  if(ht == NULL)
    return;
  size_t i = 0;
  for(; i < HashMaxSize; i++)
  {
    HashEelem* cur = ht->data[i];
    HashEelem* to_delete = NULL;
    while(cur)
    {
      to_delete = cur;
      cur= cur->next;
      free(to_delete);
      to_delete = NULL;
    }
  }
 ht->size = 0; 
}
HashEelem* CreateNode(KeyType key, ValType val)
{
   HashEelem* elem =    (HashEelem*)malloc(sizeof(HashEelem));
   if(elem == NULL)
     return NULL;
   elem->key = key;
   elem->val = val;
   elem->next = NULL;
   return elem;
}
void HashInsert(HashTable* ht,HashEelem elem)
{
  if(ht == NULL)
    return;
  size_t offset = ht->func(elem.key);
  if(ht->data[offset] == NULL)
  {
    ht->data[offset] = CreateNode(elem.key,elem.val);
  }
  else 
  {
    HashEelem* new_node= CreateNode(elem.key,elem.val);
    new_node->next = ht->data[offset];
    ht->data[offset] = new_node;
  }
  ht->size++;
}
ValType HashFind(HashTable* ht,  KeyType key)
{
  if(ht == NULL)
    return -1;
  size_t offset = ht->func(key);
  HashEelem* cur = ht->data[offset];
  while(cur)
  {
   if(cur->key == key)
   {
     return cur->val;
   }
   cur = cur->next;
  }
  printf("not found\n");
  return -1;
}
void  HashRemove(HashTable* ht,  KeyType key)
{
  if(ht == NULL)
    return;
  size_t offset = ht->func(key);
  HashEelem* cur = ht->data[offset];
  HashEelem* pre_cur = NULL;
  while(cur)
  {
    if( cur->key == key )
    {
      break;
    } 
    pre_cur = cur;
    cur = cur->next;
  }
  if(cur == NULL)
  {
    printf("empty key \n");
  }
  else if(pre_cur == NULL)
  {
    free(cur);
    cur = NULL;
  }
  else 
  {
    free(cur);
    cur = NULL;
   pre_cur->next = NULL; 
  }
}
void HashPrint(HashTable* ht)
{
  size_t i = 0;
  for(; i < HashMaxSize; i++)
  {
    if( ht->data[i] == NULL )
      continue;
    HashEelem* cur = ht->data[i] ;
    printf("第%lu條連結串列結構如下\n",i); 
    while(cur)
    {
      /*sleep(1);*/
      printf("[key: %d| val: %d] ", cur->key,cur->val);
      cur = cur->next;
    }
    printf("\n");
  }
  printf("\n");
}

[c語言實現]雜湊表

我們在這篇部落格雜湊表初探已經初步瞭解了雜湊表的作用,那麼接下來就應該自己實現一下雜湊表了. 同樣的,實現兩種不同的解決雜湊衝突的方案1,閉雜湊 2,雜湊桶閉雜湊標頭檔案 #pragma once #include<stdio

C語言實現雜湊表查詢演算法

雜湊表（散列表）是直接通過關鍵字key得到要查詢的記錄的記憶體儲存位置。雜湊技術是在記錄的儲存位置和它的關鍵字之間建立一個確定的對應關係f，使得每個關鍵字key對應一個儲存位置f(key)。採用雜

c語言資料結構實現-雜湊表/雜湊桶（hashtable/hashbucket）

一、需求以“key-value”的形式進行插入、查詢、刪除，是否可以考慮犧牲空間換時間的做法？二、相關知識雜湊表（Hashtable）又稱為“雜湊表”，Hashtable是會根據索引鍵的雜湊程式程式碼組織成的索引鍵（Key）和值（Value）配對的集合。Hashtab

自己動手用c++實現雜湊表

雜湊表查詢效率約等於1 實現思想介紹一般的hash思想未採用模板，簡單的實現 key是int，value是string 把輸入的key值經過hash函式計算，算出它要放入的桶的編號採用一個指標陣列記錄各個桶每個桶裡都有50個key_value物件

C語言實現靜態順序表

實現順序表分為以下幾步： 1.先寫出封裝順序表結構的結構體； 2.初始化順序表； 3.增刪查改； 4.順序表的逆置等。 #define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType d

C語言實現動態順序表(Linux環境)

SeqList.h /************************************************************************* > File Name: SeqList.h > Author: > Mail

資料結構C語言實現-2—線性表

Table of Contents 靜態連結串列線性表順序儲存結構 #include <stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #de

java 陣列實現雜湊表的構建，查詢，插入，刪除

以下程式碼以陣列儲存方式實現了雜湊表的建立，查詢，插入，刪除等操作，雜湊函式採用除留餘數法，使用開放定址法中的線性探查法處理衝突 public class HashSearch { /*使用陣列實現hashtable的建立，查詢，插入，刪除*/

用C語言實現輸出乘法表！

解題思路： 1、輸入整型變數i，j，其中i的取值範圍在1到9之間，j的取值範圍在1到i之間； 2、用i*j輸出，每輸出一行以後就換行；程式碼如下： //輸出乘法表！ #include <stdio.h> int main() { int i = 0; for (i =

C++資料結構--.雜湊表線性探測開放定址法與獨立錶鏈地址法

class hashTable {friend class hashIterator;private:vector<list<T>> table; hashFun fun; //雜湊函式物件size_t rows; public:#include"hashIterator.h"

c語言實現簡單單鏈表

1.比較順序表和連結串列的優缺點，說說他們正在什麼場景下使用？答：對於順序表，無論是動態還是靜態，他們有都會死連續的儲存空間，在讀取時間效率上比較短，但在插入和刪除時會比較麻煩，需要不斷的遍歷去找到尾節點。對於連結串列，因為是

資料結構C語言實現——順序線性表SqList

delcaration.h #ifndef DECLARATION_H_INCLUDED #define DECLARATION_H_INCLUDED #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0

C++ STL中雜湊表Map 與 hash_map 介紹

0 為什麼需要hash_map 用過map吧？map提供一個很常用的功能，那就是提供key-value的儲存和查詢功能。例如，我要記錄一個人名和相應的儲存，而且隨時增加，要快速查詢和修改：嶽不群－華山派掌門人，人稱君子劍張三丰－武當掌門人，太極拳創始人東方

資料結構之---c語言實現迴圈單鏈表操作

wechat:812716131 ------------------------------------------------------ 技術交流群請聯絡上面wechat ----------------------------------------------

C++ STL中雜湊表 hash_map介紹

0 為什麼需要hash_map 用過map吧？map提供一個很常用的功能，那就是提供key-value的儲存和查詢功能。例如，我要記錄一個人名和相應的儲存，而且隨時增加，要快速查詢和修改：嶽不群－華山派掌門人，人稱君子劍張三丰－武當掌門人，太極拳創始人東方不敗－第一高手，葵花寶典 ... 這

C++淺談雜湊表和STLmap

題目：對比雜湊表和STL map。雜湊表是怎麼實現的？如果輸入資料規模不大，我們可以使用什麼資料結構來代替雜湊表。解答：對比雜湊表和STL map 在雜湊表中，實值得儲存位置由其鍵值對應得雜湊函式值決定。因此，儲存在雜湊表中得值是無序得。在雜湊表

使用python實現雜湊表、字典、集合

雜湊表雜湊表（Hash Table, 又稱為散列表），是一種線性表的儲存結構。雜湊表由一個直接定址表和一個雜湊函式組成。雜湊函式h(k)將元素關鍵字k作為自變數，返回元素的儲存下標。簡單雜湊函式：除法雜湊：h(k) = k mod m 乘法雜湊：h(k) = floor(m(kA mod 1)) 0&

雜湊表 -- C語言實現

1 雜湊表原理這裡不講高深理論，只說直觀感受。雜湊表的目的就是為了根據資料的部分內容（關鍵字），直接計算出存放完整資料的記憶體地址。試想一下，如果從連結串列中根據關鍵字查詢一個元素，那麼就需要遍歷才能得到這個元素的記憶體地址，如果連結串列長度很大，查詢就需要更多的時間. void*

雜湊表 -- C語言實現

1 雜湊表原理這裡不講高深理論，只說直觀感受。雜湊表的目的就是為了根據資料的部分內容（關鍵字），直接計算出存放完整資料的記憶體地址。試想一下，如果從連結串列中根據關鍵字查詢一個元素，那麼就需要遍歷才能得到這個元素的記憶體地址，如果連結串列長度很大，查詢就需要更多的時間

雜湊三部曲：二：第一部分：C語言實現靜態雜湊表

在這個靜態雜湊表中我們用一個容量為10 的靜態陣列作為雜湊表的底層構造但是陣列的每一個儲存空間中又分為兩個部分資料區：data

[c語言實現]雜湊表

閉雜湊

標頭檔案

各個函式的實現

雜湊桶

相關推薦