hash表的具體實現

原創 Cyrus_wen 2020-02-20 15:13
閉散列

hash1.c

#include "hash1.h"
#include <stdio.h>
#include <stddef.h>


void HashInit(HashTable* ht, HashFunc hash_func){
    if(ht == NULL){
        return;
    }
    ht->size = 0;
    ht->func = hash_func;
    size_t i = 0;
    for(; i < HashMaxSize; ++i){
        ht->data[i].stat = Empty; 
    }
    return;
}

void HashDestroy(HashTable* ht){
    if(ht == NULL){
        return;
    }
    ht->size = 0;
    ht->func = NULL;
    size_t i = 0;
    for(; i < HashMaxSize; i++){
        ht->data[i].stat = Empty;
    }        
    return;
}

void HashInsert(HashTable* ht, KeyType key, ValType value){
    if(ht == NULL){
        return;
    }

    //設置負載因子爲0.8
    if(ht->size >= 0.8 * HashMaxSize){
        //表示大於負載因上限
        return;
    }

    size_t offset = ht->func(key);
    while(1){
        if(ht->data[offset].stat != Valid){
            ht->data[offset].key = key;
            ht->data[offset].stat = Valid;
            ht->data[offset].value = value;
            ++ht->size;
        }else if(ht->data[offset].stat == Valid && ht->data[offset].key == key){
            //如果遇到key值相同的，插入失敗
            return;
        }else{
            //線性探測找到下一個有效位置
            offset++;
            if(offset > HashMaxSize){
                offset = 0;
            }
        }
    }
    return;
}

int HashFind(HashTable* ht, KeyType key, ValType* value){
    if(ht == NULL){
        return 0;
    }
    if(ht->size == 0){
        return 0;
    }
    size_t offset = ht->func(key);
    while(1){
        if(ht->data[offset].key == key && ht->data[offset].stat == Valid){
            *value = ht->data[offset].value;
            return 1;
        }else if(ht->data[offset].stat == Empty){
            return 0;
        }else{
            ++offset;
            offset = offset > HashMaxSize ? 0 : offset;
        }
    }
    return 0;
}

void HashRemove(HashTable* ht, KeyType key){
    if(ht == NULL){
        return;
    }
    if(ht->size == 0){
        //空的哈希表
        return;
    }
    size_t offset = ht->func(key);
    while(1){
        if(ht->data[offset].key == key && ht->data[offset].stat == Valid){
            ht->data[offset].stat = Deleted;
            --ht->size;
            return;
        }else if(ht->data[offset].stat == Empty){
            //如果當前狀態爲空，表示查找失敗
            return;
        }else{
            //線性地向下探測
            ++offset;
            offset = offset > HashMaxSize ? 0 : offset;
        }
    }
}

void HashPrnit(HashTable* ht, const char* message){
    if(ht == NULL || message == NULL){
        return;
    }
    printf("[%s]\n", message);
    size_t i = 0;
    for(;i <= ht->size; i++){
        if(ht->data[i].stat == Empty){
            continue;
        }
        printf("[%lu, %d : %d]\n", i, ht->data[i].key, ht->data[i].value);
    }
    return;
}

hash1.h

#pragma once
#include <stdio.h>
#include <stddef.h>

#define TestType printf("\n######################### %s ############################\n",__FUNCTION__)

//我們存放的是鍵值對
#define HashMaxSize 1000

typedef enum{
    Empty, //空狀態
    Deleted, //被刪除狀態
    Valid, //有效狀態
} Stat;

typedef int KeyType;
typedef int ValType;

typedef size_t (*HashFunc)(KeyType key);

//這個結構體表示哈希表中的一個元素
typedef struct HashElem{
   KeyType key;
   ValType value;
   Stat stat;
} HashElem;

//[0, size)不能表示有效元素
typedef struct HashTable{
    HashElem data[HashMaxSize];
    size_t size;
    HashFunc func;
} HashTable;

void HashInit(HashTable* ht, HashFunc hash_func);

void HashDestroy(HashTable* ht);

void HashInsert(HashTable* ht, KeyType key, ValType value);

int HashFind(HashTable* ht, KeyType key, ValType* value);

void HashRemove(HashTable* ht, KeyType key);

void HashPrnit(HashTable* ht, const char* message);

main1.c

#include "hash1.h"
#include <stdio.h>

size_t HashFuncDefault(KeyType key){
    return key % HashMaxSize;
}

