手写hashMap（排序版）

手写的 HashMap 里，链表元素按value排列

LeetCode版 706题，按value排序

public class LC706_排序 {
    //链表节点
    private class Node {
        int key;
        int value;
        Node next;

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

    //数组长度
    private final int N = 10000;
    private Node[] node;

    public LC706_排序() {
        node = new Node[N];
    }

    //哈希函数
    private int hash(int key) {
        return key % N;
    }

    public void put(int key, int value) {
        int hash = hash(key);
        if (node[hash] == null) {
            //先存虚拟头
            node[hash] = new Node(-1, -1);
            //再存实际头节点
            node[hash].next = new Node(key, value);
        } else {
            //从虚拟头开始遍历
            Node prev = node[hash];
            Node temp = prev;
            while (temp.next != null) {
                if (temp.next.key == key) {
                    //有键，更新值
                    temp.next.value = value;
                    //按value进行排序，归并排序
                    prev.next = sortList(prev.next);
                    return;
                }
                temp = temp.next;
            }
            //没有键，添加节点
            temp.next = new Node(key, value);
        }
    }

    public Node sortList(Node head) {
        if (head == null || head.next == null) {
            return head;
        }
        Node slow = head;
        Node fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        Node tmp = slow.next;
        slow.next = null;
        Node left = sortList(head);
        Node right = sortList(tmp);
        Node pre = new Node(0, 0);
        Node res = pre;
        while (left != null && right != null) {
            //小于0，升序。大于等于0，降序
            if (left.value < right.value) {
                pre.next = left;
                left = left.next;
            } else {
                pre.next = right;
                right = right.next;
            }
            pre = pre.next;
        }
        pre.next = left != null ? left : right;
        return res.next;
    }

    public int get(int key) {
        int hash = hash(key);
        if (node[hash] != null) {
            Node cur = node[hash].next;
            while (cur != null) {
                if (cur.key == key) {
                    return cur.value;
                }
                cur = cur.next;
            }
        }
        return -1;
    }

    public void remove(int key) {
        int hash = hash(key);
        if (node[hash] != null) {
            Node prev = node[hash];
            while (prev.next != null) {
                //删除节点
                if (prev.next.key == key) {
                    Node delNode = prev.next;
                    prev.next = delNode.next;
                    delNode.next = null;
                    return;
                }
                prev = prev.next;
            }
        }
    }
}

---

---

---

hashMap源码版

public interface MyMap2 {
    //接口中的方法默认使用的 public abstract 修饰
    int put(Integer key, Integer value);

    int get(Integer key);

    int size();

    interface Entry {
        int getKey();

        int getValue();
    }
}

public class 手写HashMap implements MyMap2 {
    //容量
    private int capacity;
    //元素表
    private Node[] table;
    //元素数量
    private int size;

    class Node implements Entry {
        //key的哈希值
        private int hash;
        private int key;
        private int value;
        //下一个节点
        private Node next;

        public Node(int hash, int key, int value, Node next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        @Override
        public int getKey() {
            return key;
        }

        @Override
        public int getValue() {
            return value;
        }
    }

    //高低16位异或，计算 hash 值
    private int hash(Integer key) {
        int h;
        //>>右移，>>>右移补零
        return (key == 0) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    @Override
    public int put(Integer k, Integer v) {
        int oldValue = 0;
        int hash = hash(k);
        int index = hash & (capacity - 1);
        if (table[index] == null) {
            table[index] = new Node(hash, k, v, null);
            size++;
        } else {
            Node node = table[index];
            while (node != null) {
                if (node.hash == hash && k == node.getKey()) {
                    oldValue = node.getValue();
                    node.value = v;
                    return oldValue;
                }
                node = node.next;
            }
            table[index].next = new Node(hash, k, v, node);
            size++;
        }
        //对链表进行归并排序
        sortList(table[0]);
        return oldValue;
    }

    public Node sortList(Node head) {
        if (head == null || head.next == null) {
            return head;
        }
        Node slow = head;
        Node fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        Node tmp = slow.next;
        slow.next = null;
        Node left = sortList(head);
        Node right = sortList(tmp);
        Node h = new Node(0, 0, 0, null);
        Node res = h;
        while (left != null && right != null) {
            if (left.value < right.value) {
                h.next = left;
                left = left.next;
            } else {
                h.next = right;
                right = right.next;
            }
            h = h.next;
        }
        h.next = left != null ? left : right;
        return res.next;
    }

    @Override
    public int get(Integer k) {
        int hash = hash(k);
        int index = hash & (capacity - 1);
        if (table[index] == null) {
            return 0;
        } else {
            Node node = table[index];
            while (node != null) {
                if (node.hash == hash && k == node.getKey()) {
                    return node.value;
                } else {
                    node = node.next;
                }
            }
        }
        return 0;
    }

    @Override
    public int size() {
        return size;
    }
}