算法导论学习笔记——散列表

最新推荐文章于 2024-11-01 17:00:11 发布
最新推荐文章于 2024-11-01 17:00:11 发布
阅读量2.6k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 object table string java null

本文系转载，转自：http://www.iteye.com/topic/570646

散列表是最常用的数据结构之一，特别是 ruby js等动态语言在语法层次上对它进行了支持。只是在java中，有那么点点绕(每次使用的时候，心里会疙瘩一下，不知道你们有没有这种感觉)。

本章真是纠结，因为看得懂的以前都看过，不懂的现在还是看不懂。 还好看不懂的部分都是加星号的。

散列表是这样一个东西：它能以key为索引保存东西， 然后在需要的时候嗖的一下就能找出来，灰常地快：）

Java代码   

    @Test  
    public void test() {  
        HashTable ht = new HashTable();  
          
        Object o1 = new Object();  
        ht.put("o1", o1);  
          
        Object o2 = new Object();  
        ht.put("o2", o2);  
          
        assertEquals(o1, ht.get("o1"));  
        assertEquals(o2, ht.get("o2"));  
    }

 get方法要在常量时间内找到需要的东西。O(1)  <--- 要这样的复杂度

先不管这些，但至少HashTable看起来像这样：

Java代码   

    public class HashTable {  
          
        public void put(String key, Object value) {  
            //...  
        }  
          
        public Object get(String key) {  
            //...  
            return null;  
        }  
    }

上面的代码当然是通不过测试的(PS: 请先忘记java.util.HashTable)

要想get足够快，那么最好是跟据 key 直接计算出存储位置， 然后就能一下子找到啦。

差不多像这样:

    public class HashTable {  
          
        private Object[] table = new Object[1000];  
          
        public void put(String key, Object value) {  
            int hash = hash(key.hashCode());  
            if (table[hash] == null) {  
                table[hash] = value;  
            } else{  
                throw new RuntimeException("撞车啦，怎么办?");  
            }  
        }  
          
        public Object get(String key) {  
            int hash = hash(key.hashCode());  
            return table[hash];  
        }  
          
        private int hash(int hashCode) {  
            return -1; // 这里需要返回一个数 [0, table.length - 1]  
        }  
    }

运行测试，数组越界， 因为我们还未实现 hash 这个方法。

hash 的作用是把关键字等可能地散列到 table 中去

有除法散列，乘法散列，等等。

先试一个除法散列：

 

Java代码   

 
 private int hash(int hashCode) {  
        int capacity = table.length;  
        return hashCode % capacity;  
    }  










capacity 不应该是 2 的幂， 否则的话值为hashCode的低 k 位， 高位就会浪费掉，可能会造成很多碰撞


可以选择2的整数幂不大接近的质数。


现在运行测试，是通过滴：）


但是等等， 有时候我们需要这样：


 
 


  
  


   
   

    
    Java代码  
    
    
    public void test2() {  
        HashTable ht = new HashTable();  
          
        Object o1 = new Object();  
        ht.put("o1", o1);  
          
        Object anotherO1 = new Object();  
        ht.put("o1", anotherO1);    // 更新  
        assertEquals(anotherO1, ht.get("o1"));  
    }  

   
   


  
  


 
 


我们需要重构代码，把key也给保存起来。


首先添加一个结构， 保存key 和value


 
 


  
  


   
   

    
    Java代码  
   
   


  
  


 
 




    public class HashTable {  
          
        public static  class Entry {  
            private String key;  
            private Object value;  
              
            public Entry(String key, Object value) {  
                this.key = key;  
                this.value = value;  
            }  
              
            public String getKey() {  
                return key;  
            }  
            public Object getValue() {  
                return value;  
            }  
        }  
          
        private Entry[] table = new Entry[1000];  // 原来的Object[] 改成 Entry[]  




重构put


 
 


  
  


   
   

    
    Java代码  
    
    收藏代码
   
   


  
  


 
 




    public void put(String key, Object value) {  
        int hash = hash(key.hashCode());  
        if (table[hash] == null || table[hash].getKey().equals(key)) {  
            table[hash] = new Entry(key, value);  
        } else{  
            throw new RuntimeException("撞车啦，怎么办?");  
        }  
    }  




重构get


 
 


  
  


   
   

    
    Java代码  
   
   


  
  


 
 




    public Object get(String key) {  
        int hash = hash(key.hashCode());  
        Entry entry = table[hash];  
        return entry == null ? null : entry.getValue();   
    }  




 可以看到，测试又通过了：）


再看乘法散列


 
 


  
  


   
   

    
    Java代码  
   
   


  
  


 
 




    private int hash(int hashCode) {  
        int capacity = table.length;  
        double a = 0.6180334;  // 万能的黄金分割  
        return (int) (((hashCode * a) % 1) * capacity);  
    }  




用常数(A) 乘hashCode  取小数 再乘capacity


Knuth认为 黄金分割数 是比较理想的值（(根号5 - 1) / 2 ~ 0.618), 股民朋友们一定认识


