精华内容
下载资源
问答
  • /为班级30个人的姓名设计一个哈希表,假设姓名用汉语拼音表示。要求用除留余数法 ...2、创建哈希表,将ASCII码取余得KEY值,若未发生冲突存入哈希表 3、发生冲突调用冲突函数。进行线性探测。最后存入哈希表。
  • 创建一个简单的哈希表

    千次阅读 2019-09-14 12:42:04
    class HashTable: def __init__(self, size): self.elem = [None for i in range(size)] # 使用list数据结构作为哈希表元素保存方法 self.count = size # 最大表长 def hash(self, key): return key...
    class HashTable:
        def __init__(self, size):
            self.elem = [None for i in range(size)]  # 使用list数据结构作为哈希表元素保存方法
            self.count = size  # 最大表长
     
        def hash(self, key):
            return key % self.count  # 散列函数采用除留余数法
     
        def insert_hash(self, key, value):
            """插入关键字到哈希表内"""
            address = self.hash(key)  # 求散列地址
            while self.elem[address]:  # 当前位置已经有数据了,发生冲突。
                address = (address + 1) % self.count  # 线性探测下一地址是否可用
            self.elem[address] = value  # 没有冲突则直接保存。
     
        def search_hash(self, key):
            """查找关键字,返回布尔值"""
            star = address = self.hash(key)
            while self.elem[address] != key:
                address = (address + 1) % self.count
                if not self.elem[address] or address == star:  # 说明没找到或者循环到了开始的位置
                    return False
            return True
    if __name__ =="__main__":     
         hash1=HashTable(7)
         hash1.insert_hash(1,11)
         hash1.insert_hash(2,12)
         hash1.insert_hash(3,13)
         hash1.insert_hash(4,14)
         print(hash1.search_hash(14))

     

    展开全文
  • 我们都知道,当我们要在一个集合中查找数据时,如果这个集合是顺序且我们能确定要找的数据在顺序中的位置的话,我们就能通过下标直接找到元素,这无非是我们要追求的最高效的查找策略!但是现实总是那么骨感,在...

    我们都知道,当我们要在一个集合中查找数据时,如果这个集合是顺序表且我们能确定要找的数据在顺序表中的位置的话,我们就能通过下标直接找到元素,这无非是我们要追求的最高效的查找策略!但是现实总是那么骨感,在大多数情况下,要在茫茫数据海洋中找某些关键信息,是不可能直接找到的。因为我们并不知道我们要找的数据与其所在位置之间是否存在某种关联。

    所以我们在存储数据时,建立如同顺序表形式的可以按照下标进行查找的存储集合,然后我们可以认为建立要存的关键信息和其在集合中的下标之间的关系,这样我们在找想找的信息时,就可以确定信息在集合中的下标了,这样就可实现较为高效的查找了。而我们所说的这个集合就称为哈希表,建立的下标与信息的关系可以通过哈希函数(自定义合理的函数)来实现。

    哈希表在查找,加密等很多方面都有广泛用途。
    今天我用拉链法建立了简单的哈希表其结构如图所示:
    在这里插入图片描述

    源码

    #include <iostream>
    #include<array>
    #include<memory>
    #include<string>
    #include<vector>
    using namespace std;
    
    class data{
    public :
        string name;
        int age;
        data(){
        }
        ~data(){}
    };
    class info:public data{
    
    public :
        vector<data>ls;
        info(){
        }
        ~info(){}
        static void init(array<shared_ptr<info>,27>&ss);
        static void input(array<shared_ptr<info>,27>&ss);
        static int getLoc(char a);;
        static void search(array<shared_ptr<info>,27>&ss);
    };
    
    void info::search(array<shared_ptr<info>,27>&ss){
    
        string name ;
        cin>>name ;
        int index = getLoc(name[0]);
        if(index==-1){
            cout<<"No the name"<<endl;
        }
        int i =0 ;
        int flag =1;
        for(i=0;i<(int)ss[index]->ls.size();i++){
            if(ss[index]->ls[i].name==name){
                flag =0;
                cout<<"The info of the person:"<<endl;
                cout<<" \nAge:"<<ss[index]->ls[i].age<<"      "<<"Name:"<<ss[index]->ls[i].name<<endl;
                break;
            }
        }
        if(flag ==1){
            cout<<"No the info"<<endl;
        }
    }
    int info::getLoc(char a){
        
                if(a>='A'&&a<='Z'){
                    return a-65;
                }
                 else if(a>='a'&&a<='z'){
                    return a-97;
                }
                else{
                    return -1;
            }
    }
    void info::input(array<shared_ptr<info>,27>&ss){
        string name ;
        cout<<"请输入姓名(由英文字符组成)和年龄 -1 to return..."<<endl;
        while(1){
            data dd;
            cin>>dd.name ;
            if(dd.name=="-1"){
                    break;
                }
            cin>>dd.age;
            //差试用一下lamda表达式
            auto key= [dd](){
                if(dd.name[0]>='A'&&dd.name[0]<='Z'){
                    return dd.name[0]-65;
                }
                 else if(dd.name[0]>='a'&&dd.name[0]<='z'){
                    return dd.name[0]-97;
                }
                else if(dd.name[0]==' '){
                    return 0;
                }
                else{
                    return -1;
            }
            };
            int index= key();
            if(index==-1){
                cout<<"The name is error!"<<endl;
                continue ;
            }
            ss[index]->ls.push_back(dd);
        }
    }
    void info::init(array<shared_ptr<info>,27>&ss){  
        int i;
        for(i=0;i<27;i++){
            shared_ptr<info>p(new info());
            ss[i]=p;
        }
    }
    int main()
    {
        array<shared_ptr<info>,27>ss;
        info::init(ss); 
        info::input(ss);
        info::search(ss);
        return 0;
    }
    

    这个程序刚开始创建了info类的指针数组,info类继承了data类,info类里面有个vector容器主要存data类数据信息的。举个例子吧,要是name首字母是A,根据key = (大写字母-65),则该data类所有信息就存在以下标为key的数组中的vector容器中,即ss[key].ls.push_back(含相应name关键字的对象),后面同样的实现方法。在找时只需根据name首字母将要搜索的范围缩小,然后只能一个个遍历vector容器了。程序总的逻辑
    很简单,使用拉链法,哈希冲突也比较容易解决。

    展开全文
  • 哈希表实现通讯录

    2018-01-23 12:11:22
    (1)每人的信息至少包括姓名,...(2)假设人名为汉语拼音全拼形式,待插入哈希表的长度为你所在班级的人数。哈希函数用除留余数法构造,采用链地址法或二次探测再散列法解决冲突。 (3)完成菜单设计。操作有必要的提示。
  • 哈希表支持基于文本或字符串输入数据的搜索,插入,删除,打印和整数哈希键创建。 在发生冲突的情况下,此单独的链接哈希表将使用单链接列表来存储重复的密钥。 样本输入 输入文件每行至少包含一个命令,即插入,...
  • 哈希表创建 (C语言(icoding

    千次阅读 2020-07-09 16:41:42
    哈希表创建 哈希表(Hash Table,也叫散列表),是根据键(Key)而直接访问在内存存储位置的数据结构。也就是说,它通过计算一个关于键值的函数,将所需查询的数据映射到表中一个位置来访问记录,这加快了查找速度。...

    哈希表创建

    哈希表(Hash Table,也叫散列表),是根据键(Key)而直接访问在内存存储位置的数据结构。也就是说,它通过计算一个关于键值的函数,将所需查询的数据映射到表中一个位置来访问记录,这加快了查找速度。这个映射函数称做哈希函数,存放记录的数组称做哈希表。哈希表相关定义如下:

    typedef enum{
        HASH_OK,
        HASH_ERROR,
        HASH_ADDED,
        HASH_REPLACED_VALUE,
        HASH_ALREADY_ADDED,
        HASH_DELETED,
        HASH_NOT_FOUND,
    } HASH_RESULT;
    
    typedef struct __HashEntry HashEntry;
    struct __HashEntry{
        union{
            char  *str_value;
            double dbl_value;
            int       int_value;
        } key;
        union{
            char  *str_value;
            double dbl_value;
            int       int_value;
            long   long_value;
            void  *ptr_value;
        } value;
        HashEntry *next;
    };
    
    struct __HashTable{
        HashEntry **bucket;        
        int size;
        HASH_RESULT last_error;
    };
    typedef struct __HashTable HashTable;
    
    // 创建大小为hash_size的哈希表,创建成功后返回HashTable类型的指针,否则返回NULL。
    HashTable *create_hash(int hash_size);
    哈希表相关说明:
    
    HASH_RESULT 类型为相关函数的返回类型
    HashEntry 为哈希表所保存元素(即键值对 《key, value》)类型
    HashTable 为哈希表,其中 bucket 指向大小为size的、元素类型为 HashEntry*的指针数组
    哈希表采用链地址法处理冲突
    请实现 create_hash 函数,创建指定大小的哈希表。
    

    答案

    #include “hash.h”
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

    HashTable* create_hash(int size)
    {
    HashTable* H;
    H = (HashTable*)malloc(1 * sizeof(HashTable));
    if (H == NULL)
    return NULL;
    H->bucket = (HashEntry**)malloc(size * sizeof(HashEntry*));
    if (H->bucket == NULL) {
    free(H);
    return NULL;
    }
    memset(H->bucket, 0, size * sizeof(HashEntry*));
    H->size = size;
    H->last_error = HASH_OK;
    return H;
    }

    展开全文
  • 哈希表创建

    千次阅读 2018-09-06 15:30:09
    哈希表的拉链法实现: 定义哈希表的定义链结点 #define HASHSIZE 10 typedef unsigned int uint; typedef struct Node{ const char* key; const char* value; Node *next; }Node; class HashTable{ p...

    2018.09.06

    代码块

    哈希表的拉链法实现:

    定义哈希表的定义链结点

    #define HASHSIZE 15
    typedef unsigned int uint;
    typedef struct Node{
        const char* key;
        const char* value;
        Node *next;
    }Node;
    
    class HashTable{
    private:
        Node* node[HASHSIZE];
    public:
        HashTable();
        uint hash(const char* key);
        Node* lookup(const char* key);
        bool install(const char* key,const char* value);
        const char* get(const char* key);
        void display();
    };
    
    HashTable::HashTable(){
        for (int i = 0; i < HASHSIZE; ++i)
        {
            node[i] = NULL;
        }
    }

    定义哈希表的Hash算法:time33算法(没找到什么理论可以说明这种算法的合理性,据说只是通过测试和实践发现这个算法是比较好的)

    uint HashTable::hash(const char* key){
        uint hash=0;
        for (; *key; ++key)
        {
            hash=hash*33+*key;
        }
        return hash%HASHSIZE;
    }

    哈希表的查找

    Node* HashTable::lookup(const char* key){
        Node *np;
        uint index;
        index = hash(key);
        for(np=node[index];np;np=np->next){
            if(!strcmp(key,np->key))
                return np;
        }
        return NULL;
    }

    插入一个新的结点,首先是查看该key值的结点是否存在,如果存在则更改value值就好,如果不存在,则插入新结点。

    bool HashTable::install(const char* key,const char* value){
        uint index;
        Node *np;
        if(!(np=lookup(key))){
            index = hash(key);
            np = (Node*)malloc(sizeof(Node));
            if(!np) return false;
            np->key=key;
            np->next = node[index];
            node[index] = np;
        }
        np->value=value;
        return true;
    }

    链地址法可以解决哈希冲突


    展开全文
  • 针对你所在班集体中的“人名”,设计一个哈希表,使得平均查找长度不超过R,完成相应的建表和查找过程。 设计要求: 1.每个人的信息至少包括姓名,电话,地址。至少包括对通讯录的创建,添加和按姓名查找等功能。 ...
  • 完整可运行代码,简单的取余来解决冲突,并分配空间,哈希表的容量可随时变化。
  • 使用哈希表创建哈希映射。 用Java编写。 要查看源代码,请输入 src/COP3530 此代码是为 DR 编写的。 MARK WEISS 在 FIU 的数据结构课程。 将本准则用于上述类别可能会带来严重后果。 如果您偶然发现了这一点,请...
  • 搜索引擎 目前只支持英文字母,即不支持Unicode 。 哈希表是从头开始实现的--- std::hash未使用--- ... 快速统计:该程序大约需要 4 秒钟来初始化哈希表,扫描大小约为 100 兆字节的文件并创建一个哈希表进行搜索。
  • 哈希表 Linux内核模块创建哈希表
  • 姓名哈希表

    千次阅读 多人点赞 2020-06-13 14:53:55
    /为班级30个人的姓名设计一个哈希表,...2、创建哈希表,将ASCII码取余得KEY值,若未发生冲突存入哈希表 3、发生冲突调用冲突函数。进行线性探测。最后存入哈希表。 #define HASH_SIZE 50//哈希表的长度 #define Name_S
  • 实现哈希表 查找 删除 创建和插入等
  • 哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现
  • #include<iostream> using namespace std; typedef int status; constexpr auto SUCCESS = 1; constexpr auto UNSUCCESS = 0; constexpr auto HASHSIZE = 12; constexpr auto NULLKEY = -...//哈希表结构的...
  • 使用python哈希表实现英语字典算法思想哈希表哈希函数冲突源码及分析数据源码源码解析 ...我们所用到的是开发定值法:构建哈希表先要创建哈希函数,常用的哈希函数方法为除留余数法: H(key)=key MOD
  • 在这一节,我们来编写哈希函数。
  • 第1关:哈希表初始化 本关任务:初始化哈希表满足下面要求。 将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中, ...编写一个能将键值插入哈希表的函数,要求按线性探测再散列法处理冲突) 头文件
  • 数据结构 创建二叉树和哈希表的代码
  • 哈希表-源码

    2021-02-11 10:07:46
    创建一个包含哈希的十六进制表示形式的字符串(在lowercsae中)以及文件的相对文件路径,类似于sha256sum的输出。 注意:字符串末尾有换行符。 3bf3e00bb30a0dde6f70167c5273bc455e0621053e02965733130002dabbc1a6 ....
  • //散列表(哈希表)的创建、初始化、插入与查找 #include<stdlib.h> #include<iostream> using namespace std; #define HASHSIZE 13 #define NULLKEY -32456 //哈希表初始化的值 //定义哈希表结构 ...
  • 一个键-值对(items)都会被保存在结构体中。
  • 数组也是有一定的缺点的,如果我们不知道某个元素的下标值,而只是知道该元素在数组中,这时我们想要获取该元素就只能对数组进行线性查找,即从头开始遍历,...所以,为了解决上述数组的不足之处,引入了哈希表的概念。
  • 也就是说,它通过把关键码值映射到一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。 给定M,存在函数f(key),对任意给定的关键字值key,代入函数后若能得到...
  • JavaScript创建哈希表

    千次阅读 2013-04-22 16:19:51
    本例通过JavaScript创建一个哈希表,学习如何保存数据字典(键/值对)。 【实现代码】 标题页 //自定义哈希表类 function Hashtable() { this._hash = new Object(); // 创建Object对象 //哈希表的添加...
  • 哈希表java实现

    千次阅读 2020-06-10 17:36:33
    哈希表一、基本概念二、代码实现 一、基本概念 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的...
  • Common Lisp中对哈希表的两种常见的(可能是恰当的)批评是,哈希表的初始化笨重且笨拙,并且哈希表的表示不像列表和(一定程度上)向量的表示那样集成到语言中。 make-hash软件包通过提供三种有用的相关机制来解决...
  • 哈希表的C简单实现

    2018-03-07 09:41:52
    哈希表的C简单实现代码。包含如下功能: 1.创建哈希 2.销毁哈希 3.清空哈希 4.加入键值对 5.删除键值对 6.根据键获取值 7.获取键值对数目

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,410
精华内容 70,564
关键字:

创建一个哈希表