void TestInit(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    printf("size expected 0, actual %lu\n", ht.size);
    printf("func expected %p, actual %p\n", HashFuncDefault, ht.func);
    return;
}

void TestHashDestroy(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashDestroy(&ht);
    printf("size expected 0, actual %lu\n", ht.size);
    printf("func expected NULL, actual %p\n",ht.func);
    return;
}

void TestHashRemove(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashInsert(&ht, 1, 1);
    HashInsert(&ht, 2, 2);
    HashInsert(&ht, 1001, 11);
    HashPrnit(&ht, "刪除前");
    HashRemove(&ht, 1001);
    HashPrnit(&ht, "刪除後");
    return;
}

void TestHashInsert(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashInsert(&ht, 1, 1);
    HashInsert(&ht, 1, 10);
    HashInsert(&ht, 2, 2);
    HashInsert(&ht, 1001, 11);
    HashInsert(&ht, 1002, 12);
    HashPrnit(&ht, "插入元素");
    return;
}

void TestFind(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashInsert(&ht, 1, 1);
    HashInsert(&ht, 1, 10);
    HashInsert(&ht, 2, 2);
    HashInsert(&ht, 1001, 11);
    HashInsert(&ht, 1002, 12);
    int value = 0;
    int ret = HashFind(&ht, 1002, &value);
    printf("ret expected is 1, actual %d\n", ret);
    printf("value epected is 12, actual %d\n", value);
    return;
}

int main(){
    TestInit();
    TestHashDestroy();
    TestHashInsert();
    TestFind();
    TestHashRemove();
    return 0;
}
開散列

hash2.h

#pragma once
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>

#define HASHMAXSIZE 1000

#define TestType printf("\n############################## %s ###############################\n", __FUNCTION__)

typedef int KeyType;
typedef int ValType;

typedef size_t (*HashFunc)(KeyType key);

typedef struct HashElem{
    KeyType key;
    ValType value;
    struct HashElem* next;
} HashElem;

typedef struct HashTable{
    HashElem* data[HASHMAXSIZE];
    size_t size;
    HashFunc func;
} HashTable;

void HashInit(HashTable* ht, HashFunc HashFuncDefault);

void HashDestroy(HashTable* ht);

HashElem* HashBucketFind(HashElem* Elem, KeyType to_find);

void HashInsert(HashTable* ht, KeyType key, ValType value);

int HashFind(HashTable* ht, KeyType key, ValType* value);

int HashSize(HashTable* ht);

void HashPrint(HashTable* ht,const char* msg);

void HashRemove(HashTable* ht, KeyType key);

size_t HashFuncDefault(KeyType key);

hash2.c

#include "hash2.h"

HashElem* CreateHashElem(KeyType key, ValType value){
    HashElem* new_node = (HashElem*)malloc(sizeof(HashElem));
    new_node->key = key;
    new_node->value = value;
    new_node->next = NULL;
    return new_node;
}

size_t HashFuncDefault(KeyType key){
    return key % HASHMAXSIZE;
}

void DestroyHashElem(HashElem* hash){
    free(hash);
    return;
}

void HashInit(HashTable* ht, HashFunc HashFuncDefault){
    if(ht == NULL){
        return;
    }
    ht->func = HashFuncDefault;
    ht->size = 0;
    size_t i = 0;
    for(;i < HASHMAXSIZE; i++){
        ht->data[i] = NULL;
    }
    return;
}

void HashDestroy(HashTable* ht){
    if(ht == NULL){
        return;
    }
    ht->func = NULL;
    ht->size = 0;
    size_t i = 0;
    for(; i < HASHMAXSIZE; i++){
        HashElem* cur = ht->data[i];
        while(cur != NULL){
            HashElem* tmp = cur;
            cur = cur->next;
            DestroyHashElem(tmp);
            tmp = NULL;
        }
    }
}

HashElem* HashBucketFind(HashElem* Elem, KeyType to_find){
    if(Elem == NULL){
        return NULL;
    }

    HashElem* cur = Elem;
    for(; cur != NULL; cur = cur->next){
        if(cur->key == to_find){
            break;
        }
    }
    return cur == NULL ? NULL : cur;

}