乘法散列 的优点是：


对 capacity 没有什么特别的要求， 一般选择它为 2 的整数幂。


因为这样可以使用移位代替乘法计算。


然后黄金分割数 A 如果可以表示成 2654435769  / (2 ^32) 


那就可以简化成：//


假设计算机字长是w位，这里w为32位，hashCode * 2654435769，是一个2w位的值，前32位为高位，后32位为低位，
((1 << 32) - 1) 为32个1，与hashCode * 2654435769相与(&)即可保留低32位的值，然后低32位中的前p位即为散列值，也就是低32位右移(32-p)












              ((hashCode * 2654435769) 
                  & ((1 << 32) - 1) )   // 只保留 32 位
               >> (32 - p) 




重购代码试试看：


首先，数组空间大小为 2 ^ p


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    private int p = 10;  
    private Entry[] table = new Entry[1 << p];  




然后：


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    private int hash(int hashCode) {  
        long k = 2654435769L;  
        return (int)(((k * hashCode) & ((1L << 32) - 1)) >> (32 - p));  
    }  




测试还是通过滴。


下面， 让我们加多一点元素，搞坏它。


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    @Test  
    public void test3() {  
        HashTable ht = new HashTable();  
          
        for (int i = 0; i < 1000; i++) {  
            Object o = new Object();  
            ht.put("key" + i, o);  
            assertEquals(o, ht.get("key" + i));  
            System.out.println("Ok: " + i);  
        }  
    }  




运行测试，失败， 可以看到控制台只输出到 108


RuntimeException,   撞车了怎么办？


可以采用链接法，开放寻址法搞定


先来 链接法


首先重构Entry, 把自己串起来


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    public static class Entry {  
        private String key;  
        private Object value;  
        private Entry next;  
          
        public Entry(String key, Object value) {  
            this(key, value, null);  
        }  
        public Entry(String key, Object value, Entry next) {  
            this.key = key;  
            this.value = value;  
            this.next = next;  
        }  
          
        public String getKey() {  
            return key;  
        }  
          
        public Object getValue() {  
            return value;  
        }  
        public void setValue(Object value) {  
            this.value = value;  
        }  
          
        public Entry getNext() {  
            return next;  
        }  
    }  




同时也添加了一个 setValue 方法， 这样更容易在链表中“更新元素


然后重构put


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    public void put(String key, Object value) {  
        int hash = hash(key.hashCode());  
        Entry entry = table[hash];  
          
        if (entry == null) { // 位置没被使用过， 直接用  
            table[hash] = new Entry(key, value);  
            return;  
        }  
        for (Entry o = entry; o != null; o = o.getNext()) {  
            if (o.getKey().equals(key)) {  // 看看key节点是否存在， 如果是，就更新它  
                o.setValue(value);  
                return;  
            }  
        }  
        table[hash] = new Entry(key, value, entry);  // 这里我们串起来  
    }  




可以看到，测试正常运行：）


但是随着散列表中的元素越来越多，碰撞机率也越来越大，最好当元素数量达到一定量时，自动扩充容量，这样才能保证其优异的查找性能。


但是我们先看看，现在的散列表， 运行test3时，碰撞几率是多少。


