哈希表查找代码实现

最新推荐文章于 2024-09-26 21:15:55 发布
最新推荐文章于 2024-09-26 21:15:55 发布
阅读量8.5k 收藏 43
点赞数 8
分类专栏： 数据结构 文章标签： 散列表的实现 线性探测 二次探测 链地址法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35644234/article/details/68068293
版权

前言

博客编写人：Willam
博客编写时间：2017/3/29
博主邮箱：2930526477@qq.com（有志同道合之人，可以加qq交流交流编程心得）

1、代码实现的介绍

下面我将会实现哈希表的查找代码：
其中我会采取的散列构造函数为最常用的构造函数：除留取余数法
而解决冲突的方法采用以下三种，分别实现：

  1. 线性探测
  2. 二次探测
  3. 链地址法

如果需要了解哈希表的详细介绍，可参考博客：哈希表的详解

2、线性探测的实现

  • linear.h文件的代码
/************************************************************/
/*                程序作者：Willam                          */
/*                程序完成时间：2017/3/29                  */
/*                有任何问题请联系：2930526477@qq.com       */
/************************************************************/
//@尽量写出完美的程序


//#pragma once是一个比较常用的C/C++杂注，
//只要在头文件的最开始加入这条杂注，
//就能够保证头文件只被编译一次。
#ifndef   MY_H_FILE       //如果没有定义这个宏  
#define   MY_H_FILE       //定义这个宏  

#include<iostream>
using namespace std;
typedef int Keytype;

//每次都是取质数最接近的质数

struct Hash {
    Keytype * elem; //记录哈希表中的元素
    bool * isfull;  //记录哈希表是否有元素了
    int count;      //哈希表中元素的个数
    int sizeindex;

};

bool searchHash(Hash t, Keytype k, int & p, int &c,int * hashsize);
bool insertHash(Hash & t, Keytype k, int * hashsize);
bool DeleteHash(Hash & t, Keytype k, int * hashsize);
void print(Hash  t, int * hashsize);

#endif
  • linear.cpp文件的代码
#include"linear.h"


//查找对应的关键字
bool searchHash(Hash t, Keytype k, int & p,int &c,int * hashsize) {
    p = k%hashsize[t.sizeindex];
    while (t.isfull[p] && t.elem[p] != k && c < hashsize[t.sizeindex]-1) {
        ++c;
        //继续往下寻找下一个散列结点
        p=(k+c) % hashsize[t.sizeindex];
    }
    if (t.elem[p] == k) {
        return true;
    }
    return false;

}




bool insertHash(Hash & t, Keytype k, int * hashsize) {
    int p;
    int c = 0;
    if (searchHash(t, k, p,c,hashsize)) {
        return false;
    }
    else if (c==hashsize[t.sizeindex]-1) {//此时哈希表已经满，得重新分配了
        //首先是把之前的内容保存起来
        int temp;
        temp=hashsize[t.sizeindex];
        Keytype * elem = new Keytype[hashsize[t.sizeindex]];
        bool * isfull=new bool[hashsize[t.sizeindex]];
        for (int i = 0; i < hashsize[t.sizeindex]; ++i) {
            elem[i] = t.elem[i];
            isfull[i] = t.isfull[i];
        }
        delete t.elem;
        delete t.isfull;
        ++t.sizeindex;
        //重新分配空间
        t.elem= new Keytype[hashsize[t.sizeindex]];
        t.isfull=new bool[hashsize[t.sizeindex]];
        int i;
        for (i = 0; i < temp; ++i) {
             t.elem[i]=elem[i];
             t.isfull[i] = isfull[i];
        }
        for (; i < hashsize[t.sizeindex]; ++i) {
            t.isfull[i] = false;
        }
    }
    else {
        //cout << p << endl;
        //直接插入对应的位置
        t.elem[p] = k;
        ++t.count;
        t.isfull[p] = true;
    }

}

bool DeleteHash(Hash & t, Keytype k, int * hashsize) {
    int p;
    int c = 0;
    if (!searchHash(t, k, p, c,hashsize)) {//没找到要删除的元素
        return false;
    }
    else {
        t.isfull[p] = false;
        --t.count;
    }
}

void print(Hash t, int * hashsize) {
    cout << "当前的表的长度：" << hashsize[t.sizeindex] << endl;
    cout << "Hash表的元素个数为：" << t.count << endl;
    cout << "打印整个表：" << endl;
    for (int i = 0; i < hashsize[t.sizeindex]; ++i) {
        if(t.isfull[i])
        cout << t.elem[i] << " ";
        else {
            cout << "^" << " ";
        }
    }
    cout << endl;
}
  • main.cpp文件的代码
