【數據結構】Java實現映射(Map)

• Map 在有些編程語言中也叫做字典（dictionary，比如 Python）
• Map 中的每一個 Key 是唯一的
• Map 中的每一個 Key 對應一個 Value

Map的接口定義（Map.java）

public interface Map<K, V> {
	int size();
	boolean isEmpty();
	void clear();
	V put(K key, V value);
	V get(K key);
	V remove(K key);
	boolean containsKey(K key);
	boolean containsValue(V value);
	void traversal(Visitor<K, V> visitor);
	
	public static abstract class Visitor<K, V> {
		boolean stop;
		public abstract boolean visit(K key, V value);
	}
}

紅黑樹實現 TreeMap

/**
 * 直接由紅黑樹實現的映射
 */
public class TreeMap<K, V> implements Map<K, V> {
	private static final boolean RED = false;
	private static final boolean BLACK = true;
	private int size;
	private Node<K, V> root;
	private Comparator<K> comparator;
	
	public TreeMap() {
		this(null);
	}
	public TreeMap(Comparator<K> comparator) {
		this.comparator = comparator;
	}
	
	/**
	 * 存放 key 和 value 的紅黑樹節點類
	 */
	private static class Node<K, V> {
		K key;
		V value;
		boolean color = RED;
		Node<K, V> left;
		Node<K, V> right;
		Node<K, V> parent;
		public Node(K key, V value, Node<K, V> parent) {
			this.key = key;
			this.value = value;
			this.parent = parent;
		}
		public boolean isLeaf() { // 是否爲葉子結點
			return left == null && right == null;
		}
		
		public boolean hasTwoChildren() { // 是否有兩個子節點
			return left != null && right != null;
		}
		
		public boolean isLeftChild() { // 是否爲左節點
			return parent != null && this == parent.left;
		}
		
		public boolean isRightChild() { // 是否爲右節點
			return parent != null && this == parent.right;
		}
		
		public Node<K, V> sibling() { // 返回兄弟節點
			if (isLeftChild()) {
				return parent.right;
			}
			
			if (isRightChild()) {
				return parent.left;
			}
			return null;
		}
	}
	
	public int size() {
		return size;
	}

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

	public void clear() {
		root = null;
		size = 0;
	}

	public V put(K key, V value) {
		KeyNotNullCheck(key); // 傳入元素不能爲空
		
		// 添加第一個節點
		if (root == null) {
			root = new Node<>(key, value, null);
			size++;

			// 新添加節點之後的處理
			// BST中無需處理，爲 AVL樹 和 B樹提供可覆蓋的方法
			afterPut(root);
			return null;
		}
		
		// 添加的不是第一個節點
		// 找到父節點
		Node<K, V> parent = root;
		Node<K, V> node = root;
		int cmp = 0;
		do {
			cmp = compare(key, node.key);
			parent = node;
			if (cmp > 0) {
				node = node.right;
			} else if (cmp < 0) {
				node = node.left;
			} else { // 相等
				// 相等時的操作按需求來定，這裏選擇了覆蓋
				node.key = key;
				V oldValue = node.value;
				node.value = value;
				return oldValue;
			}
		} while (node != null);

		// 通過上面的while循環找到了要插入節點的父節點
		// 看看插入到父節點的哪個位置
		Node<K, V> newNode = new Node(key, value, parent);
		if (cmp > 0) {
			parent.right = newNode;
		} else {
			parent.left = newNode;
		}
		size++;
		
		// 新添加節點之後的處理
		// BST中無需處理，爲 AVL樹 和 B樹提供可覆蓋的方法
		afterPut(newNode);
		return null;
	}

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

