精华内容
下载资源
问答
  • python实现哈希表
    2021-03-06 03:57:21

    复制代码 代码如下:

    #! /usr/bin/env python

    #coding=utf-8

    #实现哈希表(线性地址再散列)

    def ChangeKey(key,m,di):

    key01=(key+di) % m

    return key01

    a=raw_input("Please entry the numbers:\n").split()

    m=len(a)

    dict01={}

    for i in a:

    key=int(i)%m

    if "%s"%key in dict01:

    NewKey=ChangeKey(key,m,1)

    while "%s"%NewKey in dict01:         #因为下面的dict01的key值是以字符串来保存,因此这里作判断时也要用字符串格式

    NewKey=ChangeKey(NewKey,m,1)

    dict01["%s"%NewKey]=int(i)

    else:

    dict01["%s"%key]=int(i)

    print dict01

    本文来源:https://www.jb51.net/article/46500.htm

    更多相关内容
  • 2.按照学号字段建一个哈希表,实现按学号进行查找 务必用哈希结构实现 3.按照姓名字段构建哈希表结构,实现姓名的模糊查询。姓名取中文姓氏作为哈希地址 4.排序 实现多关键字排序 5.分别使用堆排和快排显示成绩前10...
  • 哈希表实现通讯录

    2018-01-23 12:11:22
    (1)每个人的信息至少包括姓名,...(2)假设人名为汉语拼音全拼形式,待插入哈希表的长度为你所在班级的人数。哈希函数用除留余数法构造,采用链地址法或二次探测再散列法解决冲突。 (3)完成菜单设计。操作有必要的提示。
  • 数据结构 杂凑编程实现 完美运行 完美注释
  • 易语言哈希表学习例程源码,哈希表学习例程,InitNameList,CreateHashList,子程序1,FindList,Display
  • 针对某个集体中的人名设计一个哈希表,使得平均查找长度不超过R,完成相应的建立和查表程序. 1.2 人名为汉语拼音形式,最长不超过18个字符(如:庄双双 zhuangshuangshuang). 1.3 假设待填入哈希表的人名有30个,...
  • 请你为自己手机的电话簿以电话号码作为关键字建立哈希表,然后依据电话号码进行哈希查找,并采用合适的冲突处理方法处理冲突。查找成功显示姓名与号码,查找失败则进行插入。电话簿初始从文本文档中逐个读入,然后...
  • 从键盘输入各记录,以用户名为关键字建立哈希表,哈希函数用除留取余数法构造,采用线性探测法解决冲突。可以插入、查找、删除并显示给定用户名的记录,并计算查找长度, 哈希表保存到文件中,并能从文件中读取数据。...
  • 1.1 针对某个集体中的人名设计一个哈希表,使得平均查找长度不超过R,完成相应的建立和查表程序. 1.2 人名为汉语拼音形式,最长不超过18个字符(如:庄双双 zhuangshuangshuang). 1.3 假设待填入哈希表的人名有30个,...
  • C语言设计哈希表实现图书查找系统,完成相应的建表和查表程序。从键盘输入各图书相关信息,分别以图书编号为关键字建立散列表。待填入哈希表的书号至少30个;构造合适的哈希函数。 1) 记录由外部输入。 2) 将生成...
  • 本文为大家分享了C语言基于哈希表实现通讯录的具体代码,供大家参考,具体内容如下 1.需求分析 本演示程序用C语言编写,完成哈希表的生成,电话号码的插入、以及查找等功能。  (1)按提示输入相应的联系人的相关...
  • 哈希表应用 设计哈希表实现图书查找系统,完成相应的建表和查表程序。从键盘输入各图书相关信息,分别以图书编号为关键字建立散列表。待填入哈希表的书号至少30个;构造合适的哈希函数。 (1)记录由外部输入。 (2...
  • 哈希表建立和查找哈希表建立和查找哈希表建立和查找哈希表建立和查找
  • (1)哈希函数:本案例选取“除留余数法”。 (2)碰撞问题:采用“线性探测法”解决。 2 实现代码 public class HaXi<E> { private class Node<E>{ public E e; public Node next; public...

    1 前置条件

    (1)哈希函数:本案例选取“除留余数法”。

    (2)碰撞问题:采用“线性探测法”解决。

    2 实现代码

    public class HaXi<E> {
    	
    	private class Node<E>{
    		public E e;
    		public Node next;
    		public Node(E e){
    			this.e = e;
    			this.next = null;
    		}
    	}
    	
    	private static final int M = 7;
    	private Node[] data;
    	
    	public HaXi(){
    		data = new Node[M];
    	}
    	
    	/**
    	 * 创建哈希表
    	 * @param e
    	 */
    	public void add(E e){
    		int hash = e.hashCode()  % M;
    		Node cur = data[hash];
    		if(cur==null){
    			cur = new Node(e);
    			data[hash] = cur;
    		}else{
    			while(cur!=null){
    				cur = cur.next;
    			}
    			cur = new Node(e);
    		}
    	}
    	
    	/**
    	 * 哈希查找
    	 */
    	public int find(E e){
    		int i=0, hash = e.hashCode() % M;
    		Node cur = data[hash];
    		while(cur!=null){
    			if(cur.e.equals(e)){
    				i++;
    				return i;
    			}else{
    				cur = cur.next;
    			}
    		}
    		return -1;
    	}
    	
    }
    

     

    展开全文
  • 哈希表(python)

    2021-02-10 10:54:06
    #-*- coding: utf-8 -*-classArray(object):def __init__(self, size=32, init=None):self._size=sizeself._items= [init] *sizedef __getitem__(self, index):returnself._items[index]def __setitem__(self, index...

    #-*- coding: utf-8 -*-

    classArray(object):def __init__(self, size=32, init=None):

    self._size=size

    self._items= [init] *sizedef __getitem__(self, index):returnself._items[index]def __setitem__(self, index, value):

    self._items[index]=valuedef __len__(self):returnself._sizedef clear(self, value=None):for i inrange(len(self._items)):

    self._items[i]=valuedef __iter__(self):for item inself._items:yielditemclassSlot(object):def __init__(self, key, value):

    self.key, self.value=key, valueclassHashTable(object):

    UNUSED= None #没被使用过

    EMPTY = Slot(None, None) #使用却被删除过

    def __init__(self):

    self._table= Array(8, init=HashTable.UNUSED) #保持 2*i 次方

    self.length =0

    @propertydef_load_factor(self):#load_factor 超过 0.8 重新分配

    return self.length /float(len(self._table))def __len__(self):returnself.lengthdef_hash(self, key):return abs(hash(key)) %len(self._table)def_find_key(self, key):

    index=self._hash(key)

    _len=len(self._table)while self._table[index] is notHashTable.UNUSED:if self._table[index] isHashTable.EMPTY:

    index= (index*5 + 1) %_lencontinue

    elif self._table[index].key ==key:returnindexelse:

    index= (index*5 + 1) %_lenreturnNonedef_find_slot_for_insert(self, key):

    index=self._hash(key)

    _len=len(self._table)while notself._slot_can_insert(index):

    index= (index*5 + 1) %_lenreturnindexdef_slot_can_insert(self, index):return (self._table[index] is HashTable.EMPTY or self._table[index] isHashTable.UNUSED)def __contains__(self, key): #in operator

    index =self._find_key(key)return index is notNonedefadd(self, key, value):if key inself:

    index=self._find_key(key)

    self._table[index].value=valuereturnFalseelse:

    index=self._find_slot_for_insert(key)

    self._table[index]=Slot(key, value)

    self.length+= 1

    if self._load_factor >= 0.8:

    self._rehash()returnTruedef_rehash(self):

    old_table=self._table

    newsize= len(self._table) * 2self._table=Array(newsize, HashTable.UNUSED)

    self.length=0for slot inold_table:if slot is not HashTable.UNUSED and slot is notHashTable.EMPTY:

    index=self._find_slot_for_insert(slot.key)

    self._table[index]=slot

    self.length+= 1

    def get(self, key, default=None):

    index=self._find_key(key)if index isNone:returndefaultelse:returnself._table[index].valuedefremove(self, key):

    index=self._find_key(key)if index isNone:raiseKeyError()

    value=self._table[index].value

    self.length-= 1self._table[index]=HashTable.EMPTYreturnvaluedef __iter__(self):for slot inself._table:if slot not in(HashTable.EMPTY, HashTable.UNUSED):yieldslot.keydeftest_hash_table():

    h=HashTable()

    h.add('a', 0)

    h.add('b', 1)

    h.add('c', 2)assert len(h) == 3

    assert h.get('a') ==0assert h.get('b') == 1

    assert h.get('hehe') isNone

    h.remove('a')assert h.get('a') isNoneassert sorted(list(h)) == ['b', 'c']

    n= 50

    for i inrange(n):

    h.add(i, i)for i inrange(n):assert h.get(i) ==iif __name__ == '__main__':print('beg',

    test_hash_table(),'end',

    )

    展开全文
  • 数据结构课程设计 之姓名哈希表的建 立及查找 课程设计任务书 学生姓名 刘颖 专业班级 计科1003班 指导教师 谭新明 工作单位 计算机科学系 题目哈希表的设计与实现 初始条件 针对某个集体比如你所在的班级中的人名...
  • C#实现哈希表

    2020-10-01 14:17:04
    哈希表 介绍 散列表(Hash Table,也叫哈希表),是根据关键码值(key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中的一个位置来访问记录,从而加快查找的速度。这个映射函数叫做散列函数,...

    哈希表

    介绍

    散列表(Hash Table,也叫哈希表),是根据关键码值(key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中的一个位置来访问记录,从而加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。

    实际需求

    有一个公司,当有新的员工报到时,要求将该员工的信息加入(ID,姓名…),当输入该员工的 ID 时,要求查找到该员工的所有信息。

    代码

    using System;
    
    namespace HashTableDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                //创建一个哈希表
                HashTable hashTable = new HashTable(7);
    
                //测试
                string key = "";
                while (true)
                {
                    Console.WriteLine("add: 添加雇员");
                    Console.WriteLine("list: 显示雇员");
                    Console.WriteLine("find: 查找雇员");
                    Console.WriteLine("exit: 退出");
    
                    key = Console.ReadLine();
                    switch (key)
                    {
                        case "add":
                            Console.WriteLine("输入id");
                            int id = Convert.ToInt32(Console.ReadLine());
                            Console.WriteLine("输入姓名");
                            string name = Console.ReadLine();
    
                            //创建雇员
                            Employee employee = new Employee(id, name);
                            hashTable.Add(employee);
                            break;
                        case "list":
                            hashTable.Traverse();
                            break;
                        case "find":
                            Console.WriteLine("输入带查找的雇员id");
                            id = Convert.ToInt32(Console.ReadLine());
                            hashTable.FindEmployeeByID(id);
                            break;
                        case "exit":
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    
        //创建 Hash Table
        class HashTable
        {
            private EmployeeLinkedList[] empLinkedListArray;
            private int size;   //表示共有多少条链表
    
            public HashTable(int size)
            {
                this.size = size;
                empLinkedListArray = new EmployeeLinkedList[size];
    
                //此处不要忘了分别初始化数组内部的每个链表
                for (int i = 0; i < size; i++)
                {
                    empLinkedListArray[i] = new EmployeeLinkedList();
                }
            }
    
            public void Add(Employee employee)
            {
                //根据雇员 ID 得到该员工应该加入到哪条链表
                int empLinkedListNum = GetHashCode(employee.ID);
    
                //将employee  添加到对应的链表中
                empLinkedListArray[empLinkedListNum].Add(employee);
            }
    
            //遍历哈希表
            public void Traverse()
            {
                for (int i = 0; i < size; i++)
                {
                    empLinkedListArray[i].Traverse(i);
                }
            }
    
            //根据输入的id查找雇员
            public void FindEmployeeByID(int id)
            {
                //使用散列函数确定查找哪条链表
                int empLinkedListNum = GetHashCode(id);
    
                Employee emp = empLinkedListArray[empLinkedListNum].FindEmployeeByID(id);
                if (emp != null)
                {
                    Console.WriteLine($"在第{empLinkedListNum}条链表中找到该雇员 id = [{emp.ID}] name = [{emp.Name}]");
                }
                else
                {
                    Console.WriteLine("在哈希表中未找到该雇员");
                }
    
            }
    
            //散列函数  使用简单的取模法
            public int GetHashCode(int id)
            {
                return id % size;
            }
        }
    
        //表示一个雇员
        class Employee
        {
            public int ID { get; set; }
            public string Name { get; set; }
            public Employee Next { get; set; }
    
            public Employee(int id, string name)
            {
                this.ID = id;
                this.Name = name;
                //this.Next = null;
            }
        }
    
        //表示链表
        class EmployeeLinkedList
        {
            //头指针,指向第一个Emp,因此该链表的head是有效的,直接指向第一个Emp
            private Employee head;  //默认为空
    
            //添加雇员到链表,直接加到链表末尾
            public void Add(Employee emp)
            {
                //如果是添加第一个雇员
                if (head == null)
                {
                    head = emp;
                    return;
                }
    
                //如果不是第一个雇员,则使用一个辅助指针定位到最后
                Employee curEmp = head;
                while (curEmp.Next != null)
                {
                    curEmp = curEmp.Next;
                }
    
                //将emp 加入链表
                curEmp.Next = emp;
            }
    
            //遍历链表信息
            public void Traverse(int no)
            {
                if (head == null)
                {
                    Console.WriteLine($"第{no}条链表为空!");
                    return;
                }
    
                Console.Write($"第{no}条链表信息为:");
    
                Employee curEmp = head;
                while (curEmp != null)
                {
                    Console.WriteLine($"=> id = [{curEmp.ID}]  name = [{curEmp.Name}]");
                    curEmp = curEmp.Next;
                }
                return;
            }
    
            //根据id查找雇员,如果查找到,返回对应节点, 未找到返回空
            public Employee FindEmployeeByID(int id)
            {
                if (head == null)
                    return null;
    
                Employee curEmp = head;
                while (curEmp != null)
                {
                    if (curEmp.ID == id)
                        return curEmp;
                    curEmp = curEmp.Next;
                }
    
                return null;
            }
    
        }
    }
    
    

    补充

    在本例中,其实就是通过一个链表数组,将存储数据的链表拆分成几个小的链表,再通过对应的散列函数找到存储关键值对应的"小链表",从"小链表"中查找数据比在一个大的链表中查找数据更快。

    展开全文
  • 资源包括:源代码,可执行文件。 1.问题描述 设计散列表实现电话...6)输出相应的哈希表,计算平均查找长度; 7)设计一个菜单,上述操作要求都作为菜单中的主要菜单项。 3.测试数据 取所在班级的 n(n>=20)个同学记录。
  • 哈希表的创建

    千次阅读 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...
  • 也叫哈希表)。是依据关键码值(Keyvalue)而直接进行訪问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来訪问记录。以加快查找的速度。这个映射函数叫做散列函数。存放记录的数组叫做散列表。散列函数能...
  • 文章目录1、哈希表介绍2、哈希函数H(k)哈希函数的构造方法:(1)直接定址法(2)数字分析法(3)平方取中法(4)折叠法(5)除留余数法(6)随机数法3、解决哈希碰撞1、开放地址法2、链地址法(拉链法)4、实例:...
  • C语言基于哈希表实现通讯录--附源码
  • 哈希表建立与运用C语言实现哈希表建立与运用C语言实现哈希表建立与运用C语言实现哈希表建立与运用C语言实现哈希表建立与运用C语言实现
  • 哈希表建立和查找

    2015-06-10 23:21:00
    建立哈希表的相关函数,用线性探查和二次探查解决冲突
  • 基于c语言的哈希表电话簿

    千次阅读 多人点赞 2020-12-23 19:56:14
    三、详细设计 3.1建立哈希表(实例)的存储结构 将每个人的信息作为一条记录,包括电话号码、用户名、地址,还有一个整型变量用来记录冲突的次数,便于计算ASL,然后哈希表由记录数组、表中现存量、表容量组成,具体...
  • 哈希表实现电话号码查询系统

    千次阅读 多人点赞 2019-12-18 11:58:28
    list.h #pragma once //预防头文件重复引用 #include <stdio.h> #include<stdlib.h> #include<string.h> #include <windows.h> #include<assert.h>...#define ...
  • 假设人名为中国人姓名的汉语拼音形式。待填入哈希表的人名共有30个,取平均查找长度的上限为2。哈希函数用除留余数法构造,用线性探测再散列法或链地址法处理冲突。
  • #include<iostream> using namespace std; typedef int status; constexpr auto SUCCESS = 1; constexpr auto UNSUCCESS = 0; constexpr auto HASHSIZE = 12; constexpr auto NULLKEY = -...//哈希表结构的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,888
精华内容 42,755
关键字:

哈希表建立