集合与映射——基于线性表和二叉树实现：

1.集合Set接口定义：

public interface Set<E> {
	public void add(E e);
	public void remove(E e);
	public boolean contains(E e);
	public int getSize();
	public boolean isEmpty();
}

（1）基于链表ArrayList实现的集合：linkedSet

import 动态链表.linkedList;
//基于链表实现的集合；
public class LinkedSet<E> implements Set<E> {
	private linkedList<E> list; //内部访问链表
	public LinkedSet(){
		list=new linkedList<>();
	}
	@Override
	public void add(E e) {
		if(!list.contains(e)){ //判断一下，如果不重复再添加
			list.addLast(e);
		}
	}
	@Override
	public int getSize() {
		return list.getSize();
	}
	@Override
	public boolean isEmpty() {
		return list.isEmpty();
	}
	@Override
	public void remove(E e) {
		list.removeElement(e);
	}
	@Override
	public boolean contains(E e) {
		return list.contains(e);
	}
}
**（2）基于二叉树BinarySearchTree实现的集合：BSTSet**
package 集合与映射;
import 二分搜索树.BinarySearchTree;
//基于二分搜索树
public class BSTSet<E extends Comparable<E>> implements Set<E> {
	private BinarySearchTree<E> bst;//内部访问二分搜索树
	public BSTSet(){
		bst=new BinarySearchTree<>();
	}
	@Override
	public void add(E e) {
		bst.add(e);
	}
	@Override
	public void remove(E e) {
		bst.remove(e);
	}
	@Override
	public boolean contains(E e) {
		return bst.contains(e);
	}
	@Override
	public int getSize() {
		return bst.size();
	}
	@Override
	public boolean isEmpty() {
		return bst.isEmpty();
	}
}

2.映射Map接口定义：

package 集合与映射;
import 动态数组.List;
public interface Map<K,V> {
	public void add(K key,V value);
	public V remove(K key);//根据key值删除一个键
	public boolean contains(K key);
	public V get(K key);
	public void set(K key,V value); 
	public int getSize();
	public boolean isEmpty();
	public Set keys();//返回映射中键的集合
	public List values();//返回映射中值组成的线性表
}

（1）基于链表ArrayList实现的映射：linkeMap

import 动态数组.List;
import 动态链表.linkedList;
public class LinkedMap<K,V>implements Map<K,V>{
	private class Node{   //内部类
		public K key;  //键
		public V value;	//值
		public Node next;	//节点数据域
		public Node(K key,V value){  //内部构造函数
			this.key=key;
			this.value=value;
			next=null;
		}
		public Node(){
			this(null,null);
		}
		public String toString(){
			return key.toString()+":"+value.toString();
		}
	}
	private Node head;//头结点
	private int size; //元素个数
	public LinkedMap(){ //构造函数
		head=new Node();
		size=0;
	}
	private Node getNode(K key){ //辅助函数：获取键为key的节点并返回
/*		迭代
		Node p=head;
		while(p!=null){
			if(p.key.equals(key)){ //如果值相等，代表找到了
				return p;
			}
			p=p.next;//否则p继续后移
		}
		return null;
*/
		return getNode(head.next,key); //递归
	}
	private Node getNode(Node node, K key){ //获取值为key的节点
		if(node==null){
			return null;
		}
		if(node.key.equals(key)){
			return node;
		}else{
			return getNode(node.next,key);
		}
	}
	@Override
	public void add(K key, V value) { //添加一个键为key，值为value的节点
		Node n=getNode(key);
		//如果没有找到这个键，则将这个键更新为待添加的值
		if(n==null){
			n=new Node(key,value);
			n.next=head.next;
			head.next=n;
			size++;
		}else{
			n.value=value;
		}
	}
	@Override
	public V remove(K key) {//删除key,并返回value值。关键先找key的前驱
		Node pre=head;
		while(pre.next!=null){
//如果pre的下一个等于key，则代表找到了key的前驱，就可以直接删除
			if(pre.next.key.equals(key)){
				break;
			}
			pre=pre.next; //删除key
		}
		if(pre.next!=null ){
			Node n=pre.next;
			pre.next=n.next;
			n.next=null;
			size--;
			return n.value;
		}
		return null;
	}
	@Override
	public boolean contains(K key) {
		return getNode(key)!=null;
	}
	@Override
	public V get(K key) {
		Node n=getNode(key);//先找这个节点
		return n==null?null:n.value;//找到了找不到就是null，找到了直接返回它的值
	}
	@Override
	public void set(K key, V value) { //设置一个键为key，值为value的节点
		Node n=getNode(key);
		if(n==null){//如果找不到，抛异常
			throw new IllegalArgumentException("元素不存在！");
		}
		n.value=value;//找到了，直接将value值赋给n.value
	}
	@Override
	public int getSize() {
		return size;
	}
	@Override
	public boolean isEmpty() {
		return size==0;
	}
	@Override
	public Set keys() {//返回一个由映射中键组成的集合
		Set<K> set=new LinkedSet<K>();//创建一个集合（不能重复存储）
		Node cur=head.next;
		while(cur!=null){
			set.add(cur.key);
		}
		return set;
	}
	@Override
	public List values(){//获取一个由映射中值组成的集合
		List<V> list=new linkedList<V>();//先创建一个线性表（可以重复存储元素）
		Node cur=head.next;
		while(cur!=null){
			list.addLast(cur.value);
		}
		return list;
	}
}

