Java(二十七)---二叉搜索树以及Map和Set

文章目录

前言
1.二叉搜索树
- 1.1.概念
- 1.2.操作--- 插入
- 1.3.操作---搜索
- 1.4.操作---删除
- 1.6.性能分析
- 1.7 和 java 类集的关系
2.搜索
- 2.1.概念和场景
- 2.2.模型
3.Map的使用
- 3.1.关于Map的说明
- 3.2.Map.Entry<K,V>的说明
- 3.3.Map中常用的方法
- 3.4.TreeMap的使用案例
4.Set的使用
- 4.1 常见方法说明
5.哈希
- 5.1.概念
- 5.2 冲突-概念
- 5.3 冲突-避免
- 5.4 冲突-避免-哈希函数设计
- 5.5 冲突-避免-负载因子调节（重点掌握）
- 5.6 冲突-解决
- 5.7 冲突-解决-闭散列
- 5.8 冲突-解决-开散列/哈希桶（重点掌握）
- 5.9 冲突严重时的解决办法

前言

前几篇博客中，我们学习了有关二叉树、优先级队列等知识点，今天我们学习新的知识点—二叉搜索树，Map以及Set

1.二叉搜索树

1.1.概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

在这里插入图片描述

1.2.操作— 插入

第一步：判断root是否为空，为空的话，就把新节点定义为头结点，不然的话，就要进行遍历。
第二步：创建三个节点，cur(用于遍历)，parent(用于记录cur前一个节点)，node(新的节点)，cur进行遍历，遍历完后找到相应的位置，让parent的left或者right节点跟node建立联系。


public class BinarySearchTree {
    static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }
    public TreeNode root;
    public void insert(int key){
        if (root == null){
            root = new TreeNode(key);
            return;
        }
        TreeNode parnet = null;
        TreeNode cur = root;
        TreeNode node = new TreeNode(key);
        while (cur != null){
            if (cur.val > key){
                parnet = cur;
                cur = cur.left;
            }else if (cur.val < key){
                parnet = cur;
                cur = cur.right;
            }else {
                return;
            }
        }
        if (parnet.val > key){
            parnet.left = node;
        }else {
           parnet.right = node;
       }
    }
}

1.3.操作—搜索

这段代码就不多进行介绍了，相信大家可以看懂

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

1.4.操作—删除

这个删除操作不简单，主要是要想好几种情况，我们使用替代法，但是要找到那个需要替代的节点并不容易，现在我们进行分类讨论。
其中cur 中有一段有空 (cur.left == null 或者是 cur.right == null) ，这两种情况比较大同小异，我已cur.left == null 举例
在这里插入图片描述
cur.right == null 跟上面情况一模一样，我就不在过多叙述。
但是如果 cur.left != null 并且 cur.right != null 的话，那么就需要使用替代法啦。

