散列表冲突解决方法11.1.3

最新推荐文章于 2023-12-05 19:45:00 发布
最新推荐文章于 2023-12-05 19:45:00 发布
阅读量448 收藏
点赞数 2
分类专栏： 数据结构

常用的解决思路：
1、换个位置：开放定址法
开放定地法
数组结构

    #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */
    typedef int ElementType;    /* 关键词类型用整型 */
    typedef int Index;          /* 散列地址类型 */
    typedef Index Position;     /* 数据所在位置与散列地址是同一类型 */
    /* 散列单元状态类型，分别对应：有合法元素、空单元、有已删除元素 */
    typedef enum { Legitimate, Empty, Deleted } EntryType;

    typedef struct HashEntry Cell; /* 散列表单元类型 */
    struct HashEntry{
        ElementType Data; /* 存放元素 */
        EntryType Info;   /* 单元状态 */
    };

    typedef struct TblNode *HashTable; /* 散列表类型 */
    struct TblNode {   /* 散列表结点定义 */
        int TableSize; /* 表的最大长度 */
        Cell *Cells;   /* 存放散列单元数据的数组 */
    };

    int NextPrime( int N )
    { /* 返回大于N且不超过MAXTABLESIZE的最小素数 */
        int i, p = (N%2)? N+2 : N+1; /*从大于N的下一个奇数开始 */

        while( p <= MAXTABLESIZE ) {
            for( i=(int)sqrt(p); i>2; i-- )
                if ( !(p%i) ) break; /* p不是素数 */
            if ( i==2 ) break; /* for正常结束，说明p是素数 */
            else  p += 2; /* 否则试探下一个奇数 */
        }
        return p;
    }

    HashTable CreateTable( int TableSize )
    {
        HashTable H;
        int i;

        H = (HashTable)malloc(sizeof(struct TblNode));
        /* 保证散列表最大长度是素数 */
        H->TableSize = NextPrime(TableSize);
        /* 声明单元数组 */
        H->Cells = (Cell *)malloc(H->TableSize*sizeof(Cell));
        /* 初始化单元状态为“空单元” */
        for( i=0; i<H->TableSize; i++ )
            H->Cells[i].Info = Empty;

        return H;
    }

2、同一位置的冲突对象组织在一起：链地址法
数组+链表的结构

#define KEYLENGTH 15                   /* 关键词字符串的最大长度 */
typedef char ElementType[KEYLENGTH+1]; /* 关键词类型用字符串 */
typedef int Index;                     /* 散列地址类型 */
/******** 以下是单链表的定义 ********/
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
/******** 以上是单链表的定义 ********/

typedef struct TblNode *HashTable; /* 散列表类型 */
struct TblNode {   /* 散列表结点定义 */
    int TableSize; /* 表的最大长度 */
    List Heads;    /* 指向链表头结点的数组 */
};

