二分搜索树和链表实现映射

二分搜索树:

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 k, V value) {
			this.key = key;
			this.value = value;
			left = null;
			right = null;
		}
	}

	private Node root;
	private int size;

	public BSTMap() {
		root = null;
		size = 0;
	}

	public int getSize() {
		return size;
	}

	public boolean isEmpty() {
		return size == 0;
	}

	public void add(K key, V value) {
		root = add(root, key, value);
	}

	// 向以node为根的二分搜索树中插入元素(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;
	}

	// 返回以node为根节点的二分搜索树中，key所在的节点
	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);
	}

	public boolean contains(K key) {
		return getNode(root, key) != null;
	}

	public V get(K key) {
		Node node = getNode(root, key);
		return node == null ? null : node.value;
	}

	public void set(K key, V newValue) {
		Node node = getNode(root, key);
		if (node == null)
			throw new IllegalArgumentException(key + " doesn't exist!");

		node.value = newValue;
	}

	// 返回以node为根的二分搜索树的最小值所在的节点
	private Node minimum(Node node) {
		if (node.left == null)
			return node;
		return minimum(node.left);
	}

	// 删除掉以node为根的二分搜索树中的最小节点
	// 返回删除节点后新的二分搜索树的根
	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;
	}

	public V remove(K key) {
		Node node = getNode(root, key);
		if (node != null) {
			root = remove(root, key);
			return node.value;
		}
		return null;
	}

	// 删除以node为根的二分搜索树中键为key的节点，递归算法
	// 返回删除节点后新的二分搜索树的根
	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(key) > 0) {
			node.right = remove(node.right, key);
			return node;
		} else {// e==node.e
				// 待删除节点左子树为空的情况
			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;
		}
	}

}

链表:

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) {
			this(key, null, null);
		}

		public Node() {
			this(null, null, null);
		}

		public String toString() {
			return key.toString() + " : " + value.toString();
		}
	}

	private Node dummyhead;
	private int size;

	public LinkedListMap() {
		dummyhead = new Node();
		size = 0;
	}

	public int getSize() {
		return size;
	}

	public boolean isEmpty() {
		return 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;
	}

	public boolean contains(K key) {
		return getNode(key) != null;
	}

	public V get(K key) {
		Node node = getNode(key);
		return node == null ? null : node.value;
	}

	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;
		}
	}

	public void set(K key, V newValue) {
		Node node = getNode(key);
		if (node == null)
			throw new IllegalArgumentException(key + " doesn't exist!");

		node.value = newValue;
	}

	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;
	}
}