数据结构---集合与映射

1.01 集合（Set）

存储不重复元素的容器

有序集合中的元素具有顺序性，基于搜索树实现；
无序集合中的元素没有顺序性，基于哈希表实现。

顺序性，是指按照元素的大小进行排序，并非指插入的顺序 
有序性，是指元素的进场顺序和出场顺序一致

应用场合

客户统计 
词汇量统计

1.02 Set集合接口定义

public interface Set<E>{
	void add(E e);	//向集合中添加元素e（不能添加重复元素）
	void remove(E e);	//删除集合中指定元素e
	boolean contains(E e);	//判断是否包含指定元素
	int getSize();	//获取集合中元素的个数
	boolean isEmpty();	//判断集合是否为空
}

1.03 BSTSet基于二分搜索树实现的集合类定义

public class BSTSet<E extends Comparable<E>> implements Set<E>{
	private BinarySearchTree<E> tree;
	public BSTSet(){
		tree=new BinarySearchTree<E>();
	}
	public void add(E e){
		tree.add(e);
	}
	public void remove(E e){
		tree.remove(e);
	}
	public boolean contains(E e){
		return tree.contains(e);
	}
	public int getSize(){
		return tree.size();
	}
	public boolean isEmpty(){
		return tree.isEmpty();
	}
	public void show(){
		tree.inOrder();
	}
}

1.04 LinkedListSet基于链表实现的集合类定义

public class LinkedListSet<E> implements Set<E>{
	private LinkedList<E> list;
	public LinkedListSet(){
		list=new LinkedList<E>();
	}
	public void add(E e){
		if(!list.contains(e)){
			list.addHead(e);
		}
	}
	public void remove(E e){
		list.removeElement(e);
	}
	public boolean contains(E e){
		return list.contains(e);
	}
	public int getSize(){
		return list.getSize();
	}
	public boolean isEmpty(){
		return list.isEmpty();
	}
}

1.05 应用：读取小说中的单词，对比两种不同的实现方式（时间复杂度分析）



1.06 二分搜索树最坏情况
其结构退化成链表，用平衡二叉树解决该问题

1.07 Java中对于集合相关的常见内置类

1.08 映射（Map）

映射就是存储（键，值）数据对的数据结构（Key，Value）。根据键（Key），寻找值（Value）

有序映射中的键具有顺序性，基于搜索树实现
无序映射中的键没有顺序性，基于哈希变实现


1.09 Map接口定义

public interface Map<K,V>{
	void add(K key,V value);	//向集合中添加键值对
	V remove(K,key);	//删除元素
	boolean contains(K key);	//是否包含某元素
	V get(K key);	//根据键获取值
	void set(K key,V value);	//修改元素
	int getSize();	//获取其有效长度
	boolean isEmpty();	//是否为空
}

1.10 LinkedListMap基于链表实现的映射类定义

1. 定义类

public class LinkedListMap<K,V> implaments Map<K,V>

2. 定义内部类结点

private class Node{
	public K key;
	public V value;
	public Node next;
	public Node(K key.V value){
		this.key=key;
		this.value=value;
	}
	public Node(){ //虚拟头结点
		this(null,null);
	}
	public String toString(){
		return key.toString()+":"+value.toString();
	}
}

3. 定义成员变量

private Node head;
private int size;

4. 定义构造函数

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

5. 实现功能

public void add(K key,V value){
	Node node=getNode(key);
	if(node==null){	//添加元素
		node=new Node(key,value);
		node.next=head.next;
		head.next=node;
		size++;
	}else{	//修改元素
		node.value=value;
	}
}

public V remove(K key){
	Node pre=head;
	while(pre.next!=null){
		if(pre.next.key.equals(key)){
			break;
		}
		pre=pre.next;
	}
	if(pre.next!=null){	//找到要删除的元素后 在链表中删除该结点
		Node delNode=pre.next;
		pre.next=delNode.next;
		delNode.next=null;
		size--;
		return delNode.value;
	}
	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 set(K key,V newValue){
	Node node=getNode(key);
	if(node==null){
		throw new IllegalArgumentException("doesn't exist!");
	}
	node.value=newValue;
  }
  
  public int getSize(){
  	return size;
  }
  
  public boolean isEmpty(){
  	return size==0;
  }
  
  private Node getNode(K key){
  	Node cur=head.next;
  	while(cur!=null){
  		if(cur.key.equals(key)){
  			return cur;
  		}
  		cur=cur.next;
  	}
  	return null;
  }
  
  public String toString(){
  	if(isEmpty()){
  		return "[]";
  	}
  	StringBuilder sb=new StringBuilder("[");
  	Node p=head;
  	while(p.next!=null){
  		p=p.next;
  		if(p.next!=null){	//如果不是最后一个与元素
  			sb.append("("+p+")"+",");
  		}else{	//如果是最后一个元素
  			sb.append("("+p+")"+"]\n");
  		}
  	}
  	return sb.toString();
  }
}

1.11 BSTMap基于二分搜索树实现的映射类定义

1. 定义类

public classBSTMap<K extends Comparable<K>,V> implements Map<K,V>

2. 定义内部类结点

private class Node{
	public K key;
	public V value;
	Node left,right;
	public Node(K key,V value){
		this.key=key;
		this.value=value;
		left=null;
		right=null;
	}
	public String toString(){
		return "("+key+","+value+")";
	}
}

3. 定义成员变量

private Node root;
private int size;

4. 定义构造函数

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

5. 实现功能

public int getSize(){
	return size;
}

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

public void add(K key,V value){
	root=add(root,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.rigth=add(node.rigth,key,value);
	}else{
		node.value=value;
	}
	return node;
  }
public V get(k key){
	Node node=getNode(root,key);
	return node==null?null:node.value;
}

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

public V remove(K key){
	Node node=getNode(root,key);
	if(node!=null){
		root=remove(root,key);
		return node.value;
	}
	return null;
}
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 rigthNode=node.right;
			node.right=null;
			size--;
			return rightNode;
		}
		if(right==null){
			Node leftNode=node.left;
			node.left=null;
			size--;
			return leftNode;
		}
		Node newcurRoot=minmun(node.right);
		newcurRoot.right=removeMin(node.right);
		newcurRoot.left=node.left;
		node.left=node.right=null;
		return newcurRoot;
	}
}

private Node minmum(Node node){
	if(node==null){
		return null;
	}else{
		return minmum(node.left);
	}
}

private Node removeMin(Node node){
	if(node.left==null){
		Node rightNode=node.right;
		node.right=null;
		size--;
		return rightNode;
	}
	node.left=ewmoveMin(node.left);
	return node;
}

public boolean cotains(k key){
	return getNode(root,key)!=null;	
}

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

对比两者的时间复杂度