算法很美 笔记 10.哈希表、哈希映射

10.哈希表、哈希映射

1.HashMap,HashSet

基本概念

• 若关键字为k ,则其值存放在f(k)的存储位置上。由此,不需比较便可直接取得所查记录。称这个对应关系f为散列函数,按这个思想建立的表为散列表。

• 对不同的关键字可能得到同一散列地址,即k1≠k2 ,而f(k1)=f(k2) ,这种现象称为冲突(英语: Collision)。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述,根据散列函数f(k)和处理冲突的方法将一组关键字映射到一个有限的连续的地址集(区间).上,并以关键字在地址集中的“像”作为记录在表中的存储位置,这种表便称为散列表,这一映射过程称为散列造表或散列,所得的存储位置称散列地址。

压缩映射

两个关键

• 散列函数

  • 直接定址法

  • 数字分析法

  • 平方取中法

  • 折叠法

  • 随机数法

  • 除留余数法

• 冲突解决

  • 开放定址法

  • 拉链法

  • 双散列

  • 再散列

Java的HashMap

public class HashMapTest {
    public static void main(String[] args) {
        testHashMapAPIs();
    }
    private static void testHashMapAPIs() {
        // 初始化随机种子
        Random r = new Random();
        // 新建HashMap
        HashMap map = new HashMap();
        // 添加操作
        map.put("one", r.nextInt(10));
        map.put("one", r.nextInt(10));
        map.put("two", r.nextInt(10));
        map.put("three", r.nextInt(10));

        // 打印出map
        System.out.println("map:" + map);

        // 通过Iterator遍历key-value
        Iterator iter = map.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            System.out.println("next : " + entry.getKey() + " - " + entry.getValue());
        }

        // HashMap的键值对个数
        System.out.println("size:" + map.size());

        // containsKey(Object key) :是否包含键key
        System.out.println("contains key two : " + map.containsKey("two"));
        System.out.println("contains key five : " + map.containsKey("five"));

        // containsValue(Object value) :是否包含值value
        System.out.println("contains value 0 : " + map.containsValue(new Integer(0)));

        // remove(Object key) ： 删除键key对应的键值对
        map.remove("three");

        System.out.println("map:" + map);

        // clear() ： 清空HashMap
        map.clear();

        // isEmpty() : HashMap是否为空
        System.out.println((map.isEmpty() ? "map is empty" : "map is not empty"));
    }
}

map:{one=9, two=0, three=9}
next : one - 9
next : two - 0
next : three - 9
size:3
contains key two : true
contains key five : false
contains value 0 : true
map:{one=9, two=0}
map is empty

1. 扩容负载因子
2. 拉链边长，转为红黑树
3. 优化hash函数

2.布隆过滤器

基本概念