void HashInsert(HashTable* ht, KeyType key, ValType value){
    if(ht == NULL){
        return;
    }
    //根據key算出offset
    size_t offset = ht->func(key);
    HashElem* ret = HashBucketFind(ht->data[offset], key);
    if(ret != NULL){
        //返回值不爲空，表示已經有key
        return;
    }

    HashElem* new_node = CreateHashElem(key, value);
    new_node->next = ht->data[offset];
    ht->data[offset] = new_node;
    ++ht->size;
    return;
}

int HashFind(HashTable* ht, KeyType key, ValType* value){
    if(ht == NULL || value == NULL){
        return -1;
    }
    size_t offset = ht->func(key);
    HashElem* ret = HashBucketFind(ht->data[offset], key);
    if(ret == NULL){
        return 0;
    }
    *value = ret->value;
    return 1;
}

int HashSize(HashTable* ht){
    if(ht == NULL){
        return 0;
    }
    return ht->size;
}

int HashBucketFindEx(HashElem* head, KeyType to_find, HashElem** pre_node, HashElem** cur_node){
    HashElem* pre = NULL;
    HashElem* cur = head;
    for(;cur != NULL; pre = cur, cur = cur->next){
        if(cur->key == to_find){
            break;
        }
    }
    if(cur == NULL){
        return 0;
    }
    *cur_node = cur;
    *pre_node = pre;
    return 1;
}

void HashRemove(HashTable* ht, KeyType key){
    if(ht == NULL){
        return;
    }
    if(ht->size == 0){
        return;
    }
    size_t offset = ht->func(key);
    HashElem* pre = NULL;
    HashElem* cur = NULL;
    int ret = HashBucketFindEx(ht->data[offset], key, &pre, &cur);
    if(ret == 0){
        return;
    }
    if(pre == NULL){
        ht->data[offset] = cur->next;
    }else{
        pre->next = cur->next;
    }
    DestroyHashElem(cur);
    ht->size--;
    return;
}

void HashPrint(HashTable* ht,const char* msg){
    if(ht == NULL){
        return;
    }
    printf("[%s:]\n",msg);
    size_t i = 0;
    for(; i < HASHMAXSIZE; ++i){
        if(ht->data[i] == NULL){
            continue;
        }
        printf("%lu\n",i);
        HashElem* cur = ht->data[i];
        for(;cur != NULL; cur = cur->next){
            printf("[%d:%d] ", cur->key, cur->value);
        }
        printf("\n");
    }
    return;
}

main2.c

#include "hash2.h"
#include <stdio.h>


void TestHashInit(){
    TestType;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    printf("func expected %p, actual %p\n", HashFuncDefault, ht.func);
    printf("size expected 0, actual %lu\n",ht.size);
    return;
}

void TestHashDestroy(){
    TestType;
    HashTable ht;
    HashDestroy(&ht);
    printf("func expected NULL, actual %p\n", ht.func);
    printf("size expected 0, actuall %lu\n",ht.size);
    return;
}

void TestHashInsert(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashInsert(&ht, 2, 10);
    HashInsert(&ht, 10, 13);
    HashInsert(&ht, 12, 14);
    HashInsert(&ht, 13, 15);
    HashPrint(&ht, "打印哈希表");
    return;
}

void TestHashFind(){
    TestType;
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashInsert(&ht, 2, 10);
    HashInsert(&ht, 10, 13);
    HashInsert(&ht, 12, 14);
    HashInsert(&ht, 13, 15);
    int Val;
    int ret = HashFind(&ht,13, &Val );
    printf("ret expect 1, actual %d\n", ret);
    printf("value expect 15, actual %d\n", Val);
    return;
}

void TestHashRemove(){
    HashTable ht;
    HashInit(&ht, HashFuncDefault);
    HashInsert(&ht, 2, 10);
    HashInsert(&ht, 10, 13);
    HashInsert(&ht, 12, 14);
    HashInsert(&ht, 13, 15);
    HashPrint(&ht, "刪除前");
    HashRemove(&ht,12);
    HashPrint(&ht, "刪除後");
    return;
}

int main(){
    TestHashInit();
    TestHashDestroy();
    TestHashInsert();
    TestHashFind();
    TestHashRemove();
    return 0;
}
Cyrus_wen
發佈了66 篇原創文章 · 獲贊 22 · 訪問量 2萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Git 原理與實踐

工作過程中發現很多小夥伴會git理解不深，操作過程中往往使用一些 刪除分支，文件備份的方法保證自己的代碼。本文將結合工程實踐講解git的原理 本文長期更新，歡迎研討交流。 一：git 強制回退 一不小心提交了多於的代碼到mast

