精华内容
下载资源
问答
  • 再哈希法
    万次阅读 多人点赞
    2018-06-12 10:16:57

    上篇博客我们说到了,什么是哈希冲突,其实就是再采用哈希函数对输入域进行映射到哈希表的时候,因为哈希表的位桶的数目远小于输入域的关键字的个数,所以,对于输入域的关键字来说,很可能会产生这样一种情况,也就是,一个关键字会映射到同一个位桶中的情况,这种情况就就叫做哈希冲突,解决哈希冲突的有三种方案,一种叫做拉链法(也叫作链接法、链地址法,一个意思),另外三种分别为开发地址法和再散列法。

    一、拉链法

    上篇博文我们举的例子,HashMap,HashSet其实都是采用的拉链法来解决哈希冲突的,就是在每个位桶实现的时候,我们采用链表(jdk1.8之后采用链表+红黑树)的数据结构来去存取发生哈希冲突的输入域的关键字(也就是被哈希函数映射到同一个位桶上的关键字)。首先来看使用拉链法解决哈希冲突的几个操作:

    ①插入操作:在发生哈希冲突的时候,我们输入域的关键字去映射到位桶(实际上是实现位桶的这个数据结构,链表或者红黑树)中去的时候,我们先检查带插入元素x是否出现在表中,很明显,这个查找所用的次数不会超过装载因子(n/m:n为输入域的关键字个数,m为位桶的数目),它是个常数,所以插入操作的最坏时间复杂度为O(1)的。

    ②查询操作:和①一样,在发生哈希冲突的时候,我们去检索的时间复杂度不会超过装载因子,也就是检索数据的时间复杂度也是O(1)的

    ③删除操作:如果在拉链法中我们想要使用链表这种数据结构来实现位桶,那么这个链表一定是双向链表,因为在删除一个元素x的时候,需要更改x的前驱元素的next指针的属性,把x从链表中删除。这个操作的时间复杂度也是O(1)的。

     

    拉链法的优点

    与开放定址法相比,拉链法有如下几个优点:

    ①拉链法处理冲突简单,且无堆积现象,即非同义词决不会发生冲突,因此平均查找长度较短;

    ②由于拉链法中各链表上的结点空间是动态申请的,故它更适合于造表前无法确定表长的情况;

    ③开放定址法为减少冲突,要求装填因子α较小,故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1,且结点较大时,拉链法中增加的指针域可忽略不计,因此节省空间;

    ④在用拉链法构造的散列表中,删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。

     

    拉链法的缺点

    指针需要额外的空间,故当结点规模较小时,开放定址法较为节省空间,而若将节省的指针空间用来扩大散列表的规模,可使装填因子变小,这又减少了开放定址法中的冲突,从而提高平均查找速度。

    使用例子:

    HashMap

    二、开发地址法

    开放地址法有个非常关键的特征,就是所有输入的元素全部存放在哈希表里,也就是说,位桶的实现是不需要任何的链表来实现的,换句话说,也就是这个哈希表的装载因子不会超过1。它的实现是在插入一个元素的时候,先通过哈希函数进行判断,若是发生哈希冲突,就以当前地址为基准,根据再寻址的方法(探查序列),去寻找下一个地址,若发生冲突再去寻找,直至找到一个为空的地址为止。所以这种方法又称为再散列法。

    有几种常用的探查序列的方法:

    ①线性探查

    dii=1,2,3,…,m-1;这种方法的特点是:冲突发生时,顺序查看表中下一单元,直到找出一个空单元或查遍全表。

    (使用例子:ThreadLocal里面的ThreadLocalMap)

    ②二次探查

    di=12,-12,22,-22,…,k2,-k2    ( k<=m/2 );这种方法的特点是:冲突发生时,在表的左右进行跳跃式探测,比较灵活。

    ③ 伪随机探测

    di=伪随机数序列;具体实现时,应建立一个伪随机数发生器,(如i=(i+p) % m),生成一个位随机序列,并给定一个随机数做起点,每次去加上这个伪随机数++就可以了。

    三、再哈希法

    再哈希法其实很简单,就是再使用哈希函数去散列一个输入的时候,输出是同一个位置就再次哈希,直至不发生冲突位置

    缺点:每次冲突都要重新哈希,计算时间增加。

    更多相关内容
  • 哈希表-再哈希法

    千次阅读 2016-11-28 11:44:02
    再哈希法: 为了消除原始聚集和二次聚集,可以使用另外一个方法:再哈希法,二次聚集产生的原因是,二次探测的算法产生的探测序列步长总是固定的:1,4,9,16… x现在需要的一种方法是产生一种依赖关键字的探测...

    再哈希法:
    为了消除原始聚集和二次聚集,可以使用另外一个方法:再哈希法,二次聚集产生的原因是,二次探测的算法产生的探测序列步长总是固定的:1,4,9,16…
    x现在需要的一种方法是产生一种依赖关键字的探测序列,而不是每个关键字都一样。那么,不同的关键字即使映射到相同的数组下标,也可以使用不同的探测序列。
    方法是把关键字用不同的哈希函数再做一遍哈希花,用这个结果作为步长,对指定的关键字,步长在整个探测中是不变的,不过不同的关键字使用不同的步长。

    经验说明,第二个哈希函数必须具备以下特点:
    和第一个哈希函数不同
    不能输出0.

    比如下面的哈希函数可以工作得很好:
    stepSize = constant * (key % constant)
    其中,constant是质数,且小于数组容量。

    
    package com.hash;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    
    import javax.xml.crypto.Data;
    
    class DataItem
    {
        private  int  iData;
        //...................
        public  DataItem(int ii)
        {
            iData = ii;
        }
    
        //.............
        public  int  getKey()
        {
            return  iData;
        }
    
    }
    
    class  HashTable
    {
        private  DataItem[]   hashArray; 
        private  int  arraySize;
        private  DataItem  nonItem;  //for  deleted  items
    
        //.....................
        public  HashTable(int  size)
        {
            arraySize = size;
            hashArray  =new  DataItem[arraySize];
            nonItem = new  DataItem(-1);   //deleted  item key  is  -1
    
        }
    
        //................
        public   void  displayTable()
        {
            System.out.println("Table:");
            for (int i = 0; i < arraySize; i++)
            {
                if(hashArray[i] != null)
                    System.out.println(hashArray[i].getKey()+"");
                else
                    System.out.println("");
            }
            System.out.println("");
        }
        //.............................
    
        public int  hashFunc1(int  key)
        {
            return  key % arraySize;  //哈希函数
        }
    
        /*
         * 要满足两个条件
         * 和第一个哈希函数不同
         * 不不能是0
         */
        public  int  hashFunc2(int key)
        {
            return  5* key % 5;
        }
    
        //..........................
        public  void insert(DataItem item)
        //假设哈希表没有
        {
            int key = item.getKey();
            int  hashVal = hashFunc1(key);
            int stepSize = hashFunc2(key);
            while(hashArray[hashVal]   !=  null&& hashArray[hashVal].getKey() != -1)
            {
                hashVal += stepSize;
                hashVal %= arraySize;
            }
            hashArray[hashVal]  = item;
        }
    
        //................................
        public  DataItem  delete(int  key)
        {
             int  hashVal = hashFunc1(key);
             int  stepSize= hashFunc2(key);
             while(hashArray[hashVal] != null)
             {
                    if(hashArray[hashVal].getKey() == key)
                    {
                        DataItem  temp = hashArray[hashVal];
                        //用特殊的数据项nonItem 覆盖原来的数据,这个变量事先定义为-1
                        hashArray[hashVal]  = nonItem;
                        return  temp;
                    }
                    hashVal += stepSize;
                    hashVal %= arraySize;
             }
             return  null;
        }
    
        /*
         * find()方法首先调用hashFunc()方法把待查找关键字转换成数组下标hashVal。
         * hashFunc()方法把%操作符应用于查找关键字和数组容量。
         * 接着,在while循环中,find()方法检查这个下标所指单元是否为空(null) 。如果不为空,
         * 他会检查这个数据项是否包含待检查关键字,如果包含,find()方法返回这个数据项
         * 如果不包含,find()递增hashVal,并且回到while循环的开始,检查下一个单元是否被占用。
         */
        public  DataItem  find(int  key)
        {
            int  hashVal = hashFunc1(key);
            int stepSize = hashFunc2(key);
    
            while(hashArray[hashVal]  != null)
            {
                if(hashArray[hashVal].getKey()   == key)
                    return  hashArray[hashVal];
                hashVal+=stepSize;
                hashVal %= arraySize;
            }
            return  null;
        }
        //...............................   
    
    }
    
    
    
    class  HashDoubleApp
    {
        public static void main(String[] args)  throws   Exception
        {
            int aKey;
            DataItem  aDataItem;
            int size,n;
    
            System.out.print("Enter   size  of  hash table:");
            size = getInt();
    
            System.out.print("Enetr  initial  number  of  items:");
            n=getInt();
    
    
            HashTable  theHashTable = new  HashTable(size);
            for (int i = 0; i < n; i++)
            {
                aKey = (int)(java.lang.Math.random() * 2*size);
                aDataItem =new  DataItem(aKey);
                theHashTable.insert(aDataItem);
            }
            while(true)
            {
                System.out.print("Enter  firdt  letter  of");
                System.out.print("show,insert,delete,or find:");
                char  choice = getChar();
                switch(choice)
                {
                case 's':
                    theHashTable.displayTable();
                    break;
                case 'i':
                    System.out.print("Enter  key  value  to insert:");
                    aKey = getInt();
    
                    aDataItem = new  DataItem(aKey);
                    theHashTable.insert(aDataItem);
                    break;
                case 'd':
                    System.out.print("Enter  key  value to delete:");
                    aKey = getInt();
                    theHashTable.delete(aKey);
                    break;
                case 'f':
                    System.out.println("Enter  key  value  to find:");
                    aKey = getInt();
                    aDataItem = theHashTable.find(aKey);
                    if(aDataItem != null)
                    {
                        System.out.println("found"+aKey);
                    }
                    else
                        System.out.println("Could  not  find"+aKey);
                    break;
                    default:
                        System.out.print("Invalid  enery\n");
                }
            }
        }
        //.......................
    
        public  static  String getString()  throws  Exception
        {
            InputStreamReader  isr = new  InputStreamReader(System.in);
            BufferedReader   br = new  BufferedReader(isr);
            String  s = br.readLine();
            return  s;
        }
        //.........................
        public static  char getChar()  throws  Exception
        {
            String  s= getString();
            return  s.charAt(0);
    
        }
        //...............
        public  static  int getInt()  throws  Exception
        {
            String  s= getString();
            return  Integer.parseInt(s);
        }
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 二次探测:每次加的步长随机或者是一定规律的数值再哈希法:哈希化有两个,第二个哈希化不能输出0,不能与第一个哈希化相同第二个哈希化得到的结果是当前冲突时,索引需要加的值,即是在二次探测的基础上将步长的改进...

    二次探测:每次加的步长随机或者是一定规律的数值
    再哈希法:哈希化有两个,第二个哈希化不能输出0,不能与第一个哈希化相同
    第二个哈希化得到的结果是当前冲突时,索引需要加的值,即是在二次探测的基础上将步长的改进

    //数据项(key值)
    public class DataItem {
        private int iData;
        public DataItem(int ii) {
            iData=ii;
        }
        public int getkey() {
            return iData;
        }
        
    
    }
    //哈希表
    public class HashTable {
        private DataItem[] hashArray;//数组
        private int arraySize;//哈希表的大小
        private DataItem nonItem;//标志删除之后,该位置存入的数据项(-1)
        public HashTable(int size) {//初始化
            arraySize=size;
            hashArray=new DataItem[arraySize];
            nonItem=new DataItem(-1);
        }
        //打印
        public void displayTable() {
            System.out.print("table:");
            for(int j=0;j<arraySize;j++)
                if(hashArray[j]!=null)
                    System.out.print(hashArray[j].getkey()+" ");
                else//如果没有值,就打印**
                    System.out.print("** ");
            System.out.println();
        }
        //哈希化
        public int hashFunc(int key) {
            return key%arraySize;
        }
        //第二次哈希化
        public int hashFunc2(int key) {
            //constant-(key%constant) constant为质数
            return 5-key%5; //key%5 会小于5,那么5-key%5肯定大于0
        }
        //插入
        public void insert(int key,DataItem item) {
            int hashVal=hashFunc(key);//第一次哈希化
            int stepSize=hashFunc2(key);//再哈希得到步长
            //再哈希法插入
            while(hashArray[hashVal]!=null &&  hashArray[hashVal].getkey()!=-1)//如果不是空的,也不是删除之后可以插入的
                {hashVal+=stepSize;//当前位置被占,寻找下一个位置(再哈希法) 
                 hashVal=hashVal%arraySize;//保证没有超出索引
                }
            hashArray[hashVal]=item;
            
                
            
        }
        //删除(需要判断哈希化后的位置有值.并且key是不是那个值)
        public DataItem delete(int key) {
            int hashVal=hashFunc(key);//哈希化
            int stepSize=hashFunc2(key);//第二次哈希化
            while(hashArray[hashVal]!=null) {//不等于空
                if(hashArray[hashVal].getkey()==key) {//数据项相同
                    DataItem temp=hashArray[hashVal];//要删除的数据项
                    hashArray[hashVal]=nonItem;
                    return temp;
                }
                hashVal+=stepSize;//数据项不同
                hashVal=hashVal%arraySize;
            }
            return null;//没有找到,第一次就是空的,或者再哈希法也没有找到
        }
        //查找
        public DataItem find(int key) {
            int hashVal=hashFunc(key);
            int stepSize=hashFunc2(key);//第二次哈希化
            while(hashArray[hashVal]!=null) {
                if(hashArray[hashVal].getkey()==key) {
        
                    return hashArray[hashVal];
                }
                hashVal+=stepSize;
                hashVal=hashVal%arraySize;
            }
            return null;
        }
        
        
        
        
        
        
        
        
        
        
        
        
    
        
        
    
    }
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Test {
        public static void main(String [] agrs) throws IOException {
            DataItem aDataItem;
            int akey,size,n;
            System.out.print("Enter:");
            size=getInt();
            System.out.println("初始化:");
            n=getInt();
            HashTable theHashTable=new HashTable(size);
            for(int j=0;j<n;j++) {
                akey=(int)(java.lang.Math.random()*2*size);
                aDataItem=new DataItem(akey);
                theHashTable.insert(akey,aDataItem);
            }
            while(true) {
                System.out.print("Enter first of show,isnert,delete ,find:");
                char choice=getChar();
                switch(choice){
                    case 's':
                        theHashTable.displayTable();
                        break;
                    case 'i':
                        System.out.print("insert:");
                        akey=getInt();
                        aDataItem=new DataItem(akey);
                        theHashTable.insert(akey,aDataItem);
                        break;
                    case 'd':
                        System.out.println("输入要删除的key");
                        akey=getInt();
                        theHashTable.delete(akey);
                        break;
                    case 'f':
                        System.out.println("输入要查找的key");
                        akey=getInt();
                        aDataItem=theHashTable.find(akey);
                        if(aDataItem!=null)
                            System.out.println("found"+akey);
                        else
                            System.out.println("没有找到");
                        break;
                        default:
                            System.out.println("无效的输入");
                }
            }
            
            
            
        }
        public static String getString() throws IOException{
            InputStreamReader isr=new InputStreamReader(System.in);
            BufferedReader br=new BufferedReader(isr);
            return br.readLine();
        }
        public static char getChar() throws IOException{
            return getString().charAt(0);
        }
        public static int getInt() throws IOException{
            return Integer.parseInt(getString());
        }
    
    }

     

    转载于:https://www.cnblogs.com/S-Mustard/p/7723532.html

    展开全文
  • 一、再哈希法哈希表代码如下: package com.tool.wpn.quicksort; import android.util.Log; /** * Created by Xi on 2017/8/15. * 再哈希法哈希表 */ public class HashTableAgain { private final String ...

    一、再哈希法哈希表代码如下:

    package com.tool.wpn.quicksort;
    
    import android.util.Log;
    
    /**
     * Created by Xi on 2017/8/15.
     * 再哈希法哈希表
     */
    
    public class HashTableAgain {
        private final String TAG="HashTableAgain";
        private DataItem[] hashArray;
        private int arraySize;
        private DataItem nonItem;//无元素,由于底层使用的数组,在真正删除元素时,也不是真正删除该内存空间,而是将其所含值改变,代表删除该元素
        public HashTableAgain(int size){
            arraySize=size;
            hashArray=new DataItem[arraySize];
            nonItem=new DataItem(-1);
        }
    
        public void displayTable(){
            StringBuilder sb=new StringBuilder();
            sb.append("[");
            for(int i=0;i<arraySize;i++){
                if(i==arraySize-1){
                    if(hashArray[i]!=null) {
                        sb.append(hashArray[i].getKey() + "");
                    }else {
                        sb.append("** ");
                    }
                }
                else {
                    if(hashArray[i]!=null) {
                        sb.append(hashArray[i].getKey() + "");
                    }else {
                        sb.append("** ");
                    }
                    sb.append(",");
                }
            }
            sb.append("]");
            Log.v(TAG,sb.toString());
        }
    
        /**
         * 首次哈希
         * 将传入的key经过hash算法,这里使用的普通除以数组大小求余的方法,而实际不是这么简单
         * @param key
         * @return
         */
        public int hashFunc(int key){
            return key%arraySize;
        }
    
        /**
         * 二次哈希,即再次哈希
         */
        public int hashFunc2(int key){
            //再次哈希原则 sepSize=constant-(key%constant);
            //constant是质数,且小于数组容量
            return 5-key%5;
        }
    
        /**
         * 插入元素
         */
        public void insert(DataItem item){
            int key=item.getKey();
            int hashVal=hashFunc(key);//首次哈希到的下标位置
            int stepSize=hashFunc2(key);//再次哈希得到的探测步长
            while(hashArray[hashVal]!=null && hashArray[hashVal].getKey()!=-1){//位置被占用
                //继续寻找位置
                hashVal+=stepSize;
                hashVal=hashVal%arraySize;
            }
            hashArray[hashVal]=item;//找到位置
        }
    
        /**
         * 删除元素
         */
        public DataItem delete(int key){
            int hashVal=hashFunc(key);//首次哈希到的下标位置
            int stepSize=hashFunc2(key);//再次哈希得到探测步长
            while(hashArray[hashVal]!=null){
                if(hashArray[hashVal].getKey()==key){//找到要删除的数据
                    DataItem temp=hashArray[hashVal];
                    hashArray[hashVal]=nonItem;
                    return temp;
                }
                hashVal+=stepSize;
                hashVal=hashVal%arraySize;
            }
            return null;//没有找到
        }
    
        /**
         * 查找元素
         */
        public DataItem find(int key){
            int hashVal=hashFunc(key);//首次哈希到的下标位置
            int stepSize=hashFunc2(key);//再次哈希得到探测步长
            while(hashArray[hashVal]!=null){
                if(hashArray[hashVal].getKey()==key){
                    return hashArray[hashVal];//找到元素
                }
                hashVal+=stepSize;
                hashVal=hashVal%arraySize;
            }
            return null;//没有找到
        }
    
    
    
    
    }
    

    package com.tool.wpn.quicksort;
    
    /**
     * Created by Xi on 2017/8/15.
     * 哈希表所使用元素
     */
    
    public class DataItem {
        private int iData;
        public DataItem(int key){
            iData=key;
        }
        public int getKey(){
            return iData;
        }
    
        @Override
        public String toString() {
            return "DataItem-key值为:"+iData;
        }
    }
    

    二、主函数调用如下:

    /**
         * 再哈希法哈希表
         * 第二次哈希的条件:
         * 1、二次哈希的方式不能与第一次相同
         * 2、二次哈希不能输出0
         * 3、
         */
        private void hashAgain(){
            int size=20;
            HashTableAgain hashTable=new HashTableAgain(size);
            hashTable.insert(new DataItem(10));
            hashTable.insert(new DataItem(50));
            hashTable.insert(new DataItem(60));
            hashTable.insert(new DataItem(11));
            hashTable.insert(new DataItem(21));
            hashTable.insert(new DataItem(54));
            hashTable.displayTable();
            DataItem dataItem = hashTable.find(12);//查找12
            if(dataItem==null){
                Log.v(TAG,"can't find");
            }else{
                Log.v(TAG,"find-"+dataItem.toString());
            }
            DataItem dataItemEl = hashTable.find(11);//查找11
            if(dataItemEl==null){
                Log.v(TAG,"can't find");
            }else{
                Log.v(TAG,"find-"+dataItemEl.toString());
            }
            DataItem delete = hashTable.delete(11);//删除11
            if(delete==null){
                Log.v(TAG,"can't delete");
            }else{
                Log.v(TAG,"delete-"+delete.toString());
            }
            hashTable.displayTable();
        }

    日志打印如下:


    源码下载地址: 点击打开链接
    展开全文
  • 哈希表的开放地址发中的二次探测虽然消除了线性探测的首次聚集问题,但是又产生了新的...在再哈希法中,步长依赖于关键字,且从第二个哈希函数中得到。如果第二个哈希函数返回一个值s,则探测序列是: x, x+s, x+2s,
  • } public void insertAgainDataItem(int key){//使用开放地址策略时,再哈希法最常用 DataItem data = new DataItem(key); int hashCode = getHashCode(key); int stepSize,constant=5; while(dataArray[hashCode] ...
  • package com.zoujc.hashDouble; /** * 哈希表:再哈希法 */ public class DataItem { private int iData; public DataItem(int data){ iData = data; } public int getKey(){ return iDa...
  • C语言——查找(折半、分块、二叉排序、哈希法

    千次阅读 多人点赞 2021-06-20 21:21:58
    前言 本篇主要介绍查找概念及各类查找方法。 看完本篇,你将了解到: 1.查找问题概述(查找表可进行的操作、时间开销、一些计算方法) 2.顺序表的查找(存储方式、算法时间性能) 3.折半查找(可递归可迭代) ...
  • Java HashMap中在resize()时候的rehash,即再哈希法的理解

    万次阅读 多人点赞 2016-08-22 00:24:52
    经过rehash之后,元素的位置要么是在原位置,要么是在原位置移动2次幂的位置 。对应的就是下方的resize的注释。 [java]   view plain   copy /**    * ...
  • > 再哈希法 同时构造多个不同的哈希函数,当哈希发生冲突时,使用下一个哈希函数,直到不再产生冲突。 这种方法不易产生聚焦,但增加了计算时间! > 链地址法 产生的哈希冲突加入链表 3、Java 中哈希值的计算规则 ①...
  • 字符串前缀哈希法

    2022-02-13 17:04:18
    前面为acwing上课截图! 总结:字符串前缀哈希,每一个字符看成进制位,然后转换成十进制取模。 l~r的哈希值:h[r]-h[l-1]*p[r-l+1]; 841. 字符串哈希 - AcWing题库 #include<...//h[]哈希表
  • 解决哈希冲突的四种方法

    千次阅读 2019-12-21 09:41:19
    上篇博客我们说到了,什么是哈希冲突,其实就是采用哈希函数对输入域进行映射到哈希表的时候,因为哈希表的位桶的数目远小于输入域的关键字的个数,所以,对于输入域的关键字来说,很可能会产生这样一种情况,也...
  • 主要介绍了python实现图像检索的三种(直方图/OpenCV/哈希法),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 总结一下,当我们遇到了要快速判断一个元素是否出现集合里的时候,就要考虑哈希法。 但是哈希法也是牺牲了空间换取了时间,因为我们要使用额外的数组,set或者是map来存放数据,才能实现快速的查找。 遇到需要判断一...
  • 时间限制:1000MS 代码长度限制:10KB 提交次数:0 通过次数:0 题型: 编程题语言: G++;GCC Description ...有N片雪花,每片雪花由六个角组成,每个角都有长度。...第i片雪花六个角的长度从某个角开始顺时针依次记为ai,1,...
  • /* *Copyright (c)2017,烟台大学计算机与控制工程学院 *All rights reservrd. *文件名称 :test.cpp *作者:杜昕晔 ...*问题描述: 用哈希法组织关键字 问题及代码: (1)
  • 深入详尽地讨论气相色谱法中测定死时间的PeterSon-Hir8ch法和Ambnls法之间的关系。可以认为前者为后者的一个特例,后者为前者的延伸。在使用3个等间隔的同系物化合物的保留时间时,两个方法是同样的。
  • 常用的几种方法有:开放定址法、拉链法、再哈希法、建立公共溢出区。 1、开放定址法 所谓的开放定址法就是一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入 ...
  • 接下来介绍源地址哈希法。 源地址哈希法是根据请求来源的地址,通过哈希函数计算得到的一个数值,用该数值对服务器列表的大小进行取模运算,得到的结果便是客服端要访问服务器的序号。采用源地址哈希法进行负载...
  • 使用哈希算法查找元素: /* hash search, using rehash method if find k, return if not find, d=(d+step)%m, rehash find */ int SearchHash(HashTable H, KeyType k) { int d, d1, m; m = H.ta...
  • 数组在哈希法中的经典应用
  • Hash表

    2017-11-17 15:56:00
    Hash表是什么? Hash表是一种数据结构,可以提供快速的插入操作和查找操作。 优点:运算速度快,查找操作比树块。 缺点:基于数组的,创建后难以扩展,而且当Hash表...包括线性探测、二次探测和再哈希法。 线性探...
  • 哈希法学习

    2022-03-24 10:43:20
    文章目录一、哈希表(Hash table)二、哈希函数与哈希碰撞1、拉链法2、线性探测法三、哈希法1、常见的三种哈希结构(1)数组(2)set(集合)(3)map(映射)2、什么时候使用哈希法四、编程实现1、leetcode题目2、...
  • 再哈希法 五、哈希化的效率 1.装填因子 2.开放地址法 (1).线性探测 (2).二次探测和哈希 3.链地址法 一. 认识哈希表 哈希表是一种非常重要的数据结构,几乎所有的编程语言都有直接或者间接的应用这种...
  • 笔试题:hash法

    2015-09-12 00:20:43
    #include #include #define DefaultSize 13 using namespace std;struct PeopleNode { int flags; char *name; PeopleNode():flags(0),name(new char[20]){} };class Hash { public

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,674
精华内容 3,469
关键字:

再哈希法

友情链接: anzhuang.rar