数据结构中（Map 和 Set）的那些事

wileda

已于 2022-11-26 15:24:14 修改

阅读量373

点赞数

分类专栏：数据结构文章标签：数据结构

于 2022-11-26 15:20:29 首次发布

本文链接：https://blog.csdn.net/qq_53223625/article/details/128025147

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

2.3TreeMap 和 HashMap 的区别

3.Set

3.1Set常用的方法

3.2TreeSet 和 HashSet 的区别

1.概念

1.1搜索

搜索是根据目标值在一个的特定的集合或者容器中寻找到它

以前常见的搜索有：直接遍历查找；二分查找。这些搜索的方法大大小小都有一定的限制条件，因此效率问题值得商榷。

本章我们学习了 Set 和 Map这两种搜索模型：Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。

1.2模型

我们一般把搜索的数据称为关键字(Key)，和关键字对应的值称为(Value)将其称之为Key-value的键值对，所以模型会有两种：
1. 纯 key 模型，比如：

有一个英文词典，快速查找一个单词是否在词典中
快速查找某个名字在不在通讯录中

2. Key-Value 模型，比如：

统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号

1.3集合框架

2.Map

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

2.1关于Map.Entry<K, V>的说明

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

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

2.2Map的常用方法

注意：

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

2.3TreeMap 和 HashMap 的区别

Map底层结构：

        TreeMap:红黑树

        HashMap：哈希桶

操作时间复杂度：

        TreeMap：O(log2N)

        HashMap: O(1)

是否有序：

        TreeMap：关于Key有序

        HashMap: 无序

线程安全：

        TreeMap：不安全

        HashMap: 安全

插入/删除/查找区别：

        TreeMap：需要进行元素比较

        HashMap: 通过哈希函数计算哈希地址

比较覆写：

        TreeMap：key必须能够比较，否则会抛ClassCastException异常

        HashMap:  自定义类型需要覆写equals和hashCode方法

应用场景：

TreeMap: 需要Key有序的场景下

        HashMap:Key是否有序不关心，需要更高的时间性能

3.Set

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

3.1Set常用的方法

注意：

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。

3.2TreeSet 和 HashSet 的区别

底层结构：

TreeSet: 红黑树

        HashSet: 哈希桶
插入/删除/查找时间复杂度:

        TreeSet: O(log2N)

        HashSet: O(1)
是否有序:

TreeSet: 关于Key有序

        HashSet: 不一定有序
线程安全:

        TreeSet: 不安全

HashSet:不安全
插入/删除/查找区别

        TreeSet:按照红黑树的特性来进行插入和删除
        HashSet:1. 先计算key哈希地址 2. 然后进行插入和删除
比较与覆写:
        TreeSet: 必须能够比较，否则会抛出ClassCastException异常
        HashSet:自定义类型需要覆写equals和hashCode方法
应用场景:

        TreeSet:需要Key有序场景下
        HashSet:Key是否有序不关心，需要更高的时间性能

4.搜索树

4.1概念

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

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

二叉搜索树的特性：中序遍历的结果是有序的

0 1 2 3 4 5 6 7 8 9

4.2查找

若根节点不为空：

如果根节点key == 查找的值key,返回true

如果根节点key值 > 查找的值key，在其左子树查找

如果根节点key值 < 查找的值key，在其右子树查找

否则，返回false

public boolean search(int value){
        //空树直接返回
        if(root == null){
            return false;
        }
        TreeNode current = root;
        //遍历二叉树
        while(current != null){
        //找到了直接返回
            if(current.value == value){
                return true;
            }
        //去左树找
            if(value < current.value){
                current = current.left;
            }else{
        //去右树找
                current = current.right;
            }
        }
        return false;
    }

4.3插入

1. 如果树为空树，即根 == null，直接插入
2. 如果树不是空树，按照查找逻辑确定插入位置，插入新结点

例如插入：42

首先与根节比较，比根节点小

再去左子树比较，比左子树的根节点大

再去左子树的右子树比较，大于34