为此，我们重构, 发生碰撞时， 统计次数。


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    private int size = 0;  // 统计表中元素个数  
    private int collideCount = 0;  // 统计碰撞次数  
      
    public int getSize() {  
        return size;  
    }  
    public float getCollideRate() {  
        return size > 0 ? ((float) collideCount) / size : 0;  
    }  




  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    public void put(String key, Object value) {  
            int hash = hash(key.hashCode());  
            Entry entry = table[hash];  
              
            if (entry == null) {  
                table[hash] = new Entry(key, value);  
                size++;  // 这里  
                return;  
            }  
            collideCount++;  // 这里  
            for (Entry o = entry; o != null; o = o.getNext()) {  
                if (o.getKey().equals(key)) {  
                    o.setValue(value);  
                    return;  
                }  
            }  
            table[hash] = new Entry(key, value, entry);  
            size++; // 还有这  
        }  




测试：


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    @Test  
    public void test4() {  
        HashTable ht = new HashTable();  
          
        for (int i = 0; i < 1000; i++) {  
            ht.put("key" + i, new Object());  
        }  
        System.out.println(ht.getCollideRate());  
    }  




输出：0.309


总的容量为 1024, 有1000个元素， 其中309个是发生碰撞。事故挺严重的。


下面我们重构HashTable类， 让其每次达到容量的 0.75(装载因子) 就扩充容量：）


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    private int p = 4;  
    private Entry[] table = new Entry[1 << p];  
    private float loadFactor = 0.75f;  




首先， 我们的初始化容量为 16个(1 << 4)， 然后 load factor 为0.75


  
  


   
   


    
    

     
     Java代码  
     
     收藏代码
    
    


   
   


  
  




    public void put(String key, Object value) {  
        if (table.length * loadFactor < size) {  
            resize();  
        }  




然后在put 前检查一下, 如有必要 resize


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    private void resize() {  
        Entry[] old = table;  
          
        p += 1;  
        table = new Entry[1 << p];  
        size = 0;  
        collideCount = 0;  
          
        for (int i = 0; i < old.length; i++) {  
            Entry entry = old[i];  
            while (entry != null) {  
                put(entry.getKey(), entry.getValue());  
                entry = entry.getNext();  
            }  
        }  
    }  




写个测试：


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    @Test  
    public void test5() {  
        HashTable ht = new HashTable();  
          
        for (int i = 0; i < 1000; i++) {  
            Object o = new Object();  
            ht.put("key" + i, o);  
            assertEquals(o, ht.get("key" + i));  
        }  
        System.out.println(ht.getSize());  
        assertTrue(ht.getSize() == 1000);  
        System.out.println(ht.getCollideRate());  
    }  




这个时候，同样是添加到1000个， loadFactor 此时为 0.08


我们的散列表初始大小为16,  添加到1000个，要进行若干次 resize, resize开销比较大。


我们可以重构代码， 构造函数中指定容量大小，以避免不必要的resize开销。


但这里不做了，因为现在只是为了说明算法， 但是使用 java.util.HashMap时，就晓得了。


解决碰撞还有开放寻址法


也是灰常容易滴， 我们添加两个方法， put2, 和 get2， 实现看看。


使用最简单的 线性探查


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    public void put2(String key, Object value) {  
        if (table.length * loadFactor < size) {  
            resize();  
        }  
          
        int hash = hash(key.hashCode());  
        Entry entry = table[hash];  
          
        int nextHash = hash;  
        while (entry != null) {  
            if (entry.getKey().equals(key)) {  
                entry.setValue(value);  
                return;  
            }  
            nextHash = (nextHash + 1) % table.length;  // 看看下一个位置  
            entry = table[nextHash];  
        }  
        table[nextHash] = new Entry(key, value);  
        size++;  
          
        if (hash != nextHash) {  
            collideCount++;  
        }  
    }  




  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    public Object get2(String key) {  
        int hash = hash(key.hashCode());  
        Entry entry = table[hash];  
        while (entry != null) {  
            if (entry.getKey().equals(key)) {  
                return entry.getValue();  
            }  
            hash = (hash + 1) % table.length;  
            entry = table[hash];  
        }  
        return null;  
    }  




同样，写一个测试


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    @Test  
    public void test6() {  
        HashTable ht = new HashTable();  
          
        for (int i = 0; i < 1000; i++) {  
            Object o = new Object();  
            ht.put2("key" + i, o);  
            assertEquals(o, ht.get2("key" + i));  
        }  
        System.out.println(ht.getSize());  
        assertTrue(ht.getSize() == 1000);  
        System.out.println(ht.getCollideRate());  
    }   





线性探查比较容易实现， 但是容易造成“堆在一起”的问题， 书中称为：一次群集


可以采用二次探查， 或双重散列，更好地避免这种现象。


//----------


下面看看java.util.HashMap的实现，更好地了解散列表。


先看 put:


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    public V put(K key, V value) {  
        if (key == null)  // null 也可以为key  
            return putForNullKey(value);  
        int hash = hash(key.hashCode()); // 关心的地方  
        int i = indexFor(hash, table.length); // 关心的地方  
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {  
            Object k;  
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
                V oldValue = e.value;  
                e.value = value;  
                e.recordAccess(this);  
                return oldValue;  
            }  
        }  
      
        modCount++;  
        addEntry(hash, key, value, i); // 关心的地方  
        return null;  
    }  




