集合和映射

Set集合

集合(set)是一个用于存储和处理无重复元素的高效数据结构。

2. 集合

3. 分为有序集合和无序集合。

   –有序结合基于搜索树实现。

   –无序集合基于哈希表实现。

4. 不能添加重复元素。

5. 多重集合可以添加重复元素。

接口如下：

1. void add(E e); //添加元素E
2. void remove(E e); //删除元素E
3. boolean contains(E e); //是否包含元素E
4. int getSize(); //返回集合长度
5. boolean isEmpty(); //判断是否为空

import BinarySearchTree.BST;

public class BSTSet<E extends Comparable<E>> implements Set<E> {
	private BST<E> bst;
	
	public BSTSet() {
		bst = new BST<>();
	}
	@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.getSize();
	}

	@Override
	public boolean isEmpty() {
		return bst.isEmpty();
	}

}

Map映射

映射表(map)类似于目录，提供了使用键值快速查询和获取值的功能。
可以使用链表和二叉树来实现。

有序映射 ： 搜索树实现。

无序映射： 哈希表实现。

多重映射： 键可以重复。

无序映射
定义接口:

1. void add(K,v); // 添加元素
2. V remove(K); //删除元素
3. boolean contains(K); //是否包含元素
4. V get(K); //得到元素
5. void set(k,v); // 修改元素
6. int getSize(); //元素个数
7. boolean isEmpty(); //判断是否为空

public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {
	private class Node {
		private K k;
		private V v;
		private Node left;
		private Node right;

		public Node(K k, V v) {
			this.k = k;
			this.v = v;
			left = null;
			right = null;
		}
	}

	private Node root;
	private int size;

	public BSTMap() {
		root = null;
		size = 0;
	}
    
    //添加元素
	@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 //当key存在时，更新value
			node.v = v;
		return node;
	}

	@Override
	public V remove(K k) {
		Node node = getNode(root,k);
		if(node != null) {
			root = remove(root, k);
			return	node.v;
		}
		return	null;
	}

	private Node remove(Node node, K k) {
		if (node == null)
			return null;
		if (k.compareTo(node.k) < 0) {
			return node.left = remove(node.left, k);
		} else if (k.compareTo(node.k) > 0) {
			return node.right = remove(node.right, k);
		} else {
			// 如果左子树为空
			if (node.left == null) {
				Node rightNode = node.right;
				node.right = null;
				size--;
				return rightNode;
			}
			if (node.right == null) {
				// 如果右子树为空
				Node leftNode = node.left;
				node.left = null;
				size--;
				return leftNode;
			}
			//左右子树都不为空 先找到右子树的最小值 并删除
			Node min = minimum(node);
			min.right = removeMin(node.right);
			min.left = node.right;
			node.left = node.right = null;
			return min;
		}

	}

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

	// 找到二叉树的最小元素
	public Node minimum(Node node) {
		if (node.left == null)
			return node;
		return minimum(node.left);
	}

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

	private Node getNode(Node node, K k) {
		if (node == null)
			return null;
		if (k.compareTo(node.k) == 0)
			return node;
		else if (k.compareTo(node.k) < 0)
			return getNode(node.left, k);
		else
			return getNode(node.right, k);
	}

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

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

	@Override
	public int getSize() {
		return size;
	}

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

总结：

1. 集合存储的是不重复的元素，映射表中存储的是键/值对。

2. Map将键映射到元素上，键类似于索引，Map接口提供了查询、更新以及获取值的集合以及键的集合的方法。

3. Java合集框架支持三种类型的集合：HashSet、LinkedHashSet、TreeSet。

4. Java合集框架支持三种类型的映射表：HashMap、LinkedHashMap、TreeMap。