数据结构-集合与映射

集合（Set）

Java中对于集合相关的常见内置类有哪些

• 集合：存储不重复元素的容器
• 有序集合中的元素具有顺序性，基于搜索树实现
• 无序集合中的元素没有顺序性，基于哈希表实现
• 顺序性，是指按照元素的大小进行排序，并非指插入的顺序
• 有序性，是指元素的进场顺序和出场顺序一致
• 应用场合：
  客户统计
  词汇量统计
  

基于链表的Set集合

package tree;

import dylist.LinkedList;


/**
 * 基于链表实现的集合
 * @author zhang
 *
 * @param <E>
 */
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 void remove(E e) {
		
		list.removeElement(e);
	}

	@Override
	public boolean contains(E e) {
		// TODO Auto-generated method stub
		return list.contains(e);
	}

	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return list.getSize();
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return list.isEmpty();
	}

}

基于二分搜索树的Set集合

• 时间复杂度
  

package tree;

public class BSTTree<E extends Comparable<E>> implements Set<E>{
	private BinarySearchTree<E> tree;
	
	public BSTTree() {
		tree=new BinarySearchTree<>();
	}

	@Override
	public void add(E e) {//O(logn)
		// TODO Auto-generated method stub
		tree.add(e);
	}

	@Override
	public void remove(E e) {//O(logn)
		// TODO Auto-generated method stub
		tree.remove(e);
	}

	@Override
	public boolean contains(E e) {//O(logn)
		// TODO Auto-generated method stub
		return tree.contains(e);
	}

	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return tree.size();
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return tree.isEmpty();
	}

}

映射

• 映射就是存储（键，值）数据对的数据结构（Key，Value）。根据键（Key），寻找
  值（Value）
• 有序映射中的键具有顺序性，基于搜索树实现
• 无序映射中的键没有顺序性，基于哈希表实现
• key不可以重复，value可以重复
  

链表实现Map

package reflect;
import tree.LinkedSet;
import tree.Set;
import dyarray.MyList;
import dylist.LinkedList;

public class LinkedMap<K,V> implements Map<K, V> {
	private class Node{
		public K k;
		public V v;
		public Node next;
		public Node(K k,V v){
			this.k=k;
			this.v=v;
			next=null;
		}
		public Node(){
			this(null,null);
		}
		@Override
		public String toString() {
			
			return k+":"+v;
		}
	}
	private Node head;
	private int size;
	public LinkedMap() {
		head=new Node();
		size=0;
	}
	//辅助函数
	private Node getNode(K k){
		/*迭代
		 * Node p=head.next;
		while(p!=null){
			if(p.k.equals(k)){
				return p;
			}
			p=p.next;
		}
		return p;*/
		return getNode(head.next,k);
	}
	private Node getNode(Node node, K k) {
		if(node==null){
			return null;
		}
		if(node.k.equals(k)){
			return node;
		}else{
			return getNode(node.next,k);
		}
	}
	@Override
	public void add(K k, V v) {
		Node n=getNode(k);
		if(n==null){
			n=new Node(k,v);
			n.next=head.next;
			head.next=n;
			size++;
		}else{
			n.v=v;
		}
	}

	@Override
	public V remove(K k) {
		Node p=head;
		V re=null;
		while(p.next!=null){
			if(p.next.k.equals(k)){
				
				break;
			}
			p=p.next;
		}
		if(p.next!=null){
			Node n=p.next;
			re=n.v;
			p.next=p.next.next;
			n=null;
			size--;
		}
		return re;
	}

	@Override
	public boolean contains(K k) {
		return getNode(k)!=null;
	}

	@Override
	public V get(K k) {
		Node n=getNode(k);
		return n==null?null:n.v;
	}

	@Override
	public void set(K k, V v) {
		Node n=getNode(k);
		if(n==null){
			throw new IllegalArgumentException();
		}
		n.v=v;
	}

	@Override
	public Set keys() {
		Set<K> set=new LinkedSet<>();
		Node cur=head.next;
		while(cur!=null){
			set.add(cur.k);
		}
		return set;
	}