代码中 hash 和 indexFor addEntry 是我们关心的地方。


此外： HashMap 允许使用值为 null 的key


有一个 if 语句：


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


   
   
  1. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {    


  
  


先看看 hash值是否相等， 再判断equals


这也给出了我们重写equals和 hash的原则： 如果你重写了equals, 那么你一定要重写 hashCode, 如果两个对象equals，那么hashCode也一定要相等, 否则在HashMap等容器中将不能正确工作。参看《Effective Java》


再来看看 hash 和 indexFor  (中文注释是我加的)


  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    /** 
      * Applies a supplemental hash function to a given hashCode, which 
      * defends against poor quality hash functions.  This is critical 
      * <strong>because HashMap uses power-of-two length hash tables</strong>, that 
      * otherwise encounter collisions for hashCodes that do not differ 
      * in lower bits. Note: Null keys always map to hash 0, thus index 0. 
      */  
     static int hash(int h) {  
         // This function ensures that hashCodes that differ only by  
         // constant multiples at each bit position have a bounded  
         // number of collisions (approximately 8 at default load factor).  
         h ^= (h >>> 20) ^ (h >>> 12);  
         return h ^ (h >>> 7) ^ (h >>> 4);  
     }  
      
     /** 
      * Returns index for hash code h. 
      */  
     static int indexFor(int h, int length) {  
         return h & (length-1);  
     }  




hash 根据 原hashCode产生更好的散列值， 因为table的容量大小刚好为2的整数幂， 所以必须这样做，否则hash code的高位将浪费(取模时) --- 见上面除法散列


indexFor： 等于 h % length,


所以，HashMap 采用 改进的除法散列

再看看 addEntry

  
  


   
   


    
    

     
     Java代码  
    
    


   
   


  
  




    void addEntry(int hash, K key, V value, int bucketIndex) {  
        Entry<K, V> e = table[bucketIndex];  
        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);  
        if (size++ >= threshold)  
            resize(2 * table.length);  
    }  




table 也成倍扩展的





                

        

        

    

  


    

      

        

            

              
                
                  FG2006
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
数据结构与算法02丨如何抓住重点，系统高效地学习数据结构与算法？

				
			

			

				

					qq_53280238的博客
				

				

					07-13
					
					690
					
				

			

		

		

			
				
大部分数据结构和算法教材，在开篇都会给这两个概念下一个明确的定义。但是，这些定义都很抽象，对理解这两个概念并没有实质性的帮助，反倒会让你陷入死抠定义的误区。毕竟，我们现在学习，并不是为了考试，所以，概念背得再牢，不会用也就没什么用。虽然我们说没必要深挖严格的定义，但是这并不等于不需要理解概念。下面我就从广义和狭义两个层面，来帮你理解数据结构与算法这两个概念。从广义上讲，数据结构就是指一组数据的存储结构。算法就是操作数据的一组方法。图书馆储藏书籍你肯定见过吧？

			
		

	



                

            
              



	

		

			

				
					
最全算法学习资料汇总（附链接：书籍/网站/课程/面试/项目....），99%的人都收藏了！！

				
			

			

				

					Codeforest_cloud的博客
				

				

					01-06
					
					1179
					
				

			

		

		

			
				
算法是计算机科学领域最重要的基石之一，算法工程师也是数据科学领域最重要的岗位之一。因此，今天小会整理出一些算法相关学习资源，包括书籍、算法刷题网站、项目资源、视频课程、面试要领这5个方面，欢迎大家收藏并转发哦。
争取做到，看完这一篇，算法相关学习资料全掌握！话不多说，这就开始吧！
一：书籍推荐
【入门阶段】
1、啊哈！算法（豆瓣评分7.7）
这是一本充满智慧和趣味的算法入门书。没有枯燥的描述，没有难懂的公式，一切以实际应用为出发点，通过幽默的语言配以可爱的插图来讲解算法。你更像是在阅读一个个轻松的小故事或是

			
		

	



              


  
              

                


	

		

			

				
					
