Java数据结构——Map&&Set（TreeMap TreeSet）

搜索：

Map和Set是进行数据搜索的一个结构，常用于数据的查找。

我们进行数据查找的方式有很多，其中线性的遍历搜索时间的复杂度是O(N),会比较慢。另一种基于有序的查找方式是二分查找，时间的复杂度是O(logN)。

我们一般把搜索的目标或者关键字叫做Key，而关键字所对应的值就是Value，如果把Key比作一个人的话，那么Value就是这个人的名字。如果把一件商品比作Key，那么它的价格就是Value。

根据Key—Value我们可以分成两类。

 Key模型：

1、查找一个英文字典，给出一个值看其是否存在于字典中

2、快速查找某个人是否存在于队中。

 Key—Value模型

1、快速查看英文文献中“hello” 出现了几次

2、快速查看某个集体中名字相同的人一共有多少个？

 而Map中存储的就是Key—Value值，Set中只存储了Key的值

Map的使用：

以下是Map接口的继承关系，我们可以看到Map下方有TreeMap和HashMap两个接口

 Map中的底层结构有两个，Map是一个接口，不能直接实例化对象，如果要实例化对象只能实现他的实现类 TreeMap和HashMap。

TreeMap的底层结构是一颗红黑树，而HashMap的底层结构就是一个哈希桶。

 下面我们来进行一下二叉搜索树进行TreeMap的模拟

二叉搜索树左边的节点永远小于中间的节点，中间的节点永远小于右边的节点，根据这个原则我们可以进行操作

首先我们创建节点

private class TreeNode{
        private TreeNode left;
        private TreeNode right;
        private int val;

        private TreeNode(int val){
            this.val = val;
        }
    }
    private TreeNode root;

插入操作的时候要注意几点

1、如果此时的根节点是空的，我们要把根节点建立起来

2、如果根节点已经有了值，我们将传入的val与根节点进行比较，如果根节点小就要放在右边，如果根节点大就要放在左边，如果相等就插入失败，因为二叉搜索树不可以有重复的值

3、定义pre  和  cur，每次插入肯定是在遍历到cur等于null的时候

public boolean insert(int key) {
        if(root == null) {
            root = new TreeNode(key);
            return true;
        }
        TreeNode pre = null;
        TreeNode cur = root;
        while(cur != null){
            if(key < cur.val){
                pre = cur;
                cur = cur.left;
            }else if(key > cur.val){
                pre = cur;
                cur = cur.right;
            }else{
                return false;
            }
        }
        if(pre.val < key){
            pre.right = new TreeNode(key);
        }else{
            pre.left = new TreeNode(key);
        }
        return true;
    }

 下面是查询操作，与插入操作基本一致，不同的是只需要一个cur进行遍历，找到了返回true，没找到返回false

 public TreeNode search(int key) {
        TreeNode cur = root;
        while(cur != null){
            if(cur.val == key){
                return cur;
            } else if (key < cur.val) {
                cur = cur.left;
            }else{
                cur = cur.right;
            }
        }
        return null;
    }

接下来就是最重要的删除操作，删除操作有些麻烦，但是万变不离其宗，想要删除一个节点肯定就要先找到这个点

//删除key的值
    public boolean remove(int key) {
        TreeNode cur = root;
        TreeNode pre = null;
        while(cur != null){
            if(cur.val == key){
                dele(pre,cur);
            } else if (key < cur.val) {
                pre = cur;
                cur = cur.left;
            }else{
                pre = cur;
                cur = cur.right;
            }
        }
        return false;
    }

在删除的时候，会有三种情况：

一：cur（待删除的点）的左边是空的，如果cur在pre的右边，就让pre的右边等于cur的右边。如果cur在pre的左边，就让pre的左边等于cur的右边，完成删除。在此之前需要判断root是否等于cur，如果等于就直接让root等于root的右边就好

二：cur（待删除的点）的左边是空的，如果cur在pre的右边，就让pre的右边等于cur的左边。如果cur在pre的左边，就让pre的左边等于cur的左边，完成删除。在此之前需要判断root是否等于cur，如果等于就直接让root等于root的左边就好

三：cur（待删除的点）左边和右边都不是空的，我们需要使用替罪羊法，找到待删除节点的次大的节点，让这个节点与待删除的节点的值进行交换，然后删除次大的那个点。

首先我们来一起看一下第一种删除情况：、

一：1、cur在pre的右边：

 

 因为要保证二叉搜索树的性质，所以我们要把cur删除，需要让pre.right = cur.right;

        2、cur在pre的左边：

 我们要删除cur，就需要让pre.left = cur.right;

        3、cur是root节点，只需要让root == root.right就好，因为是在cur左边是空的条件下的，所以root = root.right;