#include"linear.h"
int hashsize[]={ 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457,
461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593,
599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719,
727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857,
859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };
int main() {
    Hash t;
    t.count = 0;
    t.sizeindex = 0;
    t.elem = new Keytype[hashsize[t.sizeindex]];
    t.isfull = new bool[hashsize[t.sizeindex]];
    cout << "请先输入10个数" << endl;
    for (int i = 0; i < hashsize[t.sizeindex]; ++i) {
            t.isfull[i] = false;
    }

    for (int i = 0; i < 10; ++i) {
        int temp;
        cin >> temp;
        insertHash(t,temp,hashsize);
        //print(t, hashsize);
    }
    print(t,hashsize);
    cout << "输入需要查找的数：" << endl;
    int key;
    cin >> key;
    int p;
    int c = 0;
    if (searchHash(t, key,p,c, hashsize)) {
        cout << "查找成功" << endl;
        cout << "为第" << p+1 << "个元素" << endl;
    }
    else {
        cout << "查找失败" << endl;
    }
    cout << "输入需要删除的数：" << endl;

    cin >> key;
    if (DeleteHash(t, key, hashsize)) {
        cout << "删除成功，删除后的结果：" << endl;
        print(t, hashsize);
    }
    else {
        cout << "删除失败" << endl;
    }

    system("pause");
    return 0;
}

输入：

12 67 56 16 25 37 22 29 15 47
16
15

输出：
这里写图片描述

3、二次探测的实现

对于二次探测，其实它和线性探测的插入删除代码都是一样的，只是查找过程中单位的移动量不同，所以我们只要修改对应的查找函数就可以了，修改成如下：

//查找对应的关键字
bool searchHash(Hash t, Keytype k, int & p,int &c,int * hashsize) {
    p = k%hashsize[t.sizeindex];
    while (t.isfull[p] && t.elem[p] != k && c < hashsize[t.sizeindex]-1) {

        //++c;
        //二次探测和线性探测的区别
        if (c == 0) {
            c=1;
            p = (k + c) % hashsize[t.sizeindex];
        }
        else if (c > 0) {
            c = -c;
            p = (k - c*c) % hashsize[t.sizeindex];
        }
        else if (c < 0) {
            c = -c + 1;
            p = (k + c*c) % hashsize[t.sizeindex];
        }
        //继续往下寻找下一个散列结点
    }
    if (t.elem[p] == k) {
        return true;
    }
    return false;

}

输入：

12 67 56 16 25 37 22 29 15 47
67
12

输出：
这里写图片描述

4、链地址法的实现

  • List.h文件的代码
#pragma once
/************************************************************/
/*                程序作者：Willam                          */
/*                程序完成时间：2017/3/29                  */
/*                有任何问题请联系：2930526477@qq.com       */
/************************************************************/
//@尽量写出完美的程序


//#pragma once是一个比较常用的C/C++杂注，
//只要在头文件的最开始加入这条杂注，
//就能够保证头文件只被编译一次。


#include<iostream>
using namespace std;
typedef int Keytype;

struct Node {
    Keytype data; //每个结点的值
    Node * next;  //下一个结点
    Node() {
        next = NULL;
    }
};


//每次都是取质数最接近的质数
struct Hash {
    Node * elem; //头结点链表
    int sizeindex;

};

bool searchHash(Hash t, Keytype k, Node* & p, Node * & pre, int * hashsize);
bool insertHash(Hash & t, Keytype k, int * hashsize);
bool DeleteHash(Hash & t, Keytype k, int * hashsize);
void print(Hash  t, int * hashsize);
  • List.cpp文件的代码
#include"List.h"
bool searchHash(Hash t, Keytype k, Node * & p, Node * & pre, int * hashsize) {

    int index = k%hashsize[t.sizeindex];
    Node * head = t.elem[index].next;
    pre = NULL;
    while (head) 
    {//变量整个结点
        p = head;
        if (head->data == k) {
            return true;
        }
        pre = head;
        head = head->next;
    }
    return false;
}


//插入
bool insertHash(Hash & t, Keytype k, int * hashsize) {
    Node * p;
    Node * pre;
    if (searchHash(t, k, p,pre, hashsize)) {
        return false;
    }
    else {
        Node * s = new Node;
        s->data = k;
        if (pre == NULL) {
            int index = k%hashsize[t.sizeindex];
            t.elem[index].next = s;
            return true;
        }
        p->next = s;
    }
    return true;
}