平方探测法的c语言完整实现：

    #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */
    typedef int ElementType;    /* 关键词类型用整型 */
    typedef int Index;          /* 散列地址类型 */
    typedef Index Position;     /* 数据所在位置与散列地址是同一类型 */
    /* 散列单元状态类型，分别对应：有合法元素、空单元、有已删除元素 */
    typedef enum { Legitimate, Empty, Deleted } EntryType;

    typedef struct HashEntry Cell; /* 散列表单元类型 */
    struct HashEntry{
        ElementType Data; /* 存放元素 */
        EntryType Info;   /* 单元状态 */
    };

    typedef struct TblNode *HashTable; /* 散列表类型 */
    struct TblNode {   /* 散列表结点定义 */
        int TableSize; /* 表的最大长度 */
        Cell *Cells;   /* 存放散列单元数据的数组 */
    };

    int NextPrime( int N )
    { /* 返回大于N且不超过MAXTABLESIZE的最小素数 */
        int i, p = (N%2)? N+2 : N+1; /*从大于N的下一个奇数开始 */

        while( p <= MAXTABLESIZE ) {
            for( i=(int)sqrt(p); i>2; i-- )
                if ( !(p%i) ) break; /* p不是素数 */
            if ( i==2 ) break; /* for正常结束，说明p是素数 */
            else  p += 2; /* 否则试探下一个奇数 */
        }
        return p;
    }

    HashTable CreateTable( int TableSize )
    {
        HashTable H;
        int i;

        H = (HashTable)malloc(sizeof(struct TblNode));
        /* 保证散列表最大长度是素数 */
        H->TableSize = NextPrime(TableSize);
        /* 声明单元数组 */
        H->Cells = (Cell *)malloc(H->TableSize*sizeof(Cell));
        /* 初始化单元状态为“空单元” */
        for( i=0; i<H->TableSize; i++ )
            H->Cells[i].Info = Empty;

        return H;
    }
        Position Find( HashTable H, ElementType Key )
    {
        Position CurrentPos, NewPos;
        int CNum = 0; /* 记录冲突次数 */

        NewPos = CurrentPos = Hash( Key, H->TableSize ); /* 初始散列位置 */
        /* 当该位置的单元非空，并且不是要找的元素时，发生冲突 */
        while( H->Cells[NewPos].Info!=Empty && H->Cells[NewPos].Data!=Key ) {
                                               /* 字符串类型的关键词需要 strcmp 函数!! */
            /* 统计1次冲突，并判断奇偶次 */
            if( ++CNum%2 ){ /* 奇数次冲突 */
                NewPos = CurrentPos + (CNum+1)*(CNum+1)/4; /* 增量为+[(CNum+1)/2]^2 */
                if ( NewPos >= H->TableSize )
                    NewPos = NewPos % H->TableSize; /* 调整为合法地址 */
            }
            else { /* 偶数次冲突 */
                NewPos = CurrentPos - CNum*CNum/4; /* 增量为-(CNum/2)^2 */
                while( NewPos < 0 )
                    NewPos += H->TableSize; /* 调整为合法地址 */
            }
        }
        return NewPos; /* 此时NewPos或者是Key的位置，或者是一个空单元的位置（表示找不到）*/
    }

    bool Insert( HashTable H, ElementType Key )
    {
        Position Pos = Find( H, Key ); /* 先检查Key是否已经存在 */

        if( H->Cells[Pos].Info != Legitimate ) { /* 如果这个单元没有被占，说明Key可以插入在此 */
            H->Cells[Pos].Info = Legitimate;
            H->Cells[Pos].Data = Key;
            /*字符串类型的关键词需要 strcpy 函数!! */
            return true;
        }
        else {
            printf("键值已存在");
            return false;
        }
    }

链地址法的c语言完整实现

    #define KEYLENGTH 15                   /* 关键词字符串的最大长度 */
    typedef char ElementType[KEYLENGTH+1]; /* 关键词类型用字符串 */
    typedef int Index;                     /* 散列地址类型 */
    /******** 以下是单链表的定义 ********/
    typedef struct LNode *PtrToLNode;
    struct LNode {
        ElementType Data;
        PtrToLNode Next;
    };
    typedef PtrToLNode Position;
    typedef PtrToLNode List;
    /******** 以上是单链表的定义 ********/

    typedef struct TblNode *HashTable; /* 散列表类型 */
    struct TblNode {   /* 散列表结点定义 */
        int TableSize; /* 表的最大长度 */
        List Heads;    /* 指向链表头结点的数组 */
    };

    HashTable CreateTable( int TableSize )
    {
        HashTable H;
        int i;

        H = (HashTable)malloc(sizeof(struct TblNode));
        /* 保证散列表最大长度是素数，具体见代码5.3 */
        H->TableSize = NextPrime(TableSize);

        /* 以下分配链表头结点数组 */
        H->Heads = (List)malloc(H->TableSize*sizeof(struct LNode));
        /* 初始化表头结点 */
        for( i=0; i<H->TableSize; i++ ) {
             H->Heads[i].Data[0] = '\0';
             H->Heads[i].Next = NULL;
        }

        return H;
    }

    Position Find( HashTable H, ElementType Key )
    {
        Position P;
        Index Pos;

        Pos = Hash( Key, H->TableSize ); /* 初始散列位置 */
        P = H->Heads[Pos].Next; /* 从该链表的第1个结点开始 */
        /* 当未到表尾，并且Key未找到时 */ 
        while( P && strcmp(P->Data, Key) )
            P = P->Next;

        return P; /* 此时P或者指向找到的结点，或者为NULL */
    }

    bool Insert( HashTable H, ElementType Key )
    {
        Position P, NewCell;
        Index Pos;

        P = Find( H, Key );
        if ( !P ) { /* 关键词未找到，可以插入 */
            NewCell = (Position)malloc(sizeof(struct LNode));
            strcpy(NewCell->Data, Key);
            Pos = Hash( Key, H->TableSize ); /* 初始散列位置 */
            /* 将NewCell插入为H->Heads[Pos]链表的第1个结点 */
            NewCell->Next = H->Heads[Pos].Next;
            H->Heads[Pos].Next = NewCell; 
            return true;
        }
        else { /* 关键词已存在 */
            printf("键值已存在");
            return false;
        }
    }

    void DestroyTable( HashTable H )
    {
        int i;
        Position P, Tmp;

        /* 释放每个链表的结点 */
        for( i=0; i<H->TableSize; i++ ) {
            P = H->Heads[i].Next;
            while( P ) {
                Tmp = P->Next;
                free( P );
                P = Tmp;
            }
        }
        free( H->Heads ); /* 释放头结点数组 */
        free( H );        /* 释放散列表结点 */
    }