《算法导论》读书笔记7 (散列表)

				
			

			

				

					笨笨的专栏
				

				

					01-14
					
					134
					
				

			

		

		

			
				
《算法导论》第三部分 数据结构 略过栈 队列 链表，我们到了 散列表
 
散列表是最常用的数据结构之一，特别是 ruby js等动态语言在语法层次上对它进行了支持。只是在java中，有那么点点绕(每次使用的时候，心里会疙瘩一下，不知道你们有没有这种感觉)。
 
本章真是纠结，因为看得懂的以前都看过，不懂的现在还是看不懂。 还好看不懂的部分都是加星号的。
 
 
散列表是这样一个东西：...

			
		

	





	

		

			

				
					
速度之王 — LZ4压缩算法

				
			

			

				

					WHACKW的专栏
				

				

					08-05
					
					5587
					
				

			

		

		

			
				
LZ4 (Extremely Fast Compression algorithm) 
项目：http://code.google.com/p/lz4/ 
作者：Yann Collet 
本文作者：zhangskd @ csdn blog简介LZ4 is a very fast lossless compression algorithm, providing compression speed a

			
		

	



		

			
		



	

		

			

				
					
数据结构与算法分析：哈希表

				
			

			

				

					liyuefeilong的专栏
				

				

					09-25
					
					8816
					
				

			

		

		

			
				
哈希表又叫散列表，是实现字典操作的一种有效数据结构。哈希表的查询效率极高，在没有冲突（后面会介绍）的情况下可做到一次存取便能得到所查记录，在理想情况下，查找一个元素的平均时间为O(1)（最差情况下散列表中查找一个元素的时间与链表中查找的时间相同：O(n)，但实际情况中一般散列表的性能是比较好的）。

			
		

	





	

		

			

				
					
算法导论十一章：散列表

				
			

			

				

					longhuihu的专栏
				

				

					11-30
					
					2361
					
				

			

		

		

			
				
实现字典的一种有效的数据结构为散列表，在最坏的情况下，在散列表中查找一个元素的时间与在链表中查找一个元素的时间相同，为Θ(n)。在实践中，散列技术的效率是很高的，在一些合理的假设下，在散列表中查找一个元素的期望时间为O(1)。散列表是普通数组概率的推广。 11.1直接寻址表当关键字的全域U比较小时，直接寻址时一种简单而有效的技术。假设某个动态集合都一个取自全域U={0,1,...,m-1}的关键字，假设没有两个元素具有相同的关键字。我们用一个数组T[0...m-1](直接寻址表)，每个位置对应全域U中的一个

			
		

	





	

		

			

				
					
XXTEA加密算法 -- 高效加密解密 JAVA C# 兼容版

				
			

			

				

					810364804
				

				

					08-07
					
					728
					
				

			

		

		

			
				

先介绍一下XXTEA算法的相关知识：
  TEA（Tiny Encryption Algorithm）是一种小型的对称加密解密算法，支持128位密码，与BlowFish一样TEA每次只能加密/解密8字节数据。TEA特点是速度快、效率高，实现也非常简单。由于针对TEA的攻击不断出现，所以TEA也发展出几个版本，分别是XTEA、Block
 TEA和XXTEA。  TEA加密和解密时都使用一个...

			
		

	





	

		

			

				
					
原创 | 初学者友好！最全算法学习资源汇总（附链接）

				
			

			

				

					数据派THU
				

				

					08-24
					
					1561
					
				

			

		

		

			
				
在计算机发展飞速的今天，也许有人会问，“今天计算机这么快，算法还重要吗？”其实永远不会有太快的计算机，因为我们总会想出新的应用。虽然在摩尔定律的作用下，计算机的计算能力每年都在飞快增长，...

			
		

	





	

		

			

				
					
远程CG教育的视觉计算与图形合成任务——在线课程的设计与实施

				
			

			

				

					
				

			

		

		

			
				