	public V remove(K key) {
		return remove(node(key));
	}
	private V remove(Node<K, V> node) {
		if (node == null) return null;
		Node<K, V> oldNode = node;
		size--;
		
		if (node.hasTwoChildren()) { // 度爲2的節點
			// 找到後繼節點
			Node<K, V> s = successor(node);
			// 用後繼節點的值覆蓋度爲2的節點的值
			node.key = s.key;
			node.value = s.value;
			// 刪除後繼節點
			// 這裏是因爲後面必然會刪除node節點
			// 所以直接將後繼節點賦給node,在後面將它刪除
			node = s;
		}
		
		// 刪除node節點（node的度必然是1或者0）
		Node<K, V> replacement = node.left != null ? node.left : node.right;
		
		if (replacement != null) { // node是度爲1的節點
			// 核心：用子節點替代原節點的位置
			// 更改parent
			replacement.parent = node.parent;
			// 更改parent的left、right的指向
			if (node.parent == null) { // node是度爲1的節點並且是根節點
				root = replacement;
			} else if (node == node.parent.left) {
				node.parent.left = replacement;
			} else { // node == node.parent.right
				node.parent.right = replacement;
			}
			
			// 刪除節點之後的處理，BST中無需處理，爲 AVL樹 和 B樹提供可覆蓋的方法
			afterRemove(replacement);
		} else if (node.parent == null) { // node是葉子節點並且是根節點
			root = null;
			
			// 刪除節點之後的處理，BST中無需處理，爲 AVL樹 和 B樹提供可覆蓋的方法
			afterRemove(node);
		} else { // node是葉子節點，但不是根節點
			if (node == node.parent.left) { // 是左子樹
				node.parent.left = null;
			} else { // node == node.parent.right // 是右子樹
				node.parent.right = null;
			}
			
			// 刪除節點之後的處理，BST中無需處理，爲 AVL樹 和 B樹提供可覆蓋的方法
			afterRemove(node);
		}
		return oldNode.value;
	}
	
	public boolean containsKey(K key) {
		return node(key) != null;
	}

	public boolean containsValue(V value) {
		if(root == null) return false;
		
		Queue<Node<K, V>> queue = new LinkedList<>();
		queue.offer(root);
		
		while(!queue.isEmpty()){
			Node<K, V> node = queue.poll();
			if(valEquals(value, node.value)) return true;
			
			if(node.left != null){
				queue.offer(node.left);
			}
			if(node.right != null){
				queue.offer(node.right);
			}
		}
		return false;
	}
	
	public void traversal(Visitor<K, V> visitor) {
		if (visitor == null) return;
		traversal(root, visitor);
	}
	public void traversal(Node<K, V> node, Visitor<K, V> visitor){
		if(node == null || visitor.stop) return;
		
		traversal(node.left, visitor);
		
		if(visitor.stop) return;
		visitor.visit(node.key, node.value);
		
		traversal(node.right, visitor);
		
	}
	
	private boolean valEquals(V v1, V v2) {
		return v1 == null ? v2 == null : v1.equals(v2);
	}
	
	protected Node<K, V> predecessor(Node<K, V> node) {
		if (node == null) return null;
		
		// 前驅節點在左子樹當中（left.right.right.right....）
		Node<K, V> p = node.left;
		if (p != null) {
			while (p.right != null) {
				p = p.right;
			}
			return p;
		}
		
		// 從父節點、祖父節點中尋找前驅節點
		while (node.parent != null && node == node.parent.left) {
			node = node.parent;
		}

		// node.parent == null
		// node == node.parent.right
		return node.parent;
	}
	
	protected Node<K, V> successor(Node<K, V> node) {
		if (node == null) return null;
		
		// 前驅節點在左子樹當中（right.left.left.left....）
		Node<K, V> p = node.right;
		if (p != null) {
			while (p.left != null) {
				p = p.left;
			}
			return p;
		}
		
		// 從父節點、祖父節點中尋找前驅節點
		while (node.parent != null && node == node.parent.right) {
			node = node.parent;
		}

		return node.parent;
	}
	
	private Node<K, V> node(K key) {
		Node<K, V> node = root;
		while (node != null) {
			int cmp = compare(key, node.key);
			if (cmp == 0) return node;
			if (cmp > 0) {
				node = node.right;
			} else { // cmp < 0
				node = node.left;
			}
		}
		return null;
	}
	
