链地址法

解决哈希表冲突的方法：开发地址法，链地址法

开发地址法：虽然解决了问题，但是1和101,1占据了一个数组，101只能向下，占据了2的数组，此时来一个取余为2 的值呢，只能向下继续寻找，同理，每一个来的值都只能向下寻找，为了解决这个问题，引入了链地址法

链地址法：在哈希表每一个单元中设置链表，某个数据项对的关键字还是像通常一样映射到哈希表的单元中，而数据项本身插入到单元的链表中。简单理解如下：

 来一个相同的数据，就将它插入到单元对应的链表中，在来一个相同的，继续给链表中插入。

定义结点：

/*
 * 链结点，相当于是车厢
 */
public class Node {
    //数据域
    public Info info;
    //指针域
    public Node next;
    
    public Node(Info info) {
        this.info = info;
    }
    
}

 

初始化：

/**
 * 员工信息类
 * @author Administrator
 *
 */
public class Info {
    private String key;
    private String name;
    
    public Info(String key, String name) {
        this.key = key;
        this.name = name;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    
}

 

定义链表：

/*
 * 链表，相当于火车
 */
public class LinkList {
    //头结点
    private Node first;
    
    public LinkList() {
        first = null;
    }
    
    /**
     * 插入一个结点，在头结点后进行插入
     */
    public void insertFirst(Info info) {
        Node node = new Node(info);
        node.next = first;
        first = node;
    }
    
    /**
     * 删除一个结点，在头结点后进行删除
     */
    public Node deleteFirst() {
        Node tmp = first;
        first = tmp.next;
        return tmp;
    }
    
    
    /**
     * 查找方法
     */
    public Node find(String key) {
        Node current = first;
        while(!key.equals(current.info.getKey())) {
            if(current.next == null) {
                return null;
            }
            current = current.next;
        }
        return current;
    }
    
    /**
     * 删除方法，根据数据域来进行删除
     */
    public Node delete(String key) {
        Node current = first;
        Node previous = first;
        while(!key.equals(current.info.getKey())) {
            if(current.next == null) {
                return null;
            }
            previous = current;
            current = current.next;
        }
        
        if(current == first) {
            first = first.next;
        } else {
            previous.next = current.next;
        }
        return current;
        
    }
}

 

 定义方法：

import java.math.BigInteger;

public class HashTable {
    private LinkList[] arr;
    
    /**
     * 默认的构造方法
     */
    public HashTable() {
        arr = new LinkList[100];
    }
    
    /**
     * 指定数组初始化大小
     */
    public HashTable(int maxSize) {
        arr = new LinkList[maxSize];
    }
    
    /**
     * 插入数据
     */
    public void insert(Info info) {
        //获得关键字
        String key = info.getKey();
        //关键字所自定的哈希数
        int hashVal = hashCode(key);
        if(arr[hashVal] == null) {
            arr[hashVal] = new LinkList();
        }
        arr[hashVal].insertFirst(info);
    }
    
    /**
     * 查找数据
     */
    public Info find(String key) {
        int hashVal = hashCode(key);
        return arr[hashVal].find(key).info;
    }
    
    /**
     * 删除数据
     * @param key
     * @return
     */
    public Info delete(String key) {
        int hashVal = hashCode(key);
        return arr[hashVal].delete(key).info;
    }
    
    public int hashCode(String key) {
//        int hashVal = 0;
//        for(int i = key.length() - 1; i >= 0; i--) {
//            int letter = key.charAt(i) - 96;
//            hashVal += letter;
//        }
//        return hashVal;
        
        BigInteger hashVal = new BigInteger("0");
        BigInteger pow27 = new BigInteger("1");
        for(int i = key.length() - 1; i >= 0; i--) {
            int letter = key.charAt(i) - 96;
            BigInteger letterB = new BigInteger(String.valueOf(letter));
            hashVal = hashVal.add(letterB.multiply(pow27));
            pow27 = pow27.multiply(new BigInteger(String.valueOf(27)));
        }
        return hashVal.mod(new BigInteger(String.valueOf(arr.length))).intValue();
    }
}

 

进行测试：

public class TestHashTable {
    public static void main(String[] args) {
        HashTable ht = new HashTable();
        ht.insert(new Info("a","张三"));
        ht.insert(new Info("ct","李四"));
        ht.insert(new Info("b","王五"));
        ht.insert(new Info("dt","赵柳"));
        
        System.out.println(ht.find("a").getName());
        System.out.println(ht.find("ct").getName());
        System.out.println(ht.find("b").getName());
        System.out.println(ht.find("dt").getName());
        
//        System.out.println(ht.hashCode("a"));
//        System.out.println(ht.hashCode("ct"));
        
        System.out.println(ht.delete("a").getName());
        System.out.println(ht.find("a").getName());

    }
}