日本Ar ticlei n f o ab st ract文章历史记录：2020年12月31日收到2021年4月13日修订2021年4月14日接受2021年4月22日在线提供关键词：在线教材学习流行病时间云计算GPGPU路径跟踪考虑到视觉计算中图像感知/识别...

			
		

	





	

		

			

				
					
总结了200道经典的机器学习面试题（附参考答案）

				
			

			

				

					small-guo
				

				

					07-01
					
					7642
					
				

			

		

		

			
				
刷题，是面试前的必备环节。本文总结了往年BAT机器学习面试题，干货满满，值得收藏。想要入职大厂可谓是千军万马过独木桥。为了通过层层考验，刷题肯定是必不可少的。本文根据网络在线发布的BAT机器学习面试1000题系列，整理了一份面试刷题宝典。1.请简要介绍下SVM。SVM，全称是support vector machine，中文名叫支持向量机。SVM是一个面向数据的分类算法，它的目标是为确定一个分类超平面，从而将不同的数据分隔开。扩展：支持向量机学习方法包括构建由简至繁的模型：线性可分支持向量机、线性支持向量机

			
		

	





	

		

			

				
					
java 基于取模实现分表获取表名

				
			

			

				

					u013658068的专栏
				

				

					06-06
					
					390
					
				

			

		

		

			
				
java 基于取模实现分表获取表名

			
		

	





	

		

			

				
					
[asp.net]登录协同工作平台安全解决方式

				
			

			

				

					weixin_30810583的博客
				

				

					03-13
					
					258
					
				

			

		

		

			
				
版权声明：本文为博主原创文章，未经博主同意不得转载。					https://blog.csdn.net/david_520042/article/details/25372207				
								            
						
...

			
		

	





	

		

			

				
					
从头到尾彻底解析Hash表算法

				
			

			

				

					weixin_30698527的博客
				

				

					10-07
					
					483
					
				

			

		

		

			
				
转自：http://kb.cnblogs.com/page/189480/
作者：July、wuliming、pkuoliver
　　说明：本文分为三部分内容，第一部分为一道百度面试题Top K算法的详解；第二部分为关于Hash表算法的详细阐述；第三部分为打造一个最快的Hash表算法。
　　第一部分：Top K 算法详解
　　问题描述（百度面试题）：
　　搜索引擎会通过日志文件把用户每...

			
		

	





	

		

			

				
					
哈希表（散列表）原理详解

				
			

			

				

					Mr.Steven  专注于Java
				

				

					12-01
					
					1387
					
				

			

		

		

			
				
转载：写的很好，大佬地址http://blog.csdn.net/duan19920101/article/details/51579136 
什么是哈希表？ 
   哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

			
		

	





	

		

			

				
					
乘法散列表的分析

				
			

			

				

					For free
				

				

					08-22
					
					1643
					
				

			

		

		

			
				
构造乘法散列表的乘法方法包含了两个步骤：
1. 用关键字 K 乘上常数 A (0
2. 然后再用 m 乘以这个值，再向下去整
总之散列函数为：
h(k) = |_ (m*(k*Amod1)) _|
 
这里对m没有太大的要求，一般选择他为2的某个幂次方( m 的取值规定了hash的长度)
Knuth提出 A 的最佳选择为 A ≈ (√5-1)/2 = 0.618 033 988 7.

			
		

	





	

		

			

				
					
深⼊理解指针2

					
最新发布

				
			

			

				

					ElePower9527的博客
				

				

					11-01
					
					644
					
				

			

		

		

			
				
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外•    sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。

			
		

	





	

		

			

				
					
数对的最大曼哈顿距离[ABC178E] Dist Max

				
			

			

				

					2301_80882026的博客
				

				

					10-30
					
					523
					
				

			

		

		

			
				
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;

			
		

	





	

		

			

				
					
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100

				
			

			

				

					weixin_47868976的博客
				

				

					10-31
					
					1100
					
				

			

		

		

			
				
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。

			
		

	





	

		

			

				
					
C++学习：数据结构与算法分析笔记

				
			

			

				

					
				

			

		

		

			
				
"C++数据结构与算法的学习笔记，涵盖了数据结构、算法分析以及相关编程概念，旨在帮助学习者掌握核心编程技巧并提升问题解决能力。"  在这份"C++数据结构与算法学习笔记"中，重点讲解了以下几个关键知识点：  1. **...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值