phoenix8956
关注
专栏目录
Python基础知识点总结
Python全栈系列
08-25 7万+
本文包括python基本知识：简单数据结构，数据结构类型（可变：列表，字典，集合，不可变：数值类型，字符串，元组），分支循环和控制流程，类和函数，文件处理和异常等等。
Java核心技术 卷I：基础知识
生息之地
03-03 834
第一章 Java程序设计概述 太简单了，直接略过。 1.2 Java“白皮书”的关键术语 简单性：指相对于C++简单（指针、多重继承等），但设计者也并没有试图清楚C++中所有不适当的特性 面向对象：java与C++主要不同在于多重集成，以及接口概念 网络技能 健壮性 安全性 体系结构中立 可移植性 解释性：过去Java解释器可以在任何移植了解释器的机器上执行java字节码，现在使用即使编译器将字节码再翻译成机器码 高性能 多线程 动态性 第二章 Java程序设计环境 我选择使用了JetBrainde I
散列表处理冲突的方法
CarmenIsOK的博客
02-23 3492
一、开放地址法 所谓的开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。 1.1 线性探测法 fi ( key ) = ( f ( key ) + di ) MOD m (di=1,2,3,4,…,m-1) 会出现不是同义词却需要争夺一个地址的情况，我们称这种情况为堆积。 1.2 二次探测法 关键字集合『12，67，56，16，25...
数据结构与算法-散列表冲突的解决办法
iamsongyu的博客
09-20 954
我们上文以字典作为例子，描述了散列表这种结构。 它以函数H（哈希函数）作为纽带，连接一对键值，通过H（键）计算得出数组的下标用于存储键值对。 它的优势是可以绑定键值，允许我们通过键来访问特定的值，并且寻找的复杂度不精准的来说是O（1）。 但是我们发现了问题，我们的数组是有限长度的，但是输入在某些情况下，不同的键可能会得到同样的下标，即产生了冲突。 如这两个图所示，键值1和存储之后，键值...
散列表的冲突处理方法
蒟蒻本蒻的博客
03-02 480
常用的处理方法： 开放定址法：按照某种规则取寻找另一空地址 链地址法：同一位置的冲突对象组织在一起 开放定址法 1.线性探测法 以增量序列1,2,3，……，（TableSize-1）循环试探下一个存储地址 可能会发生冲突聚集 2.平方探测法 以增量序列12,-12,22,-22，……，q2,-q2且q<=|TableSize/2|循环试探下一个存储地址 可能存在表中有空间，但是找不到的情况 为解决这个问题将TableSize设为4k+3形式的某个素数时，平方探测法可以找到整个表的空间 3.双散列探
散列表及散列冲突解决方案
yygr的博客
01-24 2305
https://blog.csdn.net/u010530712/article/details/93166430 1、散列表 看过HashMap源码的同学应该知道，HashMap是基于哈希表（散列表）的 Map 接口的非同步实现。 在我们put了一条key-value数据后，如下图，程序会先将key通过hash(key)这个函数转化成整形，这个整形做为数组的下标，插入数据或查找数据。 我们发现，散列
数据结构篇——散列表解决冲突的方法
handsomeRE的博客
12-01 854
数据结构篇——散列表解决冲突的方法
数据库系统实现
05-12
4.4.6 可扩展散列表的插入 4.4.7 线性散列表 4.4.8 线性散列表的插入 习题 4.5 小结 4.6 参考文献 第5章 多维索引 5.1 需要多维的应用 5.1.1 地理信息系统 5.1.2 数据立方体 5.1.3 SQL多维查询...
java理论
fanfan12138的博客
05-21 1505
目录 目录…1 JVM…19 2.1. 线程 …20 2.2. JVM 内存区域 …21 2.2.1. 程序计数器(线程私有)…22 2.2.2. 虚拟机栈(线程私有)…22 2.2.3. 本地方法区(线程私有)…23 2.2.4. 堆（Heap-线程共享）-运行时数据区 …23 2.2.5. 方法区/永久代（线程共享） …23 2.3. JVM 运行时内存 …24 2.3.1. 新生代 …24 2.3.1.1. Eden 区…24 2.3.1.2. ServivorFrom…24 2.3.1.3. Se.
重温Python基础知识点，又来重新巩固一遍
kakA的博客
02-21 3183
最近有很多朋友刚接触python学的还是有点模糊还有的朋友就是想重温一下基础内容，毕竟基础不牢地动山摇行吧，就总结了以下的一些知识点，可以都看看哈Python解释器下载/安装/环境配置/模块安装/解决pip下载模块慢pycharm安装/基本操作/快捷键等所有操作Python语言基本语法元素程序的格式框架，即段落格式，是Python语法的一部分，可以提高代码的可读性和可维护性。Python语言采用严格的缩进来表示程序逻辑。也就是我们所说的Python程序间的包含与层次关系。一般代码不要求缩进，顶行编写且不留空
散列表与散列冲突
01-08
目录 散列表与散列冲突 解决散列冲突的方法 1.分离链接法（拉链法） 2.开放寻址法 再散列 散列表与散列冲突 HashTable，音译为哈希表，是根据关键字（key）而直接进行访问的数据结构。关键字k，值存放在f(k)的存储位置上，则f为散列函数。关键字（key）通过散列函数直映射到表中一个位置，以加快查找速度。 散列冲突，因为存储单元数目是有限的，当关键字数量增大时，两个不同的关键字k1，k2可能会出现f(k1) == f(k2)，而关键字实际上是无限的，所以这种冲突不可避免。目前主流解决散列冲突的方式有两种：一种是开放寻址法，另一种是分裂链接法（拉链法）。 解决散列冲突的方法 1.分离链
解决散列表冲突方法
LishcCai的博客
03-26 1万+
1 解决冲突方法1.1 链接法又叫拉链法,将具有同一散列地址的记录存储在一条线性链表中1.2 开放定址法通过对原hash函数进行修改,添加探查函数,当出现冲突时,往下一个地址写数据图中p(i)为探查函数探查函数分为以下四种:        线性探查法:(p(i)为1,2,...,...n)        二次探查法        随机探查法:(p(i)为随机数)        双散列函数法使用开放...
数据结构中处理散列冲突的四种方法
最新发布
吴名氏的博客
12-05 4万+
数据结构中处理散列冲突的四种方法
处理散列冲突的方法
qq_44587855的博客
12-23 3031
1. 开放定址法 一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。 发生冲突，另寻他处 我们把这种解决冲突的方法称为线性探测法。 我们在解决冲突的时候，还会碰到比如说一个数 48， 它所在的位置已经被占用，它只能往后延，但是又与后面的冲突 ，本来两个数一点关系都没有，但是发生冲突，这种现象称为堆积， 堆积的出现使得我们需要不断处理冲突，即48要不...
java 解决Hash(散列)冲突的四种方法--开放定址法(线性探测,二次探测,伪随机探测)、链地址法、再哈希、建立公共溢出区
热门推荐
请叫我大师兄
08-21 4万+
一）哈希表简介 非哈希表的特点：关键字在表中的位置和它之间不存在一个确定的关系，查找的过程为给定值一次和各个关键字进行比较，查找的效率取决于和给定值进行比较的次数。     哈希表的特点：关键字在表中位置和它之间存在一种确定的关系。 哈希函数：一般情况下，需要在关键字与它在表中的存储位置之间建立一个函数关系，以f(key)作为关键字为key的记录在表中的位置，通常称这个函数f
散列表、常见散列函数及处理冲突的方法
薛定谔的猫的博客
11-24 3222
文章目录散列表的概念常见的散列函数处理冲突的方法处理冲突的开放地址法处理冲突的拉链法散列查找及性能分析 散列表的概念 散列法  散列法又称哈希法或杂凑法，它在元素的存储位置与元素关键码之间建立一个确定的对应函数关系Hash()，使得每个关键码与结构中的一个唯一的存储位置相对应： Address=Hash(key) Address = Hash(key)Address=Hash(key)  在插入时，依此函数计算存储位置并按此位置存放。  在查找时，对元素的关键码进行同样的函数计算，把求得的函数值当作元素的
数据结构—— 处理散列冲突的四种方法【开放定址法-再散列函数法-链地址法-公共溢出区法】
刘鑫磊
02-11 1万+
目录: 一：开放定址法 1.定义 2.要求 3.线性探测法 4.二次探测法 5.随机探测法 二：再散列函数法 1.散列函数 2.解释 3.优点弊端 A:优点 B:弊端 三：链地址法 1.定义 2.优点弊端 A:优点 B:弊端 四：公共溢出区法 一：开放定址法 1.定义 所谓的开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址 2.要...
项目团队管理：建设、冲突与激励
团队成员通常经过多方面的培训，能够熟练使用特定的工具和技能，以解决与这些工具和实践相关的问题。战术团队具有持久性，成员之间习惯于一起工作，并拥有明确定义和稳定的角色，这使得他们在处理复杂问题时能迅速...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值