精华内容
下载资源
问答
  • 哈希表的构建与查询

    千次阅读 2014-12-22 17:29:41
    设要存放的数据元素有n个,存放数据元素的数组个数为m,哈希函数的设计目标,就是要使通过哈希函数得到的n个数据元素的哈希地址 。  1 除留余数法  除留余数法是用数据元素的关键字K除以哈希表长度m所得的余数...

    (本文内容来自互联网)

    11.2 哈希函数构造方法 

    设要存放的数据元素有n个,存放数据元素的数组个数为m,哈希函数的设计目标,就是要使通过哈希函数得到的n个数据元素的哈希地址 。
        1 除留余数法
               除留余数法是用数据元素的关键字K除以哈希表长度m所得的余数作为哈希地址的方法。除留余数法的哈希函数h(K)为:
                 h(K) = K mod m

    11.3 哈希冲突解决方法

    解决哈希冲突的方法主要有开放定址法和链表法两大类。 开放定址法
             开放定址法是一类以发生哈希冲突的哈希地址为自变量、通过某种哈希冲突函数得到一个新的空闲的哈希地址的方法。开放定址法的哈希冲突函数通常是一组。

    1 线性探查法
               线性探查法是从发生哈希冲突的地址d开始,依次探查d的下一个地址,直到找到一个空闲单元为止。线性探查法的数学递推描述公式为:

              

    如下哈希表类的哈希函数采用除留余数法,   哈希冲突函数采用开放定址法中的线性探查法。

    package cn.ls.hash;
    
    public class HashItem {
    	int data=0;  
        int info=0;//标志:0表示空闲状态,1表示占用状态.  
      
        HashItem(int i) {  
            info = i;  
        }  
      
        HashItem(int d, int i) {  
            data = d;  
            info = i;  
        }  
    }
    

    package cn.ls.hash;
    
    public class HashTable {
    	 private HashItem[] ht; // 哈希表数组  
    	    private int tableSize; // 哈希表的长度  
    	    private int currentSize; // 当前的表项个数  
    	  
    	    HashTable(int m) { // 构造函数  
    	        tableSize = m;  
    	        ht = new HashItem[tableSize];  
    	        currentSize = 0;  
    	    }  
    	  
    	    public boolean isIn(int x) { // x是否已存在  
    	        int i = find(x);  
    	        if (i >= 0)  
    	            return true;  
    	        else  
    	            return false;  
    	    }  
    	  
    	    public int getValue(int i) { // 取数据元素值  
    	        return ht[i].data;  
    	    }  
    	  
    	    public int find(int x) { // 查找  
    	        int i = x % tableSize;  
    	        int j = i;  
    	  
    	        if (ht[j] == null)  
    	            ht[j] = new HashItem(0);//设置info标记为0  
    	        //注意要加上非空判断.  
    	        while (ht[j] != null && ht[j].info == 1 && ht[j].data != x) { // 说明存在冲突  
    	            j = (j + 1) % tableSize; // 得到下一个哈希地址  
    	            if (j == i)  
    	                return -tableSize;  
    	            // 若j == i表示已查找完了整个哈希表的数组,返回- tableSize  
    	        }  
    	        if (ht[j] != null && ht[j].info == 1) //此条件成立表示查找到  
    	            return j; // 返回该数据元素的下标  
    	        else  
    	            //此时表示没有查找到  返回该数据元素哈希地址的负值  
    	            return -j;   
    	    }  
    	  
    	    public void insert(int x) throws Exception { // 插入  
    	        int i = find(x); // 查找x 是否已存在,并返回数组下标  
    	  
    	        if (i > 0) { // 如果x存在  
    	            throw new Exception("该数据已存在");  
    	        }  
    	  
    	        else if (i != -tableSize) { // 如果x不存在  
    	            ht[-i] = new HashItem(x, 1); //插入数据元素x,并设置info标记为1  
    	            currentSize++; // 当前元素个数加1  
    	        } else { // 如果i等于-tableSize,表示哈希表已满  
    	            throw new Exception("哈希表已满无法插入");  
    	        }  
    	    }  
    	  
    	    public void delete(int x) throws Exception { // 删除  
    	        int i = find(x); // 查找x 是否已存在,并返回数组下标  
    	  
    	        if (i >= 0) { // 如果x存在  
    	            ht[i].info = 0; // 置为空闲状态  
    	            currentSize--; // 当前元素个数减1  
    	        } else { // 如果x不存在  
    	            throw new Exception("该数据不存在");  
    	        }  
    	    }  
    }
    

    package cn.ls.hash;
    
    public class Exam11_3 {
    	public static void main(String[] args) {  
            //7个数据元素,哈希表数组个数取11进行测试。  
            HashTable myHashTable = new HashTable(11);  
            int[] a = { 180, 750, 600, 430, 541, 900, 460 };  
            int i, j, n = 7, item;  
      
            try {  
                for (i = 0; i < n; i++)  
                    myHashTable.insert(a[i]);  
      
                for (i = 0; i < n; i++) {  
                    j = myHashTable.find(a[i]);  
                    if (j > 0) {  
                        item = myHashTable.getValue(j);  
                        System.out.println("j = " + j + "  ht[] = " + item);  
                    }  
                }  
      
                if (myHashTable.isIn(430))  
                    System.out.println("数据元素430在哈希表中");  
                else  
                    System.out.println("数据元素430不在哈希表中");  
      
                myHashTable.delete(430);  
                if (myHashTable.isIn(430))  
                    System.out.println("数据元素430在哈希表中");  
                else  
                    System.out.println("数据元素430不在哈希表中");  
            } catch (Exception e) {  
                System.out.println(e.getMessage());  
            }  
        }  
    }
    

    测试结果:

    j = 4  ht[] = 180
    j = 2  ht[] = 750
    j = 6  ht[] = 600
    j = 1  ht[] = 430
    j = 3  ht[] = 541
    j = 9  ht[] = 900
    j = 10  ht[] = 460
    数据元素430在哈希表中
    数据元素430不在哈希表中



    展开全文
  • 地址处理哈希冲突的哈希

    千次阅读 2007-11-06 13:54:00
    哈希表作为一种快速查询的数据结构,在数据查找等方面具有广泛的应用:本文就是其一种实现方式,表结构比一般的哈希表的键值结构多了一个count计数,这个值是我论文使用的,所以不介绍了,我还没有毕业呢^_^!...

    哈希表作为一种快速查询的数据结构,在数据查找等方面具有广泛的应用:

    本文就是其一种实现方式,表结构比一般的哈希表的键值结构多了一个count计数,这个值是我论文使用的,所以不介绍了,我还没有毕业呢^_^!

    其实,我的整个实验还有别的代码,这里就不贴完整了,下面的代码也是有删减的,也未提高哈希表删除操作

    首先是:哈希表节点的对象类

    /*
     * Link.java
     *
     * Created on 2007年10月31日, 下午8:21
     *
     * 链表类
     * 
     
    */


    package com.mrl;

    /**
     *
     * 
    @author rulinma
     
    */

    public class Link {
        
        
    // 主键
        private String key;
        
    // 键值
        private String value;
        
    // 键的出现次数
        private int count;
        
        
    public Link next;
        
        
    /** 默认构造函数 */
        
    public Link() {
        }

        
        
    /*
         * 构造函数
         
    */

        
    public Link(String Key,String Value,int Count)
        
    {
            key 
    = Key;
            value 
    = Value;
            count 
    = Count;
        }

        
        
    public String getKey()
        
    {
            
    return key;
        }

        
        
    public String getValue()
        
    {
            
    return value;
        }

        
        
    public int getCount()
        
    {
            
    return count;
        }

        
        
    /*
         * 显示节点
         
    */

        
    public void displayLink()
        
    {
            System.out.println(key 
    +" ");
            System.out.println(value 
    +" ");
            System.out.println(count);
        }

    }

    2 哈希表的链表:

     

    /*
     * SortedList.java
     *
     * Created on 2007年10月31日, 下午8:25
     *
     * 
     * 链表哈希
     
    */


    package com.mrl;

    /**
     *
     * 
    @author rulinma
     
    */

    public class SortedList {
        
        
    private Link first;
        
        
    /** 默认构造函数 */
        
    public SortedList() {
        }

        
        
    public void insert(Link theLink)
        
    {
            Link previous 
    = null;
            Link current 
    = first; 
            
           
            
            
    // 顺序插入的代码
            if(first != null)
            
    {
                theLink.next 
    = first;
            }

            first 
    = theLink;

        }

        
        
    /*
         * 显示列表
         
    */

        
    public void displayList()
        
    {
            
    //System.out.println("链表显示");
            Link current = first;
            
    while(current != null)
            
    {
                current.displayLink();
                current 
    = current.next;
            }

            
    //System.out.println("链表结束");
        }

        
        
    /*
         * 查找键
         
    */

        
    public Link find(String key)
        
    {
            
    // i 用来测试平均查找长度
            int i = 0;
            Link current 
    = first;
            
    while((current != null))
            
    {
                i
    ++;
                
    if(current.getKey().equals(key))
                
    {
                    System.out.println(i);
                    
    return current;
                }

                current 
    = current.next;
            }

            System.out.println(i);
            
    return null;
        }

    }

     

    3 哈希表

     

    /*
     * HashTable.java
     *
     * Created on 2007年11月2日, 下午4:42
     *
     * 
     * 链地址法处理哈希表 
     
    */


    package com.mrl;

    /**
     *
     * 
    @author rulinma
     
    */

    public class HashTable {
        
        
    /** 哈希链表首地址数组 */
        
    private SortedList[] hashArray;
        
        
    /** 哈希链表长度 */
        
    private int arraySize;
        
        
    /** 构造函数 */
        
    public HashTable() {
        }

        
        
    /*
         * 初始化哈希表
         
    */

        
    public HashTable(int size)
        
    {
            arraySize 
    = size;
            
    // SortedList数组初始化
            hashArray = new SortedList[arraySize];
            
    for(int i=0; i<arraySize; i++)
            
    {
                hashArray[i] 
    = new SortedList();
            }

        }

        
        
    /*
         * 哈希影射函数
         
    */

        
    public int hashFunc(String key)
        
    {
            
    // 哈希值计算
            int hash = key.hashCode();
            
    return (hash & 0x7FFFFFFF% arraySize;
        }

        
        
    /*
         * 插入哈希表
         
    */

        
    public void insert(Link theLink)
        
    {
            String key 
    = theLink.getKey();
            
    int hashVal = hashFunc(key);
            hashArray[hashVal].insert(theLink);
        }

        
        
    /*
         * 遍历哈希链表
         
    */

        
    public void displayTable()
        
    {
            
    for(int i=0 ; i<arraySize; i++)
            
    {
                System.out.println(i 
    + ".");
                hashArray[i].displayList();
            }

        }

        
        
    /*
         * 查找Key
         
    */

        
    public Link find(String key)
        
    {
            
    int hashVal = hashFunc(key);
            Link theLink 
    = hashArray[hashVal].find(key);
            
    return theLink;
        }

    }

     

    4 对哈希表的测试程序:

    /*
     * HashChainApp.java
     *
     * Created on 2007年11月2日, 下午4:57
     *
     * 
     * 哈希链表应用程序
     
    */


    package com.mrl;
    import java.io.*;
    /**
     *
     * 
    @author rulinma
     
    */

    public class HashChainApp {
            
        
    /** 默认构造函数*/
        
    public HashChainApp() ...{
        }

        
        
    /** 主应用程序入口 */
        
    public static void main(String[] args)
        
    {
            
    // 初始化哈希表 10
            HashTable theHashTable = new HashTable(10);
            Link theLink 
    = new Link("重地","b",2);
            theHashTable.insert(theLink);
            theHashTable.insert( 
    new Link("通话","c",1));
            theHashTable.insert( 
    new Link("d","c",1));
            theHashTable.displayTable();
            System.out.println(theHashTable.find(
    "重地"));
            System.out.print(
    "这是哈希链表测试");
        }

        
       
    }


     

    我的测试是可以的,不过上面的代码稍微修改过,但是我感觉是可以的,如果不行调试一下,或给我发mail。

     

    展开全文
  • 今天无意中有人问到一个问题,“为什么哈希查询比较快?” 我没多想就回答道,”是因为采用键值对的方式,快速索引到值得内存地址“。 接着又问,”键值对的方式的原理是什么?“ 当时一愣,没不知如何...

          今天无意中有人问到一个问题,“为什么哈希查询比较快?”

          我没多想就回答道,”是因为采用键值对的方式,快速索引到值得内存地址“。

           

          接着又问,”键值对的方式的原理是什么?“

          当时一愣,没不知如何回答,只好说”抱歉“。

     

       手边没有书,也懒得去做名词解释了,在网上搜索到的一句话:

    当插入键值对到Hashtable中时,Hashtable使用每个键所引用对象的GetHashCode()方法,获取一个哈希编码,存入Hashtable中。 

         

       总之,
    (1)哈希函数的规则是:通过某种转换关系,使关键字适度的分散到指定大小的的顺序结构中。越分散,则以后查找的时间复杂度越小,空间复杂度越高。
    (2)使用hash,我们付出了什么?
    hash是一种典型以空间换时间的算法,比如原来一个长度为100的数组,对其查找,只需要遍历且匹配相应记录即可,从空间复杂度上来看,假如数组存储的是byte类型数据,那么该数组占用100byte空间。现在我们采用hash算法,我们前面说的hash必须有一个规则,约束键与存储位置的关系,那么就需要一个固定长度的hash表,此时,仍然是100byte的数组,假设我们需要的100byte用来记录键与位置的关系,那么总的空间为200byte,而且用于记录规则的表大小会根据规则,大小可能是不定的,比如在lzw算法中,如果一个很长的用于记录像素的byte数组,用来记录位置与键关系的表空间,算法推荐为一个12bit能表述的整数大小,那么足够长的像素数组,如何分散到这样定长的表中呢,lzw算法采用的是可变长编码。
    注:hash表最突出的问题在于冲突,就是两个键值经过哈希函数计算出来的索引位置很可能相同

    转载于:https://www.cnblogs.com/KiloNet/archive/2010/10/26/1861806.html

    展开全文
  • 数据结构 人名查询哈希表设计

    千次阅读 2020-01-08 15:56:57
    哈希函数用除留余数法构造,用线性探测再散列法或链地址法处理冲突。 测试数据 取读者周围较熟悉的30个人名。 选作内容 (1) 从教科书上介绍的集中哈希函数构造方法中选出适用者并设计几个不同的哈希函数...

    问题描述

    针对某个集体中人名设计一个哈希表,使得平均查找长度不超过R,并完成相应的建表和查表程序。

    基本要求

    假设人名为中国人姓名的汉语拼音形式。待填入哈希表的人名共有30个,取平均查找长度的上限为2。哈希函数用除留余数法构造,用线性探测再散列法或链地址法处理冲突。

    测试数据

    取读者周围较熟悉的30个人名。

    选作内容

    (1) 从教科书上介绍的集中哈希函数构造方法中选出适用者并设计几个不同的哈希函数,比较他们的地址冲突率(可以用更大的名字集合作实验)。
    (2) 研究这30个人名的特点,努力找一个哈希函数,使得对于不同的拼音名一定不发生地址冲突。
    (3) 在哈希函数确定的前提下尝试各种不同处理冲突的方法,考察平均查找长度的变化和造好的哈希表中关键字的聚集性。

    源码

    代码在VS中运行会出错,建议在VC或CB中编译

    #include<stdio.h>
    #include<time.h>//time用到的头文件
    #include<stdlib.h>//随机数srand用到的头文件
    #include<ctype.h>//toascii()用到的头文件
    #include<string.h>//查找姓名时比较字符串用的头文件
    #define HASH_LEN 50//哈希表的长度
    #define P 47//小于哈希表长度的P
    #define NAME_LEN 30//姓名表的长度
    
    typedef struct//姓名表
    {
        char *key;    //名字的拼音
        int m;       //拼音所对应的ASCII和
    }NAME;
    
    typedef struct//哈希表
    {
        char *key;   //名字的拼音
        int m;      //拼音所对应的ASCII总和,即关键字
        int si;     //查找长度
    }HASH;
    
    NAME Name[HASH_LEN];        //全局定义姓名表,最大长度为50
    HASH Hash[HASH_LEN];        //全局定义哈希表,最大长度为50
    int d[30],i,j;    //全局定义随机数,循环用的i、j
    
    void InitName()
    {//姓名表的初始化
        Name[0].key="lvsongxian";
        Name[1].key="yuanlei";
        Name[2].key="daiziwen";
        Name[3].key="chenyonghui";
        Name[4].key="zhangliang";
        Name[5].key="liubei";
        Name[6].key="sunshangxiang";
        Name[7].key="liyuanfang";
        Name[8].key="huge";
        Name[9].key="liuyifei";
        Name[10].key="anyixuan";
        Name[11].key="wangbaoqiang";
        Name[12].key="yangyiming";
        Name[13].key="hujing";
        Name[14].key="guowen";
        Name[15].key="xuyang";
        Name[16].key="lilu";
        Name[17].key="shenjinfeng";
        Name[18].key="xuhui";
        Name[19].key="huangjing";
        Name[20].key="guanyu";
        Name[21].key="chenlong";
        Name[22].key="huangliang";
        Name[23].key="liyan";
        Name[24].key="haojian";
        Name[25].key="zhangfei";
        Name[26].key="shuxiang";
        Name[27].key="sunyingjie";
        Name[28].key="wangbo";
        Name[29].key="zhaoqing";
    for (i=0;i<NAME_LEN;i++)    //将字符串的各个字符所对应的ASCII码相加,所得的整数做为哈希表的关键字
    {
        int s=0;
            char *p=Name[i].key;
        for (j=0;*(p+j)!='\0';j++)
            s+=toascii(*(p+j));
            Name[i].m=s;
    }
    }
    
    void CreateHash()
    {//建立哈希表
           for(i=0;i<HASH_LEN;i++) //清空哈希表,未经此操作将储存空数据
           {
                  Hash[i].key="\0";
                  Hash[i].m =0;
                  Hash[i].si=0;
           }
           for(i=0;i<NAME_LEN;i++)
           {
                  int sum=1,j=0,t;
                  int adr=(Name[i].m)%P;  //除留余数法H(key)=key%P,除数为P=47
                  if(Hash[adr].si==0)     //如果不冲突,将姓名表赋值给哈希表
                  {
                         Hash[adr].m =Name[i].m;
                         Hash[adr].key=Name[i].key;
                         Hash[adr].si=1;
                  }
                  else                         //如果冲突
                  {
                      t=adr;        //线性探测法处理冲突
                     for(;Hash[adr].si!=0&&adr<HASH_LEN;adr++)//从冲突下一个位置开始探测
                         {
                                sum=sum+1;//每次查找,查找次数+1
                                if(adr==HASH_LEN-1)//如果找到最后一个仍然没有位置
                                {
                                    for(;Hash[adr].si!=0&&adr<t;adr++)//从第一个开始探测
                                     sum=sum+1;//每次查找,查找次数+1
                                     if(adr==t) printf("哈希表已满\n");//如果找到上次的位置仍然没有,则输出哈希表已满
                                }
                         }
                         Hash[adr].m =Name[i].m;  //将姓名表复制给哈希表对应的位置上
                         Hash[adr].key=Name[i].key;
                         Hash[adr].si=sum;
                  }
           }
    }
    
    void DisplayName()//显示姓名表
    {
           printf("\n地址 \t\t 姓名 \t\t 关键字\n");
           for (i=0;i<NAME_LEN;i++)
           printf("%2d %18s \t\t  %d  \n",i,Name[i].key,Name[i].m);
    }
    
    void DisplayHash()// 显示哈希表
    {
           float asl=0.0;
           printf("\n\n 地址 \t\t 姓名 \t\t 关键字 \t 搜索长度\n"); //显示的格式
           for (i=0;i<HASH_LEN;i++)
           {
                  printf("%2d %18s \t\t  %d \t\t  %d\n",i,Hash[i].key,Hash[i].m,Hash[i].si);
                  asl+=Hash[i].si;
           }
           asl/=NAME_LEN;//求得ASL
           printf("\n\n平均查找长度:ASL(%d)=%f \n",NAME_LEN,asl);
    }
    
    void FindName()//查找
    {
        char name[20]={0};
        int s=0,sum=1,adr;
        printf("\n请输入想要查找的姓名的拼音:");
        scanf("%s",name);
        getchar();
        for (j=0;j<20;j++)//求出姓名的拼音所对应的ASCII作为关键字
            s+=toascii(name[j]);
        adr=s%P;           //除留余数法
        j=0;
        if(Hash[adr].m==s&&!strcmp(Hash[adr].key,name)) //分3种情况进行判断,并输出查找结果
            printf("\n姓名:%s   关键字:%d   地址:%d   查找长度为: 1\n",Hash[adr].key,s,adr);
        else if (Hash[adr].m==0)
            printf("\n没有想要查找的人!\n");
        else
           {
                while(1)
                  {
                      adr=(adr+d[j++])%HASH_LEN;//伪随机探测再散列法处理冲突
                      sum=sum+1;                //查找次数加1
                      if(Hash[adr].m==0)
                         {
                            printf("\n没有想要查找的人!\n");
                            break;
                         }
                         if(Hash[adr].m==s&&!strcmp(Hash[adr].key,name))
                         {
                            printf("\n姓名:%s   关键字:%d   地址:%d   查找长度为:%d\n",Hash[adr].key,adr,s,sum);
                            break;
                         }
                  }
           }
    }
    
    void view()//交互界面
    {
         printf("=======================================================\n");
        printf("=                                                     =\n");
        printf("=                   人名哈希表                        =\n");
        printf("=                                                     =\n");
        printf("=  A: 打印姓名表                 B: 打印哈希表        =\n");
        printf("=                                                     =\n");
        printf("=  C: 查找                       D: 退出程序          =\n");
        printf("=                                                     =\n");
        printf("=======================================================\n");
    }
    
    int main()//主函数
    {
        char c;
        int a=1;
        srand((int)time(0));//以当前时间对应的int值为随机序列起点,每次运行程序由于起点不同可以得到不同的随机数序列
        for(i=0;i<30;i++)//用随机函数求得伪随机数列d[i](在1到50之间)
            d[i]=1+(int)(HASH_LEN*rand()/(RAND_MAX+1.0));
        InitName();//调用初始化姓名表函数
        CreateHash();//调用创建哈希表函数
        view();//调用交互界面函数
        while(a)
        {
           printf("\n输入选项:");
           scanf("%c",&c);
           getchar();
           switch(c)//根据选择进行判断,直到选择退出时才可以退出
           {
               case 'A':
               case 'a': DisplayName(); break;//打印姓名表
               case 'B':
               case 'b': DisplayHash(); break;//打印哈希表
               case 'C':
               case 'c': FindName(); break;//调用查找函数
               case 'D':
               case 'd': a=0; break;//退出循环,终止程序
               default: printf("\n请输入正确的选择!\n"); break;
           }
        }
        return 0;
    }
    
    展开全文
  • 本题要求你模拟hash的保留余数法:取关键字被某个不大于哈希表表长m的数key除后所得余数为哈希地址。即 H(key) = key MOD m。 现在有两种操作:  1. 往hash表插入一个值为x正整数。   2.查询hash表的...
  • 哈希

    2013-02-01 02:59:21
    关键值:哈希地址的索引号; 哈希函数:建立关键值和哈希地址之间的映射; 哈希地址:数据存储地址。 冲突:由关键值,和哈希函数得出的哈希地址,存在冲突 关于哈希函数,有很多种设计思路,来解决冲突,以及快速...
  • 哈希表最大的特点是可以快速定位到要查找的数据,查询的时间复杂度接近O(1).哈希表的设计原理假如我们有一组数据,某位工程师每年的收入情况2017 -- 100000 2018 -- 130000 2019 -- 140000 2020 -- 200000如果我们用...
  • 7-15 航空公司VIP客户查询 (25分) 不少航空公司都会提供优惠的会员服务,当某顾客飞行里程累积达到一定数量后,可以使用里程积分直接兑换奖励机票或奖励升舱等服务。现给定某航空公司全体会员的飞行记录,要求实现...
  • 设计哈希表实现电话号码查询系统

    热门讨论 2008-12-26 22:25:05
    设计哈希表实现电话号码查询系统。基本要求: 1、设每个记录有下列数据项:电话号码、用户名、地址; 2、从键盘输入各记录,分别以电话号码和用户名为关键字建立哈希表; 3、采用再哈希法解决冲突; 4、查找并...
  • 哈希表和哈希冲突

    千次阅读 2018-08-19 17:02:55
    hash table的查询速度非常快,时间复杂度几乎是o(1)。如果需要在一秒种内查找上千条记录通常使用哈希表(例如拼写检查器)哈希表的速度明显比树快,树的操作通常需要O(N)的时间级。 基本思想:将元素的关键字k通过...
  • 设计一个电话号码查询系统,为来访的客⼈提供各种信息查询服务。 1.2 基本要求 设计每个记录有下列数据项:电话号码、用户名、地址 从键盘输入个记录,分别以电话号码和用户名为关键字建立不同散列表存储 采用...
  • 在链地址法的描述中,哈希表的结构更加复杂一点,但是查询和存储的性能都有进一步提升,尤其是面对超大量的数据时,将哈希表的每一个位置设计成链表,无疑加快了查询速度,而且理解上也更加容易。 在开放地址法中,...
  • 电话号码查询系统功能: (1)存储联系人(姓名 电话 地址) (2)删除联系人 (3)根据姓名或者号码查找联系人 import java.util.Scanner; public class HashTest { public static void main(String[] args) { ...
  • 哈希表实现电话号码查询系统(c++)

    万次阅读 多人点赞 2015-09-12 16:42:40
    问题描述:设计哈希表实现电话号码查询系统,实现下列功能: (1) 假定每个记录有下列数据项:电话号码、用户名、地址。 (2) 一是从数据文件old.txt(自己现行建好)中读入各项记录,二是由系统随机产生各记录,并且...
  • HashTable-散列表/哈希表,是根据关键字(key)而直接访问在内存存储位置的数据结构...构造哈希表的几种方法直接定址法--取关键字的某个线性函数为散列地址,Hash(Key)= Key 或 Hash(Key)= A*Key + B,A、B为常...
  • 哈希查找

    2020-05-27 09:36:18
    比如我需要查询一个数460,那么根据先前存储时所采取的映射关系就可以准确地得到460相应的存储地址,从而实现高效查找。这是一个给定自变量的值,通过指定函数关系,得到因变量的值的过程。所谓哈希冲突就是一个因...
  • 哈希笔记

    2019-12-24 21:46:37
    哈希值简介:是jdk根据对象的地址或者字符串或数字算出来的int类型的数值,用于散列储存这个对象时有据可依。方便正对这个对象使用java中的各种散列数据结构做存储,比如hashmap hashset 不同的对象可能又同样的...
  • 哈希算法

    2020-07-17 22:33:01
    对某个元素进行哈希运算,把一个较长的二进值映射为较短的固定长度的二进制值,这个小的二进制值就是哈希值,是一个存储地址,然后根据地址进行元素的存储操作。具体映射方法采用位运算。(不用取模,因为第一,...
  • 哈希表就是根据一个关键值key进行高效访问的数据结构,可以通过哈希函数把一个数据当做key进行映射得到一个储存地址从而进行访问。 比如想要查询100个数字范围在(1 ~ 1e8),查询它们是否有重复的值,那么就可以用...
  • 其中最常提到的就是一个名为“哈希”的算法,由于是根据英语发音直译过来的,所以没办法很好的做到见名知意,今天的文章就为大家简单的介绍一下所谓的“哈希”。对于计算机来说,区块链就像一个单向链表,一个数据块...
  • 也就是说,它通过计算一个关于键值的函数,将所需查询的数据映射到表中一个位置来访问记录,这加快了查找速度。这个映射函数称做哈希函数,存放记录的数组称做哈希表。哈希表相关定义如下: typedef enum{ HASH_OK,...
  • 哈希hash

    2011-07-26 21:43:03
    哈希算法由两部分组成,首先是能够将查询关键字转换成表地址哈希函数。理想情况是不同的关键字映射到不同的地址,但经常出现两个或者多个关键字对应同一表地址的情况,如果两个输入关键字的hash函数的值一样,则...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 380
精华内容 152
热门标签
关键字:

哈希地址查询