数据结构之映射

映射

使用链表实现映射

创建Map接口以及实现类。

public interface Map<K, V> {
        void add(K key, V value);
        V remove(K key);
        boolean contains(K key);
        V get(K key);
        void set(K key, V value);
        int getSize();
        boolean isEmpty();
}

public class LinkedListMap<K, V> implements Map<K, V> {
        private class Node {
            public K key;
            public V value;
            public Node next;
            public Node(K key, V value, Node next) {
                this.key = key;
                this.value = value;
                this.next = next;
            }
            public Node(K key, V value) {
                this(key, value, null);
            }
            public Node() {
                this(null, null, null);
            }
            @Override
            public String toString() {
                return key.toString() + ":" + value.toString();
            }
        }
        private Node dummyHead;
        private int size;
        public LinkedListMap() {
            dummyHead = new Node();
            size = 0;
        }
        private Node getNode(K key) {
            Node cur = dummyHead.next;
            while (cur != null) {
                if (cur.key.equals(key)) {
                    return cur;
                }
                cur = cur.next;
            }
            return null;
        }
        @Override
        public void add(K key, V value) {
            Node node = getNode(key);
            if (node == null) {
                dummyHead.next = new Node(key, value, dummyHead.next);
                size++;
            } else {
                node.value = value;
            }
        }
        @Override
        public V remove(K key) {
            Node prev = dummyHead;
            while (prev.next != null) {
                if (prev.next.key.equals(key)) {
                    break;
                }
                prev = prev.next;
            }
            if (prev.next == null) {
                Node delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
                size--;
                return delNode.value;
            }
            return null;
        }
        @Override
        public boolean contains(K key) {
            return getNode(key) != null;
        }
        @Override
        public V get(K key) {
            Node node = getNode(key);
            return node == null ? null : node.value;
        }
        @Override
        public void set(K key, V value) {
            Node node = getNode(key);
            if (node == null) {
                throw new IllegalArgumentException(key + " doesn't exist!");
            } else {
                node.value = value;
            }
        }
        @Override
        public int getSize() {
            return size;
        }
        @Override
        public boolean isEmpty() {
            return size == 0;
        }
    }

使用二分搜索树实现映射

public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {
        private class Node {
            public K key;
            public V value;
            public Node left, right;
            public Node(K key, V value) {
                this.key = key;
                this.value = value;
                left = null;
                right = null;
            }
        }
        private Node root;
        private int size;
        public BSTMap() {
            root = null;
            size = 0;
        }
        @Override
        public void add(K key, V value) {
            root = add(root, key, value);
        }
        private Node add(Node node, K key, V value) {
            if (node == null) {
                size++;
                return new Node(key, value);
            }
            if (key.compareTo(node.key) < 0) {
                node.left = add(node.left, key, value);
            } else if (key.compareTo(node.key) > 0) {
                node.right = add(node.right, key, value);
            } else {
                node.value = value;
            }
            return node;
        }
        private Node getNode(Node node, K key) {
            if (node == null) {
                return null;
            }
            if (key.compareTo(node.key) == 0) {
                return node;
            } else if (key.compareTo(node.key) < 0) {
                return getNode(node.left, key);
            } else {
                return getNode(node.right, key);
            }
        }
        @Override
        public V remove(K key) {
            Node node = getNode(root, key);
            if (node != null) {
                root = remove(root, key);
                return node.value;
            }
            return null;
        }
        private Node remove(Node node, K key) {
            if (node == null) {
                return null;
            }
            if (key.compareTo(node.key) < 0) {
                node.left = remove(node.left, key);
                return node;
            } else if (key.compareTo(node.key) > 0) {
                node.right = remove(node.right, key);
            } else {
                //待删除的左子树为空的情况
                if (node.left == null) {
                    Node rightNode = node.right;
                    node.right = null;
                    size--;
                    return rightNode;
                }
                //待删除的右子树为空的情况
                if (node.right == null) {
                    Node leftNode = node.left;
                    node.left = null;
                    size--;
                    return leftNode;
                }
                //待删除的节点左右子树均不为空的情况
                //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
                //用这个节点代替删除的节点的位置
                Node successor = minimum(node.right);
                successor.right = removeMin(node.right);
                successor.left = node.left;
                node.left = node.right = null;
                return successor;
            }
            return null;
        }
        private Node minimum(Node node) {
            if (node.left == null) {
                return node;
            }
            return minimum(node.left);
        }
        private Node removeMin(Node node) {
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            node.left = removeMin(node.left);
            return node;
        }
        @Override
        public boolean contains(K key) {
            return getNode(root, key) != null;
        }
        @Override
        public V get(K key) {
            Node node = getNode(root, key);
            return node != null ? node.value : null;
        }
        @Override
        public void set(K key, V value) {
            Node node = getNode(root, key);
            if (node == null) {
                throw new IllegalArgumentException(key + "doesn't exist !");
            } else {
                node.value = value;
            }
        }
        @Override
        public int getSize() {
            return size;
        }
        @Override
        public boolean isEmpty() {
            return size == 0;
        }
}

映射的时间复杂度分析

操作	LinkedListMap	BSTMap
增 add	O(n)	O(logn)
删 remove	O(n)	O(logn)
改 set	O(n)	O(logn)
查 get	O(n)	O(logn)
查 contains	O(n)	O(logn)