• 布隆过滤器(英语:Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。

• 如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。链表、树、散列表(又叫哈希表,Hash table)等数据结构都是这种思路。但是随着集合中元素的增加，我们需要的存储空间越来越大。同时检索速度也越来越慢，上述三种结构的检索时间复杂度分别为O(n),O(logn),O(n/k)。布隆过滤器的原理是，当一个元素被加入集合时，通过K个散列函数将这个元素映射成一个位数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0，则被检元素一定不在;如果都是1，则被检元素很可能在。这就是布隆过滤器的基本思想。

• 一个Bloom Filter是基于一个m位的位向量(1…bm) ，这些位向量的初始值为0。另外，还有一
  系列的hash函数(h…hk)，这些hash函数的值域属于1~m。下图是一个bloom filter插入x,y,z并
  判断基个值w是否在该数据集的示意图:

不用保存原始的数据，只存储位图

简化版实现

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

/**简化版本的布隆过滤器的实现*/
public class BloomFilter {
    public static final int NUM_SLOTS = 1024 * 1024 * 8;//位图的长度
    public static final int NUM_HASH = 8;//hash函数的个数，一个hash函数的结果用于标记一个位
    private BigInteger bitmap = new BigInteger("0");//位图

    public static void main(String[] args) {
        //测试代码
        BloomFilter bf = new BloomFilter();
        ArrayList<String> contents = new ArrayList<>();
        contents.add("sldkjelsjf");
        contents.add("ggl;ker;gekr");
        contents.add("wieoneomfwe");
        contents.add("sldkjelsvrnlkjf");
        contents.add("ksldkflefwefwefe");

        for (int i = 0; i < contents.size(); i++) {
            bf.addElement(contents.get(i));
        }
        System.out.println(bf.check("sldkjelsvrnlkjf"));
        System.out.println(bf.check("sldkjelnlkjf"));
        System.out.println(bf.check("ggl;ker;gekr"));
    }

    /**将message+n映射到0~NUM_SLOTS-1之间的一个值*/
    private int hash(String message, int n) {
        message = message + String.valueOf(n);
        try {
            MessageDigest md5 = MessageDigest.getInstance("md5");//将任意输入映射成128位（16个字节）整数的hash函数
            byte[] bytes = message.getBytes();
            md5.update(bytes);
            byte[] digest = md5.digest();
            BigInteger bi = new BigInteger(digest);//至此，获得message+n的md5结果（128位整数）

            return Math.abs(bi.intValue()) % NUM_SLOTS;
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(BloomFilter.class.getName()).log(Level.SEVERE, null, ex);
        }
        return -1;
        // return (int)Math.abs(HashFunctions.bernstein(message,NUM_SLOTS));
    }

    /*处理原始数据
     * 1.hash1(msg)标注一个位……  hash的值域0~NUM_SLOTS-1
     * */
    public void addElement(String message) {
        for (int i = 0; i < NUM_HASH; i++) {
            int hashcode = hash(message, i);//代表了hash1，hash2……hash8
            //结果，用于标注位图的该位为1
            if (!bitmap.testBit(hashcode)) {//如果还不为1
                //标注位图的该位为1
                bitmap = bitmap.or(new BigInteger("1").shiftLeft(hashcode));
            }
        }

    }

    public boolean check(String message) {
        for (int i = 0; i < NUM_HASH; i++) {
            int hashcode = hash(message, i);
            //hashcode代表一个位置
            if (!this.bitmap.testBit(hashcode)) {
                //如果位图的该位为0，那么message一定不存在
                return false;
            }
        }
        return true;//不精确，有可能误判
    }
}

3.一致性hash

缓存集群/负载均衡

基本思路

先构造一个长度为232的整数环(这个环被称为一致性Hash环),根据节点名称的Hash值(其分布为[0, 232-1])将缓存服务器节点放置在这个Hash环上,然后根据需要缓存的数据的Key值计算得到其Hash值(其分布也为[0, 232-1]),然后在Hash环上顺时针查找距离这个Key值的Hash值最近的服务器节点,完成Key到服务器的映射查找。

增加/删除节点

• 如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中

• 按顺时针迁移的规则，那么被分割的对象被迁移到了NODE4中其它对象还保持这原有的存储位置。

数据倾斜

• 如果机器较少，很有可能造成机器在整个环上的分布不均匀，从而导致机器之间的负载不均衡

虚拟节点

代码实现

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.*;

/*不考虑数据倾斜*/
public class ConsistentHashing1 {
    //hash算法，将关键字映射到2^32的环状空间里面
    static long hash(String key) {
        ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
        int seed = 0x1234ABCD;
        ByteOrder byteOrder = buf.order();
        buf.order(ByteOrder.LITTLE_ENDIAN);
        long m = 0xc6a4a7935bd1e995L;
        int r = 47;
        long h = seed ^ (buf.remaining() * m);
        long k;
        while (buf.remaining() >= 8) {
            k = buf.getLong();
            k *= m;
            k ^= k >>> r;
            k *= m;

            h ^= k;
            h *= m;
        }
        if (buf.remaining() > 0) {
            ByteBuffer finish = ByteBuffer.allocate(8).order(
                    ByteOrder.LITTLE_ENDIAN);
            // for big-endian version, do this first:
            // finish.position(8-buf.remaining());
            finish.put(buf).rewind();
            h ^= finish.getLong();
            h *= m;
        }
        h ^= h >>> r;
        h *= m;
        h ^= h >>> r;

        buf.order(byteOrder);
        return Math.abs(h);
    }

    //机器节点==网络节点
    static class Node implements HashNode {
        String name;
        String ip;
        public Node(String name, String ip) {
            this.name = name;
            this.ip = ip;
        }
        @Override
        public String toString() {
            return this.name + "-" + this.ip;
        }
        @Override
        public String getName() {
            return name;
        }
    }

    interface HashNode {
        String getName();
    }

    //  节点列表
    List<Node> nodes;
    TreeMap<Long, Node> hashAndNode = new TreeMap<>();
    TreeMap<Long, Node> keyAndNode = new TreeMap<>();

    public ConsistentHashing1(List<Node> nodes) {
        this.nodes = nodes;
        init();
    }

    private void init() {
        for (int i = 0; i < nodes.size(); i++) {
            Node node = nodes.get(i);
            long hash = hash(node.ip);
            hashAndNode.put(hash, node);
        }
    }

    private void add(String key) {
        long hash = hash(key);
        SortedMap<Long, Node> subMap = hashAndNode.tailMap(hash);//找到map中key比fromKey大的所有的键值对，组成一个子Map
        if (subMap.size() == 0) {//hash值大于所有机器的hash归属于第一台机器
            keyAndNode.put(hash, hashAndNode.firstEntry().getValue());
        } else {//在大于hash中找到最小，
            Node node = subMap.get(subMap.firstKey());//第一个节点，key应该归属的节点
            keyAndNode.put(hash, node);
        }
    }

    /**
     * 增加一个新的机器节点
     * @param newNode
     */
    private void add(Node newNode) {
        long hash = hash(newNode.ip);
        hashAndNode.put(hash, newNode);
        //  数据迁移
        SortedMap<Long, Node> pre = hashAndNode.headMap(hash);//key小于hash的子map
        if (pre.size() == 0) {
            SortedMap<Long, Node> between = keyAndNode.subMap(0L, hash);
            for (Map.Entry<Long, Node> e : between.entrySet()) {
                e.setValue(newNode);
            }
            between = keyAndNode.tailMap(hashAndNode.lastKey());
            for (Map.Entry<Long, Node> e : between.entrySet()) {
                e.setValue(newNode);
            }
        } else {
            long from = pre.lastKey();
            long to = hash;
            SortedMap<Long, Node> between = keyAndNode.subMap(from, to);
            for (Map.Entry<Long, Node> e : between.entrySet()) {
                e.setValue(newNode);
            }
        }
    }

    public static void main(String[] args) {
        List<Node> nodes = new ArrayList<>();
        nodes.add(new Node("node1", "192.168.1.2"));
        nodes.add(new Node("node2", "192.168.1.3"));
        nodes.add(new Node("node3", "192.168.1.4"));
        nodes.add(new Node("node4", "192.168.1.5"));
        nodes.add(new Node("node5", "192.168.1.6"));
        ConsistentHashing1 obj = new ConsistentHashing1(nodes);
        for (Map.Entry<Long, Node> entry :
                obj.hashAndNode.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue().getName());
        }
        obj.add("a");
        obj.add("b");
        obj.add("c");
        obj.add("e");
        obj.add("zhangsan");
        obj.add("lisi");
        obj.add("wangwu");
        obj.add("zhaoliu");
        obj.add("wangchao");
        obj.add("mahan");
        obj.add("zhanglong");
        obj.add("zhaohu");
        obj.add("baozheng");
        obj.add("gongsun");
        obj.add("zhanzhao");
        for (Map.Entry<Long, Node> entry :
                obj.keyAndNode.entrySet()) {
            System.out.println(entry.getKey() + " ,归属到:" + entry.getValue().getName());
        }
        System.out.println("===========");
        obj.add(new Node("node6", "192.168.1.77"));
        for (Map.Entry<Long, Node> entry :
                obj.keyAndNode.entrySet()) {
            System.out.println(entry.getKey() + " ,归属到:" + entry.getValue().getName());
        }
    }
}

