哈希存储、哈希表、哈希表的基本操作、算法的一些概念

最新推荐文章于 2024-09-14 10:37:21 发布
最新推荐文章于 2024-09-14 10:37:21 发布
阅读量771 收藏 5
点赞数 11
文章标签： 数据结构 哈希表 哈希存储 vim linux 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71850179/article/details/137001286
版权
本文介绍了使用搜索(查找)二叉树和哈希表的数据结构在嵌入式开发中的应用，包括平衡二叉树的选择、哈希函数设计、数据插入、查找操作以及哈希表的销毁和遍历。作者通过实例演示了如何创建哈希表并处理哈希冲突问题。
摘要由CSDN通过智能技术生成

我要成为嵌入式高手之3月25日数据结构第七天！！
—————————————————————————————

搜索(查找)二叉树

思想：左大右小

主要为了进行二分查找，由于根节点选择不合适，容易造成树不平衡，故产生了平衡二叉树

哈希存储(散列存储)

为了快速定位数据

哈希表

哈希冲突 / 哈希矛盾

关键字不一样，但是映射之后结果一样

如何避免 哈希矛盾？

1、重新设计哈希函数，尽可能均匀散列分布在哈希表

2、开放定址法：向下寻找未存储的位置进行存放数据

3、链地址法： 将数据链表的首地址存入哈希表，只需将数据结点往链表后链接即可

1、创建哈希表

HASH_NODE *hash_table[HASH_SIZE] = {NULL};

2、设计哈希函数

int HashFun(char ch)
{
    if (ch >= 'a' && ch <= 'z')
    {
        return ch - 'a';
    }
    else if (ch >= 'A' && ch <= 'Z')
    {
        return ch - 'A';
    }
    else
    {
        return HASH_SIZE-1;
    }
}

3、数据插入哈希表

