集合和映射

最新推荐文章于 2022-03-13 22:47:48 发布

Yingmu__

最新推荐文章于 2022-03-13 22:47:48 发布

阅读量1.7k

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/yingmu__/article/details/85373122

版权

数据结构专栏收录该内容

7 篇文章 10 订阅

订阅专栏

Set集合

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

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

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

–无序集合基于哈希表实现。
不能添加重复元素。
多重集合可以添加重复元素。

接口如下：

void add(E e); //添加元素E
void remove(E e); //删除元素E
boolean contains(E e); //是否包含元素E
int getSize(); //返回集合长度
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)类似于目录，提供了使用键值快速查询和获取值的功能。
可以使用链表和二叉树来实现。

有序映射： 搜索树实现。

无序映射： 哈希表实现。

多重映射： 键可以重复。

无序映射
定义接口:

void add(K,v); // 添加元素
V remove(K); //删除元素
boolean contains(K); //是否包含元素
V get(K); //得到元素
void set(k,v); // 修改元素
int getSize(); //元素个数
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;
	}
}