哈希表学习（设计哈希集合和哈希映射）

哈希表学习

哈希表（Hash Table），也称为散列表，是一种数据结构，用于实现键值对的存储和检索。在Java中，哈希表通常由java.util.HashMap类实现。

• 哈希表定义与操作
• 设计哈希集合
• 设计哈希映射

哈希集合：存储key
哈希映射：存储key-value

哈希函数

• 一致性
• 高效性
• 均匀性

哈希冲突

• 线性探测法
• 链地址法

哈希表定义与操作

HashMap的键必须是唯一的，但值可以重复。

import java.util.HashMap;
//定义
HashMap<String, Integer> hashMap = new HashMap<>();

//添加键值对
hashMap.put("apple", 5);

//获取值
int numberOfApples = hashMap.get("apple"); // 返回5

//检测包含某个键
boolean containsKey = hashMap.containsKey("banana"); // 返回false


//遍历哈希表的键或值
for (String key : hashMap.keySet()) {
    System.out.println("Key: " + key + ", Value: " + hashMap.get(key));
}

for (int value : hashMap.values()) {
    System.out.println("Value: " + value);
}

//删除键值对
hashMap.remove("apple");

//清空哈希表
hashMap.remove("cherry");

//获取大小
int size = hashMap.size();

哈希集合（HashSet）是一种集合数据结构，它用于存储一组唯一的元素，即集合中不允许重复的元素。哈希集合的实现通常基于哈希表，这使得插入、查找和删除元素的操作非常高效。
注意，哈希集合不保证元素的顺序，元素的顺序通常是不确定的。

import java.util.HashSet;

//定义
HashSet<String> hashSet = new HashSet<>();

//添加元素
hashSet.add("apple");

//移除元素
hashSet.remove("banana");

//检查元素是否存在
boolean containsGrape = hashSet.contains("grape");   // 返回false

//遍历集合
for (String fruit : hashSet) {
    System.out.println(fruit);
}

//清空集合
hashSet.clear();

705.设计哈希集合

class MyHashSet {
    private static final int cap=100000;
    List<Integer>[] data;

    public MyHashSet() {
        data=new LinkedList[cap];
        for(int i=0;i<cap;i++){
            data[i]=new LinkedList<Integer>(); 
        }
    }
    
    public void add(int key) {
        if(contains(key)){
            return;
        }
        int h=hash(key);
        if(data[h]==null){
            data[h]=new LinkedList<>();
        }
        data[h].add(key);

    }
    
    public void remove(int key) {
        int h=hash(key);
        List<Integer> bucketList=data[h];
        if(bucketList==null){return;}

        Iterator<Integer> iterator=bucketList.iterator();
        while(iterator.hasNext()){
            if(iterator.next()==key){
                iterator.remove();
                break;
            }
        }

    }
    
    public boolean contains(int key) {
        int h=hash(key);
        List<Integer> bucketList=data[h];
        for(Integer item:bucketList){
            if(item==key){
                return true;
            }
        }
        return false;
    }

    public static int hash(int key){
        return key % cap;
    }
}

706.设计哈希映射

在Java中，要设计HashMap，键的class必须实现hashCode()和equals()

class MyHashMap {

    private class Pair{
        private int key;
        private int value;

        public Pair(int key,int value){
            this.key=key;
            this.value=value;
        }

        public int getKey() {
            return key;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }



    private static final int cap=769;
    private LinkedList[] data;

    public MyHashMap() {
        data = new LinkedList[cap];
        for (int i = 0; i < cap; ++i) {
            data[i] = new LinkedList<Pair>();
        }

    }
    
    public void put(int key, int value) {
        int h=hash(key);
        Iterator<Pair> iterator=data[h].iterator();
        while(iterator.hasNext()){
            Pair pair=iterator.next();
            if (pair.getKey() == key) {
                pair.setValue(value);
                return;
            }
        
        }
        data[h].offerLast(new Pair(key, value));
    }
    
    public int get(int key) {
        int h=hash(key);
        Iterator<Pair> iterator=data[h].iterator();
        while(iterator.hasNext()){
            Pair pair=iterator.next();
            if(pair.getKey()==key){
                return pair.getValue();
            }
        }
        return -1;
    }
    
    public void remove(int key) {
        int h=hash(key);
        Iterator<Pair> iterator=data[h].iterator();
        while(iterator.hasNext()){
            Pair pair=iterator.next();
            if(pair.getKey()==key){
                data[h].remove(pair);
                return;
            }
        }

    }

    public int hash(int key){
        return key % cap;
    }
}