int InsertHashTable(DATA_TYPE data)
{
    HASH_NODE *pnode = malloc(sizeof(HASH_NODE));
    if (NULL == pnode)
    {
        perror("fail to malloc pnode");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    int addr = HashFun(data.name[0]);

    if (IsEmpty(addr))
    {
        hash_table[addr] = pnode;
    }
    else
    {
        pnode->pnext = hash_table[addr];
        hash_table[addr] = pnode;
    }
}

4、数据查找

int SearchInHashTable(char *tmpname)
{
    HASH_NODE *ptmp = NULL;

    int addr = HashFun(tmpname[0]);
    if (IsEmpty(addr))
    {
        printf("查无此人!\n");
        return -1;
    }
    else
    {
        ptmp = hash_table[addr];
        while (ptmp != NULL)
        {
            if (!strcmp(ptmp->data.name, tmpname))
            {
                printf("该人的信息如下:\n");
                printf("name: %s\n tel: %s\naddr: %s\n", ptmp->data.name, ptmp->data.tel, ptmp->data.addr);
                return 0;
            }
            else
            {
                ptmp = ptmp->pnext;
            }
        }
        printf("查无此人!\n");
        return -1;
    }
}

5、销毁哈希表

int DestroyHashTable()
{
    HASH_NODE *ptmp = NULL;
    HASH_NODE *pfree = NULL;

    int addr = 0;
    for (addr =0; addr < HASH_SIZE; ++addr)
    {
        if (IsEmpty(addr))
        {
            continue;
        }
        ptmp = hash_table[addr];
        while (ptmp != NULL)
        {
            pfree = ptmp;
            ptmp = ptmp->pnext;
            free(pfree);
        }
    }
}

6、遍历

void SearchAll()
{
    HASH_NODE *ptmp = NULL;
    int i = 0;
    
    for (i = 0; i < HASH_SIZE; ++i)
    {
        if (IsEmpty(i))
        {
            continue;
        }
        else
        {
            ptmp = hash_table[i];
            while (ptmp != NULL)
            {
                printf("name[%d]: %s\n", i, ptmp->data.name);
                ptmp = ptmp->pnext;
            }
        }
    }
}

总程序：

main.c

#include "hash.h"

int main()
{
    DATA_TYPE pers[4] = {
        {"zhangsan", "110", "xian"},
        {"lisi", "120", "beijing"},
        {"wangwu", "119", "guangzhou"},
        {"liuqi", "12315", "shenzhen"},
    };

    InsertHashTable(pers[0]);
    InsertHashTable(pers[1]);
    InsertHashTable(pers[2]);
    InsertHashTable(pers[3]);

    char  tmp[32] = {0};
    printf("请输入要查找的人的名字: ");
    fgets(tmp, sizeof(tmp), stdin);
    tmp[strlen(tmp)-1] = '\0';
    SearchInHashTable(tmp);
    printf("==============================\n");

    SearchAll();

    DestroyHashTable();

    return 0;
}

hash.c

#include "hash.h"

HASH_NODE *hash_table[HASH_SIZE] = {NULL};

int HashFun(char ch)
{
    if (ch >= 'a' && ch <= 'z')
    {
        return ch - 'a';
    }
    else if (ch >= 'A' && ch <= 'Z')
    {
        return ch - 'A';
    }
    else
    {
        return HASH_SIZE-1;
    }
}

int IsEmpty(int addr)
{
    if (hash_table[addr] == NULL)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int InsertHashTable(DATA_TYPE data)
{
    HASH_NODE *pnode = malloc(sizeof(HASH_NODE));
    if (NULL == pnode)
    {
        perror("fail to malloc pnode");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    int addr = HashFun(data.name[0]);

    if (IsEmpty(addr))
    {
        hash_table[addr] = pnode;
    }
    else
    {
        pnode->pnext = hash_table[addr];
        hash_table[addr] = pnode;
    }
}

void SearchAll()
{
    HASH_NODE *ptmp = NULL;
    int i = 0;
    
    for (i = 0; i < HASH_SIZE; ++i)
    {
        if (IsEmpty(i))
        {
            continue;
        }
        else
        {
            ptmp = hash_table[i];
            while (ptmp != NULL)
            {
                printf("name[%d]: %s\n", i, ptmp->data.name);
                ptmp = ptmp->pnext;
            }
        }
    }
}

int SearchInHashTable(char *tmpname)
{
    HASH_NODE *ptmp = NULL;

    int addr = HashFun(tmpname[0]);
    if (IsEmpty(addr))
    {
        printf("查无此人!\n");
        return -1;
    }
    else
    {
        ptmp = hash_table[addr];
        while (ptmp != NULL)
        {
            if (!strcmp(ptmp->data.name, tmpname))
            {
                printf("该人的信息如下:\n");
                printf("name: %s\n tel: %s\naddr: %s\n", ptmp->data.name, ptmp->data.tel, ptmp->data.addr);
                return 0;
            }
            else
            {
                ptmp = ptmp->pnext;
            }
        }
        printf("查无此人!\n");
        return -1;
    }
}

int DestroyHashTable()
{
    HASH_NODE *ptmp = NULL;
    HASH_NODE *pfree = NULL;

    int addr = 0;
    for (addr =0; addr < HASH_SIZE; ++addr)
    {
        if (IsEmpty(addr))
        {
            continue;
        }
        ptmp = hash_table[addr];
        while (ptmp != NULL)
        {
            pfree = ptmp;
            ptmp = ptmp->pnext;
            free(pfree);
        }
    }
}

hash.h

#ifndef _HASH_H
#define _HASH_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define HASH_SIZE 27

typedef struct per
{
    char name[32];
    char tel[32];
    char addr[64];
}DATA_TYPE;

typedef struct hasnode
{
    DATA_TYPE data;
    struct hasnode *pnext;
}HASH_NODE;

extern int HashFun(char ch);
extern int IsEmpty(int addr);
extern int InsertHashTable(DATA_TYPE data);
extern void SearchAll();
extern int SearchInHashTable(char *tmpname);
extern int DestroyHashTable();


#endif

算法

解决特定问题求解步骤

算法的设计

1、正确性

        语法正确

        合法的输入能得到合理的结果

        对非法的输入，给出满足要求的规格说明；对精心选择，甚至刁难的测试都能正常运行，结果正确

2、可读性

        便于交流，阅读，理解，高内聚，低耦合

3、健壮性

        输入非法数据，能进行相应的处理，而不是产生异常

4、高效率

        时间复杂度

        执行这个算法所花时间的度量

将数据量增长和时间增长用函数表示出来，这个函数就叫做时间复杂度

一般用大O表示法：O(n) —— 时间复杂度是关于数据n的一个函数，随着n的增加，时间复杂度增长较慢的算法时间复杂度低

时间复杂度的计算规则

        1，用常数1 取代运行时间中的所有加法常数

        2，在修改后的运行函数中，只保留最高阶项。

        3，如果最高阶存在且系数不是1，则去除这个项相乘的常数。

5、低储存

         空间复杂度

7.25！
关注
算法：哈希表
uncle_ll的博客
03-25 2664
哈希表简介 哈希表：也叫做散列表。是根据关键字和值（Key-Value）直接进行访问的数据结构。也就是说，它通过关键字 key 和一个映射函数 Hash(key) 计算出对应的值 value，然后把键值对映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数（散列函数），用于存放记录的数组叫做 哈希表（散列表）。 哈希表的关键思想是使用哈希函数，将键 key 和值 value 映射到对应表的某个区块中。可以将算法思想分为两个部分： 向哈希表中插入一个关键字：哈希函数决定该关键字的对应值应
哈希存储、哈希表原理
热门推荐
dta0502的博客
06-29 1万+
哈希表的定义哈希存储的基本思想是以关键字Key为自变量，通过一定的函数关系（散列函数或哈希函数），计算出对应的函数值（哈希地址），以这个值作为数据元素的地址，并将数据元素存入到相应地址的存储单元中。查找时再根据要查找的关键字采用同样的函数计算出哈希地址，然后直接到相应的存储单元中去取要找的数据元素即可。哈希表的应用哈希表(hash table)是实现字典操作的一种有效的数据结构。尽管最坏的情况下，...
哈希表的常用操作
y_s_c_的博客
12-13 848
import java.util.HashMap; public class HashTableUse { //java是HashMap,python是字典，是键值对，是key-value //key通过哈希函数，确定一块内存地址，存放key/value //哈希碰撞：不同key，通过哈希函数得到同一个内存地址，通过链表的方法，将后一个key/value链在上一个key/value后面，是另一块内存地址，通过next指针链接 public static void main(
哈希存储
04-26 729
哈希简单的说就是一种映射，它将很大定义域的值映射到一个相对较小的值域内。      通常用Hash是为了便于判断一个元素是否属于某集合。所以它支持创建Hash表时的INSERT操作，判断是否存在查找时的SEARCH操作，以及删除元素DELETE操作。     如果你的集合元素个数与全集元素个数差不多，还是用数组吧。Hash一般将大集合映射到小集合中，所以会有碰撞(Collision)，这时，可
Java 哈希表的常用操作
weixin_39394671的博客
02-20 1296
1.创建哈希表 创建哈希表有两种方式：数组；HashMap //数组,索引作为key值 String[] hashTable = new String[4]; //HashMap HashMap<Integer,String> map = new HashMap<>(); 2.添加元素 //数组 hashTable[1] = "hanmeimei"; hashTable[2] = "lihua"; hashTable[3] = "siyangyuan"; //HashMap
哈希表的一些基本操作
as14569852的博客
07-05 782
1.线性探测之平方探测法 #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ typedef int ElementType; /* 关键词类型用整型 */ typedef int Index; /* 散列地址类型 */ typedef Index Position; /* 数据所在位置与散列地址是同一类型 */ /* 散
哈希表的基本算法。
ymk1507050118的博客
07-31 567
今天我来分享一下有关哈希的基本算法。 1.首先哈希就相当于分类。这种存储机构通过某种函数时元素的存储位置与它的关键词之前能够建立一一映射的关系，那么在查找时通过该函数可以快速找到该元素。 2.同时在哈希中，会出现一种哈希冲突的情况。处理哈希冲突有线性探测、二次探测。 3.闭散列代码： //闭散列。 #pragma once #include&lt;stdio.h&gt; #includ...
哈希表的基本操作
如故的博客
05-20 3564
哈希表 若关键字为k，则其值存放在f(k)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f()为散列函数，按这个思想建立的表为散列表(即哈希表). 对不同的关键字可能得到同一散列地址，即k1≠k2，而f(k1)=f(k2) 这种现象称为碰撞 散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位. 散列函数有很多种 常用的有: 直接...
哈希表基本概念.docx
05-08
### 哈希表基本概念 #### 一、哈希表定义 哈希表（Hash Table），也称为散列表或哈希映射，是一种高效的数据结构，它通过使用哈希函数将键（Key）映射到桶（Bucket）的数组索引来实现数据的快速查找、插入和删除...
hash_basic.rar_hash表_哈希搜索_哈希表 基本操作
09-24
在"hash_basic"中，可能涵盖了以上这些概念的实现，包括具体的算法细节和代码示例，帮助初学者更好地理解和掌握哈希表的基本操作。通过实际操作和练习，你可以加深对哈希表的理解，并运用到实际的编程项目中。
哈希表哈希表哈希表.zip
05-29
哈希表的核心原理是利用哈希函数将关键字转化为数组的索引，使得在平均情况下，查找、插入和删除操作的时间复杂度可以达到O(1)。 哈希函数是哈希表的关键组成部分，它的主要任务是将输入的关键字转换为数组的下标。...
hash.rar_HASH算法_fpga hash_hash_zebra85v_哈希表Verilog
07-14
标题中的“hash.rar_HASH算法_fpga hash_hash_zebra85v_哈希表Verilog”揭示了这个压缩包文件的主要内容，它涉及到哈希（Hash）算法在高速Field-Programmable Gate Array（FPGA）上的实现，以及与Zebra85v硬件平台和...
哈希表操作
rj2017211811的博客
11-25 214
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;conio.h&gt; #define HASHTABLE_LINE 1000 typedef int ElemType; typedef struct hashNode { ElemType site; ElemType key; struct...
哈希表基本操作
steph_curry的博客
01-01 346
#include using namespace std; #define TABLESIZE 12 #define NULLKEY -32768 struct HashTable { int *elem;//数据元素的基址，动态分配数组 int count; }; //哈希表初始化 int InitHashTable(HashTable *H) { H->count=TABLESIZE;
哈希表及其操作
坚持是一种品质
10-17 1089
哈希表 定义： 一般的查找都是基于比较的，其关键字和在结构中的位置是没有确定的对应关系的，查找的效率依赖于比较的次数。 理想的情况是，每个记录的关键字和其在结构中的位置是有确定的关系的，就像是函数的变量和因变量一样，对于每一个KK，有一个f(K)f(K)与之对应。这样我们在查找时候就可以根据给定的关键字K而直接找到其对应的镜像。此时，我们称这个对应关系ff为哈希函数，按这个思想建立的表称
哈希表存储
w75779的博客
05-15 2506
哈希表最常见的存储结构有两种：开放寻址法、拉链法。 通常的映射方式为对一个数取模，这种方法很可能会将两个不同的数映射为一个相同的数，我们把这称为冲突。开放寻址法、拉链法就是两种处理冲突的方法。 较为简单方式----拉链法 const int N=10003; int h[N]; int val[N],ne[N],idx; 开一个一维数组存储所有的哈希值 void insert(int x) { int k=(x%N+N)%N;//使变为正数 val[idx]=x; ne[id
B站宋红康JAVA基础视频教程（chapter14数据结构与集合源码）
最新发布
qq_61033357的博客
09-14 1061
当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容，默认扩容为原来长度的1.5倍，并将原有数组中的元素赋值到新数组中。当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容，默认扩容为原来长度的1.5倍，并将原有数组中的元素赋值到新数组中。当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容，默认扩容为原来长度的2倍，并将原有数组中的元素赋值到新数组中。所有的value是可重复，无序的。实现List接口，存储有序的，可以重复的数据。
哈希表优化：区间表快速查找算法
"区间表的快速查找算法通过应用哈希表提高效率" 区间表的查找算法在数据处理领域是一项基础而重要的任务，特别是在处理大量数据时，高效的查找算法能显著提升系统的性能。通常，对于较小规模的数据和少量查找需求，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值