陈—凡 2020-07-06 00:34:00

idea git分支圖 使用說明(1)

idea git圖解分析 compact references view 簡潔引用視圖 簡潔引用： align references to left 將引用向左對齊 引用左右對齊配置： Show tag names 顯示

陈—凡 2020-07-06 00:33:59

idea git分支圖 使用說明(2)

Trun IntelliSort On 打開intelli 排序 默認排序 默認排序按照時間線，不同分支提交節點交替 分支數少，對應 collapse linear branch and Expand linear bra

陈—凡 2020-07-06 00:33:59

哈希表的簡單介紹

哈希表的概念 哈希表（Hash Table）也叫散列表，是根據鍵碼值（key value）而直接進行訪問的數據結構。它通過把關鍵碼值映射到哈希表中的一個位置來訪問記錄，以加快查找速度。這個映射函數就叫做散列函數，存放記錄的數組的

Cyrus_wen 2020-07-04 18:30:52

來來來，線程基本概念瞭解一下~~~

線程的概念 那麼什麼是線程呢？ 百度百科是這樣介紹的： 線程，有時被稱爲輕量級進程(Lightweight Process，LWP），是程序執行流的最小單元。一個標準的線程由線程ID，當前指令指針(PC），寄存器集合和堆棧組成

Cyrus_wen 2020-07-04 18:30:52

布隆過濾器課堂代碼

bloom.h #pragma once #include "bitmap.h" #define BloomHashCount 2 typedef uint64_t (*BloomHash)(const char*); type

Cyrus_wen 2020-07-04 18:30:52

三款Java性能測試的工具介紹(未完待續...)

一、JMH a、簡介 JMH，即Java Microbenchmark Harness，是專門用於代碼微基準測試的工具套件。何謂Micro Benchmark呢？簡單的來說就是基於方法層面的基準測試，精度可以達到微秒級。當你定位到熱點方法

坏蛋呆呆 2020-06-29 12:22:21

Idea下如何使用lombok

一、準備環境 在Idea安裝lombok插件，如果不安裝的話，跳過此步驟，則工程會報錯的。在Idea中File→Setting→Plugins中，搜索lombok，點擊install完成後重啓idea即可，見圖。 二、maven引入lom

坏蛋呆呆 2020-06-29 12:22:21

Mac adb devices時，一直顯示emulator-5554 offline如何解決

問題： 在終端執行adb devices時，一直顯示emulator-5554 offline，adb disconnect也刪除不掉。 原因： 有程序佔用5555端口，導致adb認爲5554不能作爲第一個設備啓用 辦法： lsof -i

小豆瓣的靳先生 2020-06-19 17:21:32

idea 配置javap 擴展工具 External Tools

一：新增 External Tools 二、 配置javap 三、使用 在idea 項目中 選中一個Java文件

陈—凡 2020-06-16 15:17:49

idea在eclipse keymap下的快捷鍵

目錄 以下用帶“&”來表示該部分比較重要。 文章目錄目錄快捷鍵詳解&執行、&補全、&註釋行：&複製、&刪除、&移動、開啓新行&查看源碼、&生成變量名、&頁面來回切換、&查看類繼承關係&代碼格式化、&提示方法參數、&複製剪切粘貼

五彩世界 2020-06-11 16:23:37

Eclipse 入手配置

工欲善其事，必先利其器 前言 在安裝eclipse後進行簡單的配置能夠爲以後的開發提高不少效率，（由於目前經驗不足,這裏記錄下來僅供參考,會持續修改） 目前使用eclipse版本： 一、編碼配置 utf-8 1.work

小鸣的微笔记 2020-06-07 06:01:42

Java開發相關官方存檔下載地址

在開發的過程中，我們會用到一些老版本的軟件、配置文件等，但是官網一般都直接放的是最新版，幸好很多都是有存檔供下載的，這裏收集一些官方存檔，本人也是剛入行的菜鳥，如果大家有推薦的也可以下面留言，我會及時更新。 jdk Java

小鸣的微笔记 2020-06-07 06:01:42

Mac筆記本外接顯示器豎屏設置

小豆瓣的靳先生 2020-06-04 04:16:54

幾種安卓手機模擬器的對比：遊戲以外的使用

Honour Van 2020-05-17 03:31:06