删除的第二种情况，与第一种情况类似，这次是cur的左边有值，右边是空的，还是要分三种情况，cur == root      cur == pre.left      cur == pre.right

对此展示三幅图片：

删除的第三种情况稍微有些麻烦，就是cur的左边右边全部都有节点的时候，因为碍于二叉搜索树的性质，我们删除cur的时候必须要好好考虑一个问题，就是我们把cur删除之后剩下的节点还能不能构成一棵二叉搜索树。

这就需要引入一个方法，替罪羊法进行删除。

什么是替罪羊删除法？其实就是把cur的值换成另一个适合在这个位置的节点的值，然后把另一个节点删除，这就是替罪羊删除法。

那么问题又来了，我们如何找到一个近似cur的值，用来交换呢？

二叉搜索树左边节点大于中间节点大于右边节点，我们只要找到次大于cur的节点的值，然后让这两个节点的值进行交换，然后删除次大于cur的那个节点就行了，所以就要找cur的右边的节点来代替了，具体做法参照下图

        

定义一个tp == cur    t = cur.right 然后一直向t的左节点遍历，知道t.left == null 的时候，t所处的节点就是要和cur进行值交换的节点，然后删除t即可。

还有一种情况是t的左边没有节点了，那么我们只需将 tp.right = t.right 就能将t给删除

 

 删除操作的代码：

public boolean remove(int val){
        TreeNode cur = root;
        TreeNode pre = null;
        while(cur != null){
            if(val < cur.val){
                pre = cur;
                cur = cur.left;
            }else if(val > cur.val){
                 pre = cur;
                 cur = cur.right;
            }else{
                dele(pre,cur);
                return true;
            }
        }
        return false;
    }
    private void dele(TreeNode pre,TreeNode cur){
        if(cur.left == null){
            if(cur == root){
                root = cur.right;
            } else if (pre.right == cur) {
                pre.right = cur.right;
            }else{
                pre.left = cur.right;
            }
        }else if(cur.right == null){
            if(cur == root){
                root = cur.left;
            }else  if(pre.left == cur){
                pre.left = cur.left;
            }else {
                pre.right = cur.left;
            }
        }else {
            TreeNode targe = cur.right;
            TreeNode targeparent = cur;
            while(targe.left != null){
                targeparent = targe;
                targe = targe.left;
            }
            cur.val = targe.val;
            if(targe == targeparent.left){
                targeparent.left = targe.right;
            }else{
                targeparent.right = targe.right;
            }

        }
    }

 TreeMap和TreeSet以二叉搜索树作为底层结构是远远不够的，二叉搜索树的搜索过程类似于一个二分查找的过程，每次取数据的一半进行查找，但是这种方法有一个缺陷，当树构成了一个单链，即数据是递增排列的时候，查找的时间复杂度会退化成O(N)，如下图

如此以来，二叉搜索树的快速搜索就失去了作用，所以TreeMap和TreeSet的底层是红黑树，由于红黑树是一种很复杂的结构，后续我们会对其进行讲解，这里了解即可。

TreeMap&TreeSet的介绍：

TreeMap 和 TreeSet 因为其底层是红黑树，所以查找的时间复杂度是O(logN)

Map方法：

方法：	解释：
V get(Object key)	返回key对应的value
V getOrDefault(Object key, V defaultValue)	返回key对应的value，key不存在就返回默认值。
V put(K key,V value)	设置key对应的value
V remove(Object key)	删除key 对应的映射关系
Set<K> keySet()	返回key所有的不重复集合
Collection<V>values()	返回所有value的可重复集合
Set<Map.Entry<K,V>> entrySet()	返回所有K-V的映射关系
boolean containsKey(Object key)	判断是否包含key
boolean containsValue(Object val)	判断是否包含Value

值得注意的是：

1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
2. Map中存放键值对的Key是唯一的，value是可以重复的
3. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
4. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
5. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。
 

Set方法：

方法	解释
boolean add(E e)	添加元素，但重复元素不会被添加成功
void clear()	清空集合
boolean contains(Object o)	判断 o 是否在集合中
Iterator<E> iterator()	返回迭代器
boolean remove(Object o)	删除集合中的 o
int size()	返回set中元素的个数
boolean isEmpty()	检测set是否为空，空返回true，否则返回false
Object[] toArray()	将set中的元素转换为数组返回
boolean containsAll(Collection<?> c)	集合c中的元素是否在set中全部存在，是返回true，否则返回 false
boolean addAll(Collection<? extends E> c)	将集合c中的元素添加到set中，可以达到去重的效果

注意：

1. Set是继承自Collection的一个接口类
2. Set中只存储了key，并且要求key一定要唯一
3. Set的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
4. Set最大的功能就是对集合中的元素进行去重
5. 实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础维护了一个双向链表来记录元素的插入次序。
6. Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
7. Set中不能插入null的key。