	@Override
	public MyList<V> values() {
		MyList<V> list=new LinkedList<>();
		Node cur=head.next;
		while(cur!=null){
			list.addLast(cur.v);
		}
		return list;
	}

	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return size==0?true:false;
	}
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		Node n=head.next;
		while(n!=null){
			sb.append(n.k+":"+n.v+"\n");
			n=n.next;
		}
		return sb.toString();
	}
}

二叉搜索树实现Map

package reflect;

import tree.LinkedSet;
import tree.Set;
import dyarray.MyList;
import dylist.LinkedList;

public class BSTMap<K extends Comparable<K>,V> implements Map<K, V> {
	private class Node{
		public K k;
		public V v;
		public Node left,right;
		public Node(K k, V v) {
			this.k = k;
			this.v = v;
			left=null;
			right=null;
		}
		public Node(){
			this(null,null);
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return k+":"+v;
		}
		
	}
	private Node root;
	private int size;
	
	public BSTMap() {
		root=null;
		size=0;
	}
	//辅助寻找方法
	private Node getNode(K k){
		return getNode(root,k);
	}
	private Node getNode(Node node,K k){
		if(node==null){
			return null;
		}
		if(k.compareTo(node.k)<0){
			return getNode(node.left,k);
		}else if(k.compareTo(node.k)>0){
			return getNode(node.right,k);
		}else{
			return node;
		}
	}
	@Override
	public void add(K k, V v) {
		root=add(root,k,v);
	}
	private Node add(Node node,K k,V v){
		if(node==null){
			size++;
			return new Node(k,v);
		}
		if(k.compareTo(node.k)<0){
			node.left=add(node.left,k,v);
		}else if(k.compareTo(node.k)>0){
			node.right=add(node.right,k,v);
		}else{
			node.v=v;
		}
		return node;
	}
	@Override
	public V remove(K k) {
		Node n=getNode(k);
		if(n==null){
			return null;
		}
		root=remove(root,k);
		return n.v;
	}

	private Node remove(Node node, K k) {
		if(node==null){
			return null;
		}
		if(k.compareTo(node.k)<0){
			return remove(node.left,k);
		}else if(k.compareTo(node.k)>0){
			return remove(node.right,k);
		}else{
			//左子树为null
			if(node.left==null){
				Node right=node.right;
				node=null;
				return right;
			}
			//右子树为null
			if(node.right==null){
				Node left=node.right;
				node=null;
				return left;
			}
			Node tim=min(node.right);
			tim.right=removeMin(node.right);
			tim.left=node.left;
			return tim;
		}
	}
	//找到最小值
	private Node min(Node node){
		if(node.left==null){
			return node;
		}else{
			return min(node.left);
		}
	}
	//删除最小值
	private Node removeMin(Node node){
		if(node.left==null){
			Node nodeRight=node.right;
			node=null;
			size--;
			return nodeRight;
		}
		node.left=removeMin(node.left);
		return node;
	}
	@Override
	public boolean contains(K k) {
		return getNode(k)!=null;
	}

	@Override
	public V get(K k) {
		return getNode(k).v;
	}

	@Override
	public void set(K k, V v) {
		Node n=getNode(k);
		if(n==null){
			throw new IllegalArgumentException();
		}
		n.v=v;
	}

	@Override
	public Set keys() {
		Set<K> set=new LinkedSet<>();
		midOrder(root,set);
		return set;
	}
	//返回keys的中序遍历
	private void midOrder(Node node, Set<K> set) {
		if(node==null){
			return;
		}
		midOrder(node.left,set);
		set.add(node.k);
		midOrder(node.right,set);
	}
	@Override
	public MyList<V> values() {
		MyList<V> list=new LinkedList<>();
		midOrder(root,list);
		return list;
	}
	//中序遍历返回所有值
	private void midOrder(Node node,MyList<V> list){
		if(node==null){
			return;
		}
		midOrder(node.left,list);
		list.addLast(node.v);
		midOrder(node.right,list);
	}
	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return size==0;
	}

}