//删除结点
bool DeleteHash(Hash & t, Keytype k, int * hashsize) {
    Node * p;
    Node * pre;
    if (!searchHash(t, k, p,pre,hashsize)) {
        return false;
    }
    else {
        if (pre == NULL) {
            int index = k%hashsize[t.sizeindex];
            t.elem[index].next =p->next;
            return true;
        }
        else {
            pre->next = p->next;
            delete p;
        }
    }
    return true;
}

void print(Hash  t, int * hashsize) {
    Node * p;
    for (int i = 0; i < hashsize[t.sizeindex]; ++i) {
        cout << i << " ";
        p = t.elem[i].next;
        while (p) {
            cout << p->data << " ";
            p = p->next;
        }
        cout << "^" << endl;
    }
}
  • main.cpp文件的代码
#include"list.h"
int hashsize[]={ 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457,
461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593,
599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719,
727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857,
859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };
int main() {
    Hash t;
    t.sizeindex = 0;
    t.elem = new Node[hashsize[t.sizeindex]];
    cout << "请先输入10个数" << endl;
    for (int i = 0; i < hashsize[t.sizeindex]; ++i) {
        t.elem[i].next = NULL;
    }

    for (int i = 0; i < 10; ++i) {
        int temp;
        cin >> temp;
        insertHash(t,temp,hashsize);
        //print(t, hashsize);
    }
    print(t,hashsize);


    cout << "输入需要查找的数：" << endl;
    int key;
    cin >> key;
    Node *p;
    Node *pre;
    int c = 0;
    if (searchHash(t, key,p,pre, hashsize)) {
        cout << "查找成功" << endl;
        cout <<  p->data  << endl;
    }
    else {
        cout << "查找失败" << endl;
    }
    cout << "输入需要删除的数：" << endl;

    cin >> key;
    if (DeleteHash(t, key, hashsize)) {
        cout << "删除成功，删除后的结果：" << endl;
        print(t, hashsize);
    }
    else {
        cout << "删除失败" << endl;
    }

    system("pause");
    return 0;
}

输入：

12 67 56 16 25 37 22 29 15 47
29
29

输出：
这里写图片描述