	private void afterRemove(Node<K, V> node) {
		// 如果刪除的節點是紅色
		// 或者 用以取代刪除節點的子節點是紅色
		if (isRed(node)) {
			black(node);
			return;
		}
		
		Node<K, V> parent = node.parent;
		// 刪除的是根節點
		if (parent == null) return;
		
		// 刪除的是黑色葉子節點【下溢】
		// 判斷被刪除的node是左還是右
		boolean left = parent.left == null || node.isLeftChild();
		Node<K, V> sibling = left ? parent.right : parent.left;
		if (left) { // 被刪除的節點在左邊，兄弟節點在右邊
			if (isRed(sibling)) { // 兄弟節點是紅色
				black(sibling);
				red(parent);
				rotateLeft(parent);
				// 更換兄弟
				sibling = parent.right;
			}
			
			// 兄弟節點必然是黑色
			if (isBlack(sibling.left) && isBlack(sibling.right)) {
				// 兄弟節點沒有1個紅色子節點，父節點要向下跟兄弟節點合併
				boolean parentBlack = isBlack(parent);
				black(parent);
				red(sibling);
				if (parentBlack) {
					afterRemove(parent);
				}
			} else { // 兄弟節點至少有1個紅色子節點，向兄弟節點借元素
				// 兄弟節點的左邊是黑色，兄弟要先旋轉
				if (isBlack(sibling.right)) {
					rotateRight(sibling);
					sibling = parent.right;
				}
				
				color(sibling, colorOf(parent));
				black(sibling.right);
				black(parent);
				rotateLeft(parent);
			}
		} else { // 被刪除的節點在右邊，兄弟節點在左邊
			if (isRed(sibling)) { // 兄弟節點是紅色
				black(sibling);
				red(parent);
				rotateRight(parent);
				// 更換兄弟
				sibling = parent.left;
			}
			
			// 兄弟節點必然是黑色
			if (isBlack(sibling.left) && isBlack(sibling.right)) {
				// 兄弟節點沒有1個紅色子節點，父節點要向下跟兄弟節點合併
				boolean parentBlack = isBlack(parent);
				black(parent);
				red(sibling);
				if (parentBlack) {
					afterRemove(parent);
				}
			} else { // 兄弟節點至少有1個紅色子節點，向兄弟節點借元素
				// 兄弟節點的左邊是黑色，兄弟要先旋轉
				if (isBlack(sibling.left)) {
					rotateLeft(sibling);
					sibling = parent.left;
				}
				
				color(sibling, colorOf(parent));
				black(sibling.left);
				black(parent);
				rotateRight(parent);
			}
		}
	}
	
	private void afterPut(Node<K, V> node){
		Node<K, V> parent = node.parent;
		
		// 添加的是根節點 或者 上溢到達了根節點
		if (parent == null) {
			black(node);
			return;
		}
		
		// 如果父節點是黑色，直接返回
		if (isBlack(parent)) return;
		
		// 叔父節點
		Node<K, V> uncle = parent.sibling();
		// 祖父節點
		Node<K, V> grand = red(parent.parent);
		if (isRed(uncle)) { // 叔父節點是紅色【B樹節點上溢】
			black(parent);
			black(uncle);
			// 把祖父節點當做是新添加的節點
			afterPut(grand);
			return;
		}
		
		// 叔父節點不是紅色
		if (parent.isLeftChild()) { // L
			if (node.isLeftChild()) { // LL
				black(parent);
			} else { // LR
				black(node);
				rotateLeft(parent);
			}
			rotateRight(grand);
		} else { // R
			if (node.isLeftChild()) { // RL
				black(node);
				rotateRight(parent);
			} else { // RR
				black(parent);
			}
			rotateLeft(grand);
		}
	}
	
	private void rotateLeft(Node<K, V> grand) {
		Node<K, V> parent = grand.right;
		Node<K, V> child = parent.left;
		grand.right = child;
		parent.left = grand;
		afterRotate(grand, parent, child);
	}
	
	private void rotateRight(Node<K, V> grand) {
		Node<K, V> parent = grand.left;
		Node<K, V> child = parent.right;
		grand.left = child;
		parent.right = grand;
		afterRotate(grand, parent, child);
	}
	
	private void afterRotate(Node<K, V> grand, Node<K, V> parent, Node<K, V> child) {
		// 讓parent稱爲子樹的根節點
		parent.parent = grand.parent;
		if (grand.isLeftChild()) {
			grand.parent.left = parent;
		} else if (grand.isRightChild()) {
			grand.parent.right = parent;
		} else { // grand是root節點
			root = parent;
		}
		
		// 更新child的parent
		if (child != null) {
			child.parent = grand;
		}
		
		// 更新grand的parent
		grand.parent = parent;
	}

	private Node<K, V> color(Node<K, V> node, boolean color) {
		if (node == null) return node;
		node.color = color;
		return node;
	}
	
	private Node<K, V> red(Node<K, V> node) {
		return color(node, RED);
	}
	
	private Node<K, V> black(Node<K, V> node) {
		return color(node, BLACK);
	}
	
	private boolean colorOf(Node<K, V> node) {
		return node == null ? BLACK : node.color;
	}
	
	private boolean isBlack(Node<K, V> node) {
		return colorOf(node) == BLACK;
	}
	
	private boolean isRed(Node<K, V> node) {
		return colorOf(node) == RED;
	}
	
	private int compare(K k1, K k2) {
		if (comparator != null) {
			return comparator.compare(k1, k2);
		}
		return ((Comparable<K>)k1).compareTo(k2);
	}
	
	private void KeyNotNullCheck(K key) {
		if (key == null) {
			throw new IllegalArgumentException("key must not be null");
		}
	}

}