所以最终42在34的右边

 public boolean insert(int value){
        TreeNode node = new TreeNode(value);
        //如果是一个空树，将插入结点放在根节点即可
        if(root == null){
            root = node;
            return true;
        }
        //用来遍历的结点
        TreeNode current = root;
        //用来记录current的父亲结点
        TreeNode prev = null;
        //遍历二叉树
        while(current != null){
        //判断是否相等
            if(current.value == value){
        //如果相等直接返回
                return false;
            }
        //找到真正要插入的位置
            prev = current;
            if(node.value < current.value){
                current = current.left;
            }else{
                current = current.right;
            }
        }
        // 当current == null时，prev 就在一个叶子节点的位置
        // 根据prev的值来确定新节点在左还是在右
        if(value < prev.value){
            prev.left = node;
        }else {
            prev.right = node;
        }
        return true;
    }

4.4删除

设待删除结点为 cur, 待删除结点的双亲结点为 parent
1. cur.left == null
        1. cur 是 root，则 root = cur.right

        2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.right

        3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.right

2. cur.right == null
        1. cur 是 root，则 root = cur.left

        2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.left

        3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.left

3. cur.left != null && cur.right != null
1. 需要使用替换法进行删除，即在它的右子树找到最小的结点或者在左子树找到最大的结点，用它的值填补到被删除节点中，再来处理该结点的删除问题

public boolean remove(int value) {
        if (root == null) {
            return false;
        }
        // 找到要删除元素
        TreeNode current = root;
        TreeNode parent = null;
        while (current != null) {
            if (current.value == value) {
                removeNode(parent, current);
                return true;
            }
            // 记录父节点
            parent = current;
            if (value < current.value) {
                current = current.left;
            } else {
                current = current.right;
            }
        }

        return false;
    }

    private void removeNode(TreeNode parent, TreeNode current) {
        if (current.left == null) {
            // 当左孩子节点为空时进入
            if (current == root) {
                // 把当前要删除节点的右孩子赋给root
                root = current.right;
            } else if (current == parent.left) {
                // 当前节点是父节点的左孩子节点时
                parent.left = current.right;
            } else {
                // 当前节点是父节点的右孩子节点时
                parent.right = current.right;
            }
        } else if (current.right == null) {
            // 当前节点是根节点时
            if (current == root) {
                root = current.left;
            } else if (current == parent.left) {
                // 当前节点是父点的左孩子节点时
                parent.left = current.left;
            } else {
                // 当前节点是父节点的右孩子节点时
                parent.right = current.left;
            }
        } else {
            // 定义用来遍历的几个变量
            TreeNode target = current.right;
            TreeNode parentTarget = current;
            // 向左去找最小值
            while (target.left != null) {
                parentTarget = target;
                target = target.left;
            }
            // 到达叶子节点时
            current.value = target.value;
            // 删除target节点
            if (target == parentTarget.left) {
                parentTarget.left = target.right;
            } else {
                parentTarget.right = target.right;
            }
        }
    }

4.5性能分析

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2N
最差情况下，二叉搜索树退化为单支树，其平均比较次数为： N/2

5.哈希表

