目录
映射就是储存（键、值）数据对的数据结构（key、value）
映射的底层实现：
- 由链表实现、有序 --------LinkedMap
- 由二分搜索树实现、有序、键自然排序 ----------TreeMap
- 由哈希表实现、无序 --------HashMap
映射的特点：
- Map中的数据是以键值对（Key-Value）的形式存在的
- key-value以Enty类型的对象实例存在
- 可以通过key值快速的找到value
- 一个映射不包含重复的key
- 每一个key最懂只能映射到一个value
- 它提供了通过键快速获取、删除和更新键值对的功能。
注意：可以将所有的Key当作Set集合
将所有的Value当作List集合
本博客实现的是由二分搜索树实现的映射
映射Map接口定义：
package p1.接口;
public interface Map <K,V>{
//将键值对key-value加入映射 如果已存在就修改
public void put(K key, V value);
//删除指定key的键值对，并返回对应的值value
public V remove(K key);
//查找指定key对应的值是否存在
public boolean contains(K key);
//获取指定key对应的值value
public V get(K key);
//修改指定key处的值value
public void set(K key, V value);
//获取映射中键对的个数
public int size();
//判断映射是否为空
public boolean isEmpty();
//获取所有键的集合
public Set<K> keySet();
//获取所有值的List
public List<V> values();
//获取所有键值对的Set
public Set<Entry<K,V>> entrySet();
//创建一个接口，为结点提供可比较性。
public interface Entry<K, V> extends Comparable<Entry<K,V>>{
public K getKey();
public V getValue();
}
}注意：Entry<K,V>表示将键值对看成一个整体
TreeMap类的创建
由于TreeMap是底层用二分搜索树实现的Map，所有TreeMap的元素既要具有可比性，TreeMap类还得去实现Map接口。
代码如下：
package 二分搜索树;
import p1.接口.List;
import p1.接口.Map;
import p1.接口.Set;
import java.util.Iterator;
public class TreeMap<K extends Comparable<K>, V> implements Map<K, V>{
@Override
public Iterator<Entry<K, V>> iterator() {
return null;
}
@Override
public void put(K key, V value) {
}
@Override
public V remove(K key) {
return null;
}
@Override
public boolean contains(K key) {
return false;
}
@Override
public V get(K key) {
return null;
}
@Override
public void set(K key, V value) {
}
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public Set<K> keySet() {
return null;
}
@Override
public List<V> values() {
return null;
}
@Override
public Set<Entry<K, V>> entrySet() {
return null;
}
}
TreeMap的构造方法与属性
TreeMap底层是由BST（BinarySearchTree二分搜索树）实现的，但又与BST不同。BST中结点储存的是一个元素，而TreeMap中结点储存的是一个键值对（两个元素）。所以要将BST的部分代码进行改进。
//定义二分搜索树的结点信息
private class Node{
public K key; //键
public V value; //值
public Node right; //右结点
public Node left; //左结点
//构造函数
public Node(K key, V value){
this.key = key;
this.value = value;
}
}
//定义TreeMap的属性
private Node root; //定义根结点
private int size; //Treemap中键值对的个数
//TreeMap的构造函数
public TreeMap(){
root = null;
size = 0;
}TreeMap中方法的实现
首先为了后续方法能够更好的实现，我们将先写一个辅助函数。
获取指定key所在位置的结点(辅助函数).
思路：以node为根的二分搜索树中查找 key所在的结点 -- 递归
/获取指定key所在位置上的结点
public Node getNode(Node node, K key){
//如果根结点为空，说明不存在，直接返回空
if (node == null){
return null;
}
//如果key小于当前结点元素的值，让结点向左移
if (key.compareTo(node.key) < 0){
//返回key与左子节点比较的结果-----递归
return getNode(node.left, key);
//如果key大于当前结点元素的值，让该结点向右移
}else if(key.compareTo(node.key) > 0){
//返回key与右子节点比较的结果-----递归
return getNode(node.right, key);
//如果key等于当前结点元素的值，说明找到了，直接返回当前结点
}else {
return node;
}
}添加键值对（键值对如果存在就对value进行修改）
思路：以node为根结点的二分搜索树中进行查找，如果key小于当前结点元素的值，就将当前结点的左结点传入函数递归比较，并将结果返回给当前结点的左结点；如果key大于当前结点元素的值，就将当前结点的右结点传入函数递归比较，并将结果返回给当前结点的右结点。如果等于说明已存在，直接修改value即可。
//添加键值对
@Override
public void put(K key, V value) {
root = put(root, key, value);
}
private Node put(Node node, K key, V value){
//如果根结点为空（也是递归停止条件），则直接size++并返回新的结点
if (node == null){
size++;
return new Node(key, value);
}
//如果key小于当前结点元素的值
if (key.compareTo(node.key) < 0){
//递归
node.left = put(node.left, key, value);
}else if (key.compareTo(node.key) > 0){
node.right = put(node.right, key, value);
}else {
//如果当前结点的key值与要添加的key值相等，直接修改当前结点的value值
node.value = value;
}
return node;
}删除指定的key的键值对 并返回对应的值value
参考：
二分搜索树（Binary Search Tree）_boy-s6的博客-CSDN博客 中 删除二分搜索树中任意节点。
先写两个辅助函数一个是返回最小值结点，一个是删除最小值结点。
返回最小值结点：
最小值结点都是在二分搜索树的最左边，所以只要遍历到一个节点没有左子节点，那么这个节点就是最小值节点
代码如下：
//返回二分搜索树中最小值结点
private Node minimum(Node node){
//如果树为空，直接返回空
if (isEmpty()){
return null;
}
//如果该结点的左子结点为空，说明该结点就为最小值结点
if (node.left == null){
return node;
}
return minimum(node.left);
} 删除最小值结点：
我们要先找到二分搜索树的最小值，然后再将要删除结点的右子树返回给父节点的左子节点。
代码如下：
//删除二分搜索树的最小值结点,并返回给结点
public Node removeMin(Node node){
if (isEmpty()){
return null;
}
//如果左结点为空，说明该结点就为最小值结点
if (node.left == null){
//将该结点的右子树存贮到变量rightNode中
Node rightNode = node.right;
//让该结点右子树为空
node.right = null;
size--;
//返回rightNode给上它的爷爷
return rightNode;
}
node.left = removeMin(node.left);
return node;
}得到上面两个辅助函数后。
代码如下：
//删除指定key对应的键值对，并返回对应的值value
@Override
public V remove(K key) {
//首先去获得要key所在的结点
Node delNode = getNode(root, key);
//如果返回的结点存在
if (delNode != null){
//写一个函数，将删除好了的二分搜索树的根返回
root = remove(root, key);
//返回值
return delNode.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 rightNode = node.right;
node.right = null;
size--;
return rightNode;
}
//如果右结点为空
if (node.right == null){
Node leftNode = node.left;
node.left = null;
size--;
return leftNode;
}
//如果左右结点都不为空
Node successor = minimum(node.right);
//删除该结点的右子树的最小值结点
successor.right = removeMin(node.right);
successor.left = node.left;
node.right = node.left = null;
return successor;
}
}
获取所有的key
因为键是具有可比性的，不能重复，所以我们可以用Set来储存。这里为了从下到大的输出key我们借用了中序遍历。
代码：
//获取所有键的Set,因为键是具有可比性，不能重复，我们可以用Set来储存
@Override
public Set<K> keySet() {
TreeSet<K> set = new TreeSet<>();
//写一个函数，将结点从中序遍历（从小到大）的顺序储存进set中
inOrderKetSet(root, set);
//将集合的数据返回
return set;
}
//中序遍历
private void inOrderKetSet(Node node, TreeSet<K> set) {
//如果集合为空的话
if (root == null){
return;
}
inOrderKetSet(node.left, set);
//储存进集合中
set.add(node.key);
inOrderKetSet(node.right, set);
}
获取所有得value
代码：
//获取所有的value，用List储存
@Override
public List<V> values() {
//创建一个链表
LinkedList<V> list = new LinkedList<>();
//创建一个函数，将TreeMap中结点的value按照key值的大小存储进链表中
inOrDerValues(root, list);
//将链表返回
return list;
}
//中序遍历--按照key从小到大
private void inOrDerValues(Node node, LinkedList<V> list) {
if (node == null) {
return;
}
inOrDerValues(node.left, list);
list.add(node.value);
inOrDerValues(node.right, list);
}获取TreeMap中所有的结点
在获取之前我们要先考略一个问题，结点是不具有可比性的。不能比较就获取数据。所以这里我们应该写一个内部类，封装结点使其具有可比较性，然后再将结点从小到大（比较key）的顺序获取出来。
@Override
public Set<Entry<K, V>> entrySet() {
TreeSet<Entry<K,V>> entries = new TreeSet<>();
inOrDerEntry(root,entries);
return entries;
}
private void inOrDerEntry(Node node, TreeSet<Entry<K,V>> entries) {
if (node == null){
return;
}
inOrDerEntry(node.left,entries);
entries.add(new BSTEntry<>(node.key, node.value));
inOrDerEntry(node.right,entries);
}
//创建一个内部类，封装接口，实现结点的课比较性
private class BSTEntry<K extends Comparable<K>,V> implements Entry<K, V>{
private K key;
private V value;
public BSTEntry(K key, V value){
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public int compareTo(Entry<K, V> o) {
return this.getKey().compareTo(o.getKey());
}
@Override
public String toString() {
return key + ":" + value;
}
}其他方法
代码：
//判断TreeMap是否包含key
@Override
public boolean contains(K key) {
return getNode(root, key) != null;
}
//获取key所在结点的value的值
@Override
public V get(K key) {
Node node = getNode(root, key);
if (node != null){
return node.value;
}
return null;
}
//修改key所在结点的value的值
@Override
public void set(K key, V value) {
Node node = getNode(root, key);
if (node == null){
throw new IllegalArgumentException("key-value is not exist");
}
node.value = value;
}
//获取TreeMap中元素的个数
@Override
public int size() {
return size;
}
//判断是否为空
@Override
public boolean isEmpty() {
return size == 0 && root == null;
}
完整代码如下：
package 二分搜索树;
import p1.接口.List;
import p1.接口.Map;
import p1.接口.Set;
import p2.线性结构.LinkedList;
public class TreeMap<K extends Comparable<K>, V> implements Map<K, V>{
//定义二分搜索树的结点信息
private class Node{
public K key; //键
public V value; //值
public Node right; //右结点
public Node left; //左结点
//构造函数
public Node(K key, V value){
this.key = key;
this.value = value;
}
}
//定义TreeMap的属性
private Node root; //定义根结点
private int size; //Treemap中键值对的个数
//TreeMap的构造函数
public TreeMap(){
root = null;
size = 0;
}
//获取指定key所在位置上的结点
public Node getNode(Node node, K key){
//如果根结点为空，说明不存在，直接返回空
if (node == null){
return null;
}
//如果key小于当前结点元素的值，让结点向左移
if (key.compareTo(node.key) < 0){
//返回key与左子节点比较的结果-----递归
return getNode(node.left, key);
//如果key大于当前结点元素的值，让该结点向右移
}else if(key.compareTo(node.key) > 0){
//返回key与右子节点比较的结果-----递归
return getNode(node.right, key);
//如果key等于当前结点元素的值，说明找到了，直接返回当前结点
}else {
return node;
}
}
//添加键值对
@Override
public void put(K key, V value) {
root = put(root, key, value);
}
private Node put(Node node, K key, V value){
//如果根结点为空（也是递归停止条件），则直接size++并返回新的结点
if (node == null){
size++;
return new Node(key, value);
}
//如果key小于当前结点元素的值
if (key.compareTo(node.key) < 0){
//递归
node.left = put(node.left, key, value);
}else if (key.compareTo(node.key) > 0){
node.right = put(node.right, key, value);
}else {
//如果当前结点的key值与要添加的key值相等，直接修改当前结点的value值
node.value = value;
}
return node;
}
//删除指定key对应的键值对，并返回对应的值value
@Override
public V remove(K key) {
//首先去获得要key所在的结点
Node delNode = getNode(root, key);
//如果返回的结点存在
if (delNode != null){
//写一个函数，将删除好了的二分搜索树的根返回
root = remove(root, key);
//返回值
return delNode.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 rightNode = node.right;
node.right = null;
size--;
return rightNode;
}
//如果右结点为空
if (node.right == null){
Node leftNode = node.left;
node.left = null;
size--;
return leftNode;
}
//如果左右结点都不为空
Node successor = minimum(node.right);
//删除该结点的右子树的最小值结点
successor.right = removeMin(node.right);
successor.left = node.left;
node.right = node.left = null;
return successor;
}
}
//返回二分搜索树中最小值结点
private Node minimum(Node node){
//如果树为空，直接返回空
if (isEmpty()){
return null;
}
//如果该结点的左子结点为空，说明该结点就为最小值结点
if (node.left == null){
return node;
}
return minimum(node.left);
}
//删除二分搜索树的最小值结点,并返回给结点
public Node removeMin(Node node){
if (isEmpty()){
return null;
}
//如果左结点为空，说明该结点就为最小值结点
if (node.left == null){
//将该结点的右子树存贮到变量rightNode中
Node rightNode = node.right;
//让该结点右子树为空
node.right = null;
size--;
//返回rightNode给上它的爷爷
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
//判断TreeMap是否包含key
@Override
public boolean contains(K key) {
return getNode(root, key) != null;
}
//获取key所在结点的value的值
@Override
public V get(K key) {
Node node = getNode(root, key);
if (node != null){
return node.value;
}
return null;
}
//修改key所在结点的value的值
@Override
public void set(K key, V value) {
Node node = getNode(root, key);
if (node == null){
throw new IllegalArgumentException("key-value is not exist");
}
node.value = value;
}
//获取TreeMap中元素的个数
@Override
public int size() {
return size;
}
//判断是否为空
@Override
public boolean isEmpty() {
return size == 0 && root == null;
}
//获取所有键的Set,因为键是具有可比性，不能重复，我们可以用Set来储存
@Override
public Set<K> keySet() {
TreeSet<K> set = new TreeSet<>();
//写一个函数，将结点从中序遍历（从小到大）的顺序储存进set中
inOrderKetSet(root, set);
//将集合的数据返回
return set;
}
//中序遍历
private void inOrderKetSet(Node node, TreeSet<K> set) {
//如果集合为空的话
if (root == null){
return;
}
inOrderKetSet(node.left, set);
//储存进集合中
set.add(node.key);
inOrderKetSet(node.right, set);
}
//获取所有的value，用List储存
@Override
public List<V> values() {
//创建一个链表
LinkedList<V> list = new LinkedList<>();
//创建一个函数，将TreeMap中结点的value按照key值的大小存储进链表中
inOrDerValues(root, list);
//将链表返回
return list;
}
//中序遍历--按照key从小到大
private void inOrDerValues(Node node, LinkedList<V> list) {
if (node == null) {
return;
}
inOrDerValues(node.left, list);
list.add(node.value);
inOrDerValues(node.right, list);
}
@Override
public Set<Entry<K, V>> entrySet() {
TreeSet<Entry<K,V>> entries = new TreeSet<>();
inOrDerEntry(root,entries);
return entries;
}
private void inOrDerEntry(Node node, TreeSet<Entry<K,V>> entries) {
if (node == null){
return;
}
inOrDerEntry(node.left,entries);
entries.add(new BSTEntry<>(node.key, node.value));
inOrDerEntry(node.right,entries);
}
//创建一个内部类，封装接口，实现结点的课比较性
private class BSTEntry<K extends Comparable<K>,V> implements Entry<K, V>{
private K key;
private V value;
public BSTEntry(K key, V value){
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public int compareTo(Entry<K, V> o) {
return this.getKey().compareTo(o.getKey());
}
@Override
public String toString() {
return key + ":" + value;
}
}
}
扫一扫
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
