二分搜索树与集合

1. 集合的定义：集合用于存储不重复元素的容器，可以由链表实现linkedSet，是有序的，也可以由二分搜索树实现TreeSet是有序，自然排序。

2. 集合set接口的定义：

public interface Set extends Iterable{
	//向集合中添加元素
	public void add(E element);
	//删除集合中指定元素
	public void remove(E element);
	//判断集合中是否包含指定元素
	public boolean contains(E element);
	//获取集合中有效元素个数
	public int size();
	//判断集合是否为空
	public boolean isEmpty();
}

3. 底层通过二分搜索树实现集合：

//定义TreeSet 底层通过二分搜索树来实现集合Set
//二分搜索树中的数据必须具有可比性 因此二分搜索树中的数据必须都是Comparable实现子类
public class TreeSet> implements Set{

	private BinarySearchTree tree;
	
	public TreeSet() {
		tree = new BinarySearchTree();
	}
	
	//向集合中添加元素
	@Override
	public void add(E element) {
		tree.addRe(element);		
	}

	//删除集合中指定元素
	@Override
	public void remove(E element) {
		tree.remove(element);
		
	}
	
	//获取集合中有效元素个数
	@Override
	public int size() {
		return tree.size();
	}

	//判断集合中是否包含指定元素
	@Override
	public boolean contains(E element) {
		return tree.containsRe(element);
	}

	//判断集合是否为空
	@Override
	public boolean isEmpty() {
		return tree.isEmpty();
	}

	//规定及和输出的格式
	@Override
	public String toString() {
		return tree.toString();
	}
	
	//迭代集合
	@Override
	public Iterator iterator() {
		return tree.iterator();
	}
}

4. 底层通过链表实现集合：

//定义linkedSet 底层通过linkedList来实现Set
//通过linkedList来实现的集合Set中的数据不需要具有可比性
public class linkedSet implements Set{

	linkedSinglyList list;
	
	public linkedSet() {
		list = new linkedSinglyList();
	}

	//向集合中添加元素
	@Override
	public void add(E element) {
		if(!list.contains(element)) {
			list.add(element);	
		}	
	}

	//删除集合中指定元素
	@Override
	public void remove(E element) {
		list.remove(element);		
	}

	//获取集合中有效元素的个数
	@Override
	public int size() {
		return list.size();
	}

	//判断集合中是否包含指定元素
	@Override
	public boolean contains(E element) {
		return list.contains(element);
	}

	//判断集合是否为空
	@Override
	public boolean isEmpty() {
		return list.isEmpty();
	}

	//规定集合输出的格式
	@Override
	public String toString() {
		return list.toString();
	}
	
	//迭代集合
	@Override
	public Iterator iterator() {
		return list.iterator();
	}
}

5. 两种实现方式的比较：底层通过二分搜索树实现的集合存储效率要高于底层通过链表实现的集合存储效率。