5.1概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( log2N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。所以哈希表就是完成了这个事情。

5.2哈希表的插入与搜索

插入：根据待插入元素的关键码，利用函数计算出插入位置

查找：对元素进行哈希计算，然后找到相应的位置

5.3哈希冲突

哈希冲突指，两个或以上的待插入元素经过哈希函数计算，所要插入的位置是同一地址，这种现象称为哈希冲突或者哈希碰撞

要知道哈希表底层数组的容量往往小于待插入元素的个数，所以出现哈希冲突是必然的，我们能做的就是降低冲突率

5.4常见哈希函数

1. 直接定制法--(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况

2. 除留余数法--(常用)

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

3. 平方取中法--(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4.随机数法--(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。

减少哈希冲突的方法还有很多，哈希函数设计的越精妙，产生冲突的可能就越小，但是无法完全避免哈希冲突

5.5两种常用的方法(开散列和闭散列)

1.闭散列

线性探测：

从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

通过哈希函数计算待插入元素在哈希桶的位置
如果该位置没有元素则直接插入新的元素，如果有元素已经存在，那么从该位置开始线性探测找到下一个空位置，插入新的元素。

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

二次探测 ：线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hi = (H0+i^2 )% m, 或者：Hi= (H0-i^2 )% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。

完成的效率相比于上述方法，避免挨个寻找。但是闭散列最大的缺陷是空间利用率比较低，这也是哈希的缺陷。

2.开散列

开散列又叫链地址法，首先对待插入元素做哈希地址，具有相同地址的归于一个集合，每个集合称为一个桶，各个桶的元素通过一个单链表连接起来，各个链表的头节点存在哈希桶中。

3.开散列的实现

负载因子：

负载因子越大，哈希桶的冲突率会越高，所以负载因子达到一个值，我们要扩容，来减少冲突

public class HashBucket {
    // 由于是由单链表链接，定义一个节点对象
    private static class Node {
        int key;
        int value;
        Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    // 定义哈希桶，node类型
    private Node[] bucket;
    // 当前有效元素的个数
    private int size;
    // 定义负载因子
    private final float DEFAULT_LOAD_FACTOR = 0.75f;

    public HashBucket () {
        bucket = new Node[8];
    }

    /**
     * 写入操作
     * @param key
     * @param value
     * @return
     */
    public int put (int key, int value) {
        // 1.根据key计算下标
        int index = key % bucket.length;
        // 2.拿到对应下标的元素，这个元素就是链表的头节点
        Node current = bucket[index];
        // 3. 遍历链表，检查是否存在key相同的元素
        while (current != null) {
            if (current.key == key) {
                // 找到的情况下
                int oldValue = current.value;
                current.value = value;
                return oldValue;
            }
            current = current.next;
        }
        // 4. 遍历完链表之后创建新节点
        Node node = new Node(key, value);
        // 5. 让新节点的next引用，当前下标中的节点
        node.next = bucket[index];
        // 6. 让当前下标存放新节点
        bucket[index] = node;
        // 7. 有效个数加1，正确的逻辑这个size是桶位的有效个数
        size++;
        // 8. 判断当前元素的个数(正确的是桶位的有效个数)是否超过负载因子
        if (loadFactor () >= DEFAULT_LOAD_FACTOR) {
            // 9. 扩容
            resize();
        }
        return value;
    }

    //扩容
    private void resize() {
        //创建一个新的数组，大小为原来数组的二倍
        Node[] array = new Node[bucket.length * 2];
        //遍历数组，取出所有元素重新hash
        for (int i = 0; i < bucket.length; i++){
            //取出第一个结点，向下遍历
            Node current = bucket[i];
            while (current != null){
                //记录下一个结点
                Node nextNode = current.next;
                //重新计算位置
                int index = current.key % array.length;
                //结点放入hash桶中
                current.next = array[index];
                array[index] = current;
                //移动到下一个结点
                current = current.next;
            }
        }
        bucket = array;
    }

    private float loadFactor() {
        return size * 1.0f / bucket.length;
    }

    public int get (int key) {
        //计算位置
        int index = key % bucket.length;
        //取出第一个结点
        Node current = bucket[index];
        //向下遍历
        while(current != null){
            //找到目标值
            if(current.key == key){
                return current.value;
            }
        }
        return -1;
    }

}

5.6 性能分析

虽然哈希冲突是不可避免的，但是在实际使用过程中，我们认为哈希冲突是不高的，冲突个数是可控的，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1) 。

wileda

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构中（Map 和 Set）的那些事

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hi = (H0+i^2 )% m, 或者：Hi= (H0-i^2 )% m。其中：i = 1,2,3…Map.Entry 是Map内部实现的用来存放键值对映射关系的内部类，该内部类中主要提供了的获取，value的设置以及Key的比较方式。TreeMap:红黑树。
复制链接

扫一扫