找谁去替代呢？
从 cur 的左右子树开始找，可以找 cur.left后的节点的最大值(cur.left 后面的右节点为空)，或者就是cur.right 后的节点的最小值(cur.right后面的左节点为空)。
在这我们选择第二个，找cur.right 后的节点的最小值

 public void remove(int key){
        TreeNode parent = null;
        TreeNode cur = root;
        while (cur != null){
            if (cur.val > key){
                parent = cur;
                cur = cur.left;
            }else if (cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                removeNode(parent,cur);
                return;
            }
        }
    }

    private void removeNode(TreeNode parent, TreeNode cur) {
        if (cur.left == null){
           if (cur == root){
               root = root.right;
           }else if(cur == parent.left){
               parent.left = cur.right;
           }else if (cur == parent.right){
               parent.right = cur.right;
           }
        } else if (cur.right == null) {
            if (cur == root){
                root = root.right;
            } else if (cur == parent.left) {
                parent.left = cur.left;
            }else if (cur == parent.right){
                parent.right = cur.left;
            }
        } else {
            TreeNode targetParent = cur;
            TreeNode target = cur.right;
            while (target != null){
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if (targetParent.left == target){
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }

1.6.性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

在这里插入图片描述
最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：logN
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2

1.7 和 java 类集的关系

TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set；实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 + 颜色以及红黑树性质验证，关于红黑树的内容后序再进行讲解。

2.搜索

2.1.概念和场景

Map和Set是一种专门用来搜索的容器和数据结构，其搜索效率与其具体实例化的例子有关，以前我们常用的搜索方法：
直接查找，时间复杂度是O(n),随着元素的增加，效率会变慢。
二分查找：时间复杂度是O(logn)，前提是：数组必须是有序地
上述的搜索方法比较适合于静态的，即一般不会在区间中进行增加和查改，例如：

根据姓名查询学生考试成绩
通讯录，即根据姓名进行查找联系电话
不重复集合，即需要先搜索关键字是否已经在集合中
可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本节介绍的Map和Set是一种适合动态查找的集合容器。

2.2.模型

我们一般吧关键字称为key，把关键字对应的值称为value，有两种存储模型：

纯k模型，例如：
快速查找一个单词，是否出现在字典中
键值对key-value模型：例如：
统计一句话中，每个单词出现的次数。

而Map中存储的就是key-value的键值对，Set中只存储了Key。

3.Map的使用

在这里插入图片描述
我们再把这个照片拿出来，我们会发现。现在只剩下了Map和Set，下面来介绍一下Map

3.1.关于Map的说明

Map是一个接口类，该类没有继承自Collection，该类中存储的是<K,V>结构的键值对，并且K一定是唯一的，不能重复。

3.2.Map.Entry<K,V>的说明

Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式。

方法	解释
K getKey()	返回entry中的key
V getValue()	返回entry中的value
V setValue(V value)	将键值对的value替换成指定的value

注意：Map.Entry<K,V>并没有提供设置Key的方法

3.3.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>>entry	返回所有的key-value 映射关系
boolean containsKey(Object key)	判断是否包含key
boolean containsValue(Object value)	判断是否包含value

注意：

Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
Map中存放键值对的Key是唯一的，value是可以重复的
在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以为空。但是HashMap的key和value都可以为空。
Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。
TreeMap和HashMap的区别【HashMap在课件最后会讲到】

Map底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶
插入/删除/查找的时间复杂度	O(logn)	O(1)
是否有序	关于Key有序	无序
线程安全	不安全	不安全
插入/删除/查找的区别	需要进行元素比较	通过哈希函数计算哈希地址
比较与复写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要复写equals和hashCode方法
应用场景	需要Key有序的场景下	Key是否有序不关心，需要更高的时间性能

3.4.TreeMap的使用案例

public static void main(String[] args) {
        Map<String ,Integer> map = new TreeMap<>();
        map.put("hello",4);
        map.put("world",20);
        map.put("Tom",5);
        // 获得每个key所对应的value
        Set<Map.Entry<String,Integer>> set =map.entrySet();
        for(Map.Entry<String,Integer>entry:set){
            System.out.println(entry.getKey()+" "+entry.getValue());
        }
        //修改"Tom"的值，对应值加1
        int val = map.get("Tom");
        map.put("Tom",val+1);

        map.getOrDefault("Jerry",20);
        System.out.println(map.containsKey("Tom"));
        System.out.println(map.containsValue(10));
    }

大家可使用TreeMap来实例化Map，看看TreeMap和HashMap的不同。

4.Set的使用

Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key。

4.1 常见方法说明

方法	解释
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中，可以达到去重的效果
注意：

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

Set底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶
插入/删除/查找的时间复杂度	O(logn)	O(1)
是否有序	关于Key有序	不一定有序
线程安全	不安全	不安全
插入/删除/查找的区别	按照红黑树的特性来进行插入和删除	1.先计算key的哈希值
比较与复写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要复写equals和hashCode方法
应用场景	需要Key有序的场景下	Key是否有序不关心，需要更高的时间性能

5.哈希

5.1.概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN )，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(HashTable)(或者称散列表)
例如：
数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
在这里插入图片描述
但是如果要存放44 ，该怎么存呢？

5.2 冲突-概念

对于两个数据元素的关键字和 (i != j)，有 != ，但有：Hash( i ) == Hash( j )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

5.3 冲突-避免

首先，我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。

5.4 冲突-避免-哈希函数设计

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。哈希函数设计原则：
哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间哈希函数计算出来的地址能均匀分布在整个空间中哈希函数应该比较简单
常见哈希函数

直接定制法–(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关
键字的分布情况使用场景：适合查找比较小且连续的情况
除留余数法–(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：
Hash(key) = key% p(p<=m),将关键码转换成哈希地址
平方取中法–(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，
并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
通常应用于关键字长度不等时采用此法

5.5 冲突-避免-负载因子调节（重点掌握）

在这里插入图片描述
负载因子和冲突率的关系粗略演示

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

5.6 冲突-解决

解决哈希冲突两种常见的方法是：闭散列和开散列

5.7 冲突-解决-闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？
线性探测
比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

插入

通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

在这里插入图片描述

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标
记的伪删除法来删除一个元素。
二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨
着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： = ( + )% m, 或者：
= ( - )% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。对于2.1中如果要插入44，产生冲突。

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不
会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。