Ouyang_Lianjun
关注
专栏目录
哈希表(理论剖析+代码实现)
修行的凡人的博客
10-16 4111
基于著名书籍和自我研究得出的哈希表理论剖析与代码实现
用哈希表查找的源代码
07-15
用哈希表进行查找的代码，数据结构中创建哈希表，解决冲突等等
突破编程_C++_查找算法（哈希查找）
突破编程
03-22 928
C++ 查找算法：哈希查找
哈希查找算法
最新发布
灰灰老师
09-26 990
②数据量够大的时候，空间浪费足够小，因为d(i)是我们自定义的，平方数越大索引计算出来的位置间隔越大，产生数据冲突的可能性越小，同时也就会留下更多的空隙，那就是牺牲了一部分空间来换取了很小的冲突，说白了就是牺牲空间换取时间的做法。(2): d(i) = 1²，2²，3²，4²,....,或者d(i) = -1²，-2²，-3²，-4².....，这种取法称为平方探测法。举例：通讯录找人，第一步找z，赵、张--->肉眼去看“张”这个字 ---->点开“张三”这个人，然后你就看到了他的电话号码。
数据结构-哈希查找（代码实现注释超详细哦）
a15929748502的博客
05-16 7037
哈希查找（代码实现 注释超详细哦） 什么是理想的哈希表呢。哈希表（通常用数组来存放这张表）中记录的存储位置和他的关键字之间有一个确定的对应关系f(key),这就是哈希函数，常见的哈希函数； 直接定制法，除留余数法 它使每一个关键字和结构中唯一一个存储位置相对应。因而查找时可以根据f(key)算出要查找关键字的位置，达到快速查找的目的（不需要比较查找效率可达到O（1））。但是这是一种很理想...
散列表查找（哈希表）的基本操作 （完整代码）
fengyanglian的博客
11-05 7286
表和二叉树的排序，是利用元素之间的关系，逐个查找，或按一定的规律查找。 而散列表（哈希表），元素之间没有关系，它是利用了元素与存储地址之间的关系。 说白了，就是利用散列函数建立 元素->地址 的映射，然后在我们建立的结构体中，利用数组存储 地址->元素 的关系，来了个数据，用散列函数算一下他的地址，然后去数组里看看是不是这个元素，是就找到了，不是的话就拜拜了。 当然这里有一个地址冲突的问题，是
哈希表查找(C语言实现)
Touch的博客
06-15 2292
/* * 题目：给定一个全部由字符串组成的字典，字符串全部由大写字母构成。其中为每个字符串编写密码，编写的 * 方式是对于 n 位字符串，给定一个 n 位数，大写字母与数字的对应方式按照电话键盘的方式： * 2: A,B,C 5: J,K,L 8: T,U,V * 3: D,E,F 6: M,N,O 9: W,...
chazhao.rar_哈希表_哈希表 查找
09-21
在压缩包内的文件"查找"可能包含了关于如何实现哈希表查找的具体代码或示例，这些示例可以帮助你深入理解哈希表查找的过程和线性探测的实现细节。通过学习这部分内容，你可以更好地掌握哈希表这一重要的数据结构，...
哈希表实验C语言版实现
09-05
哈希表是一种高效的数据结构，它通过特定的哈希函数将键（Key）映射到一个固定大小的数组中，从而实现快速的插入、查找和删除操作。在本实验中，哈希表的C语言实现主要涉及以下几个核心知识点： 1. **哈希表的基本...
hashtab2_C语言_哈希表删除、添加、寻找_codeblocks_
10-04
哈希表是一种高效的数据结构，它通过特定的函数（哈希函数）将数据映射到一个固定大小的数组中，以此实现快速的查找、插入和删除操作。在C语言中，我们可以手动构建哈希表来处理这些操作。Code::Blocks是一款流行的...
哈希表查找
04-22
//待存入表格数据 char *key_input[] = { "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while" }; char *key_help_temp[] = { "auto function", "break function", "case function", "char function", "const function", "continue function", "default function", "do function", "double function", "else function", "enum function", "extern function", "float function", "for function", "goto function", "if function", "int function", "long function", "register function", "return function", "short function", "signed function", "sizeof function", "static function", "struct function", "switch function", "typedef function", "union function", "unsigned function", "void function", "volatile function", "while function" }; //功能：输入一个C语言关键字，快速提示这个关键字的功能及用法
数据结构哈希表查找算法
03-14
哈希表算法实现的C语言源程序 数据结构课程设计用
哈希表生成及哈希查找算法
09-09
输入：待哈希数据序列 功能要求：输出哈希方法和解决冲突的方法（文字输出），输出哈希表
哈希（Hash）算法，用哈希表进行查找
laoKdx的博客
07-25 2916
本文为哈希查找的C语言实现方法
数据结构和算法系列13 五大查找之哈希查找
weixin_30670965的博客
09-01 217
这一篇要总结的是五天查找的最后一篇，哈希查找，也称为散列查找(本文以哈希称呼)。提起哈希，我的第一印象就是C#中的Hashtable类，它是由一组key/value的键值对组成的集合，它就是应用了散列技术。 那么，什么是哈希查找呢？在弄清楚什么是哈希查找之前，我们要弄清楚哈希技术，哈希技术是在记录的存储位置和记录的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置...
【数据结构与算法】【查找】哈希表的代码实现
木名的专栏
10-28 5277
散列表
哈希表简述+常用算法代码
icc_hhy的博客
05-25 613
数组的特点：访问地址、数据容易，但删除和插入困难；而链表的特点：寻找地址困难，二插入和删除容易；是否有可能取其精华，构造出一种二者优势兼具的数据结构呢？这便是哈希表。
C语言-哈希查找(HASH)-详解（完整代码）
热门推荐
细雨青峦的博客
09-04 2万+
目录 原理： 实例解释 存储逻辑图 需要的知识： 附加 完整代码 代码详解 执行结果 1.查找个不存在的 2.查找个存在的 原理： 用一个指针数组，来存储 每个链表的头节点 的首地址 如果要从 'NUM' 个数中查找数据 先对'NUM'/0.75,求得最大质数'N' //(质数：只能被1和本身整除的数) 然后创建一个有'N'个元素的'指针数组' 然后将'NUM'个数分别对'N'取余 将每一个数保存在'余数'等于数组元素下标的链表中 然后进行查找是直接找对应的数组...
哈希表实现查找功能的C语言代码
"该代码示例展示了如何使用哈希表进行查找操作，特别是在数据结构中创建和管理哈希表，并处理可能出现的冲突问题。这里定义了两个结构体，`old` 和 `hx`，分别代表旧的哈希表结构和新的哈希表结构。输入函数 `...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值