4.题解

1、位（bit） 来自英文bit，音译为“比特”，表示二进制位。

2、字节（byte） 字节来自英文Byte，音译为“拜特”，习惯上用大写的“B”表示

题1:出现次数最多的数

有一个包含20亿个全是32位整数的大文件，在其中找到出现次数最多的数

通常的做法是使用hashmap

（4字节int型）key—具体的某一种数

（4字节int型）value—这种数出现的次数

那么一条key-value记录占有8字节

当记录数为2亿时，大约占用1.6G内存

那么如果20亿数据全部不相同，明显内存会溢出

优化解决方法：

使用哈希函数进行分流成16个小文件，由于哈希函数的性质，同一种数不会被分流到不同文件，而且对于不同的数，因为哈希函数分流是比较均匀的分配的，所以一般不会出现一个文件含有2亿个不同的整数情况，每个文件含有的种树也几乎一样

然后分别计算出每个文件中出现次数的第一名。

然后对这些第一名全部拿出来进行排序即可

题2:所有没出现过的数

32位无符号整数的范围是0~4294967295，现在有一个正好包含40亿个无符号整数的文件，所以在整个范围中必然有没出现过的数。可以使用最多1G的内存，怎么找到所有没出现过的数。

申请一个bit数组，数组大小为4294967295，大概为40亿bit，40亿/8 = 5亿字节，那么需要0.5G空间， bit数组的每个位置有两种状态0和1，那么怎么使用这个bit数组呢？呵呵，数组的长度刚好满足我们整数的个数范围，那么数组的每个下标值对应4294967295中的一个数，逐个遍历40亿个无符号数，例如，遇到100，则bitArray[100] = 1,遇到9999，则bitArray[9999] = 1,遍历完所有的数，将数组相应位置变为1。

题3:重复的URL

找到100亿个URL中重复的URL以及搜索词汇的topK问题。使用哈希函数进行分流成n个机器，n个机器又分流成n个小文件。利用小根堆排序选出每个文件top100，然后再进行整理选出每台机器的top100,最终再次整理得到总的top100(利用堆排序处理topK 的问题比较方便，时间复杂度为nlogn)