（2）基于二叉树BinarySearchTree实现的集合：BSTMap

package 集合与映射;
import java.awt.List;
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;
		}
		public Node(){
			this(null,null);
		}
		public String toString(){
			return key.toString()+"："+value.toString();
		}
	}
	private Node root;
	private int size;
	public BSTMap(){
		root=null;
		size=0;
	}
	//辅助函数,以node为头结点寻找key这个键
	private Node getNode(Node node,K key){
		if(node==null){
			return null;
		}
		if(key.compareTo(node.key)>0){
			return getNode(node.right,key);
		}else if(key.compareTo(node.key)<0){
			return getNode(node.left,key);
		}else{//相等，代表找到了这个节点，直接返回node
			return node;
		}
	}
	@Override
	//添加元素：
	public void add(K key, V value) {
		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.right=add(node.right,key,value);//递归调用，更新左右子树
		}else if(key.compareTo(node.key)<0){
			node.left=add(node.left,key,value);
		}else{
			node.value=value;
		}
		return node;
	}
	@Override
	public V remove(K key) {
		Node n=getNode(root,key);//先找这个节点；
		if(n==null){  //如果找不到，直接返回null
			return null;
		}
		root=remove(root,key);  否则就删除；
		return n.value; 返回value值
	}
	private Node remove(Node node,K key){ //以node为当前树的根结点删除key，并返回新的根节点
		if(node==null){
			return null;
		}
		if(key.compareTo(node.key)>0){   //如果大于当前节点的值
			node.right=remove(node.right,key); //往右走，递归调用remove，以右孩子为节点循环寻找待删元素；
			return node;
		}else if(key.compareTo(node.key)<0){
			node.left=remove(node.left,key);
			return node;
		}else{		//相等，即找到了待删元素;
			if(node.left==null){
				node.right=null;
				size--;
				return node.right;
			}
			if(node.right==null){
				node.left=null;
				size--;
				return node.left;
			}
			Node successor=minmum(node.right);
			successor.right=removeMin(node.right);
			successor.left=node.left;
			node.left=node.right=null;
			return successor;
		}
	}
	private Node minmum(Node node) {
		if(node.left==null){
			return node;
		}else{
			return minmum(node.right);
		}
	}
	// 以node为根节点的二分搜索树，在删除最小值之后并返回新树的根
	private Node removeMin(Node node) {
		if(node.left==null){ //left==null,找到最小值以后
			node.right=null;
			size--;
			return node.right;
		}
		node.left=removeMin(node.left);//若不是null，继续递归重复上一步
		return node;
	}
	@Override
	public boolean contains(K key) {
		Node n=getNode(root,key);
		return n==null?false:true;
	}
	@Override
	public V get(K key) {
		Node n=getNode(root,key);
		return n==null?null:n.value;
	}
	@Override
	public void set(K key, V value) {
		Node n=getNode(root,key);
		if(n==null){
			throw new IllegalArgumentException("元素不存在！");
		}
		n.value=value;
	}
	@Override
	public int getSize() {
		return size;
	}
	@Override
	public boolean isEmpty() {
		return size==0;
	}
	@Override
	public Set keys() {
		Set<K> set=new BSTSet<>();
		inOrder(root,set);
		return set;
	}
	private void inOrder(Node node, Set<K> set) {
		if(node==null){
			return;
		}
		inOrder(node.left,set);
		set.add(node.key);
		inOrder(node.right,set);
	}
	@Override
	public 动态数组.List values() {
		return null;
	}
}