数据结构映射表Map---第二篇---用二分搜索树BST实现

一、使用二叉搜索树BST实现映射表

它的实现和BST中的操作相类似，详解见BST

public class BSTMap<K extends Comparable<K>, V> implements MyMap<K,V>{
//结点类
private class Node{
	K key;
	V value;
	Node left;
	Node right;
	
	//结点构造方法
	Node(K key, V value){
		this.key = key;
		this.value = value;
		this.left = null;
		this.right = null;
	}
}

private Node root;
private int size;

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

//私有方法，根据键值获取相应的条目，这个方法将为后续许多操作提供方便
private Node getNode(Node node,K key){
	if(node == null)
		return null;
	
	if(key.compareTo(node.key) < 0){
		return getNode(node.left,key);
	}
	else if(key.compareTo(node.key) > 0){
		return getNode(node.right,key);
	}
	else{
		return node;
	}
}

//根据键值判断某一条目是否在映射表中
public boolean contains(K key){
	Node node = getNode(root,key);	
	return (node == null) ? false : true;
}

// 判断映射表是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	// 获取映射表的大小
	public int getSize() {
		return size;
	}
//向映射表中添加条目，如果已经存在，则更新value
public void add(K key, V value){
	root = add(root,key,value);
}

//向映射表中添加条目，并返回新树的结点
private Node add(Node node, K key, V value){
	if(node == null){
		Node newNode = Node(key,value);
		size++;
		return newNode;
	}
	
	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);
		size++;
		return node;
	}
	else{
		node.value = value;
	}
	size++;
	return node;
}

//获取键值为key的value值
public V get(K key){
	Node node = getNode(root,key);
	
	return (node != null) ? node.value : null;
}

public void set(K key, V value){
	Node node = getNode(root,key);
	
	if(node == null){
		throw new IllegalArgumentException(key + " doesn't exists");
	}
	node.value = value;
}

//获取树中最小的结点
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 newRight = node.right;
		node.right = null;
		size--;
		return newRight;
	}
	node.left = removeMin(node.left);
	return node;
}

//删除任意key所对应的条目
public V remove(K key){
	root = remove(root,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(node.key) > 0){
		node.right = remove(node.right,key);
		return node;
	}
	else{
		if(node.left == null){       //左孩子为空
			Node rightNode = node.right;
			node.right = null;
			size--;
			return rightNode;
		}
		else if(node.right == null){ //右孩子为空
			Node leftNode = node.left;
			node.left = null;
			size--;
			return leftNode;
		}
		else{                        //左右孩子均不为空
			Node min = minimum(node.right);
			
			min.left = node.left;
			min.right = removeMin(node.left);
			node.left = null;
			node.right = null;

			return min;
		}
	}
}