数据结构-Map和Set

小许学java2025-10-14 12:34

先赞后看，养成习惯！ ❤️ ❤️ ❤️
我是小许，一个坚持输出干货的 Java 学习者！
码字不易，你的点赞与关注，是我持续更新的动力！
✨ 小许学Java ✨

个人主页 ：小许学Java

专栏 ：Java 学习笔记

如有错误，欢迎指正批评 ^ _ ^

1. 搜索树

1.1 概念

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

若它的左子树不为空，则左子树上的所有节点都小于根节点的值。

若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。

它的左右子树也分别为二叉搜索树。

int[] array = {5,3,4,1,7,8,2,6,0,9};

1.2 操作-查找

1.3 操作-插入

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

1.4 操作-删除(难点)

设待删除节点为cur，待删除节点的双亲节点为parent。

1. cur.left==null

a. cur是root，则root=cur.right

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

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

2. cur.right==null

a. cur是root，则root=cur.left

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

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

3. cur.left!=null&&cur.right!=null

需要使用替换法进行删除，即在它的右子树中寻找中序的下一个节点(关键码最小)，用他的值填补到被删除节点中，再来处理该节点的删除问题。

1.5 实现

java 复制代码 
public class BinarySearchTree {
    public static class Node{
        int key;
        Node left;
        Node right;
        public Node(int key){
            this.key = key;
        }
    }
    private Node root=null;
    //在搜索树中查找 key，如果找到，返回 key 所在的结点，否则返回 null
    public Node search(int key){
        Node cur=root;
        while (cur!=null){
            if (key==cur.key){
                return cur;
            }else if(key< cur.key){
                cur=cur.left;
            }else {
                cur=cur.right;
            }
        }
        return null;
    }
    //插⼊
    public boolean insert(int key){
        if (root==null){
            root=new Node( key);
            return true;
        }
        Node cur=root;
        Node parent=null;
        while (cur!=null){
            if (key==cur.key){
                return false;
            }else if (key<cur.key){
                parent=cur;
                cur=cur.left;
            }else {
                parent=cur;
                cur=cur.right;
            }
        }
        Node node=new Node(key);
        if (key<parent.key){
            parent.left=node;
        }else {
            parent.right=node;
        }
        return true;
    }
    //删除成功返回 true，失败返回 false
    public boolean remove(int key){
        Node cur=root;
        Node parent=null;
        while (cur!=null){
            if (key==cur.key){
                break;
            }else if (key<cur.key){
                parent=cur;
                cur=cur.left;
            }else {
                parent=cur;
                cur=cur.right;
            }
        }
        //该元素不在二叉搜索树中
        if (cur==null){
            return false;
        }
        /*
        根据cur的孩⼦是否存在分四种情况
        1. cur左右孩⼦均不存在
        2. cur只有左孩⼦
        3. cur只有右孩⼦
        4. cur左右孩⼦均存在
        */
        //有两个子节点
        if (cur.left!=null && cur.right!=null){
            //找到右子树额最小节点
            Node successor=cur.right;
            Node successorParent=cur;
            while (successor.left!=null){
                successorParent=successor;
                successor=successor.left;
            }
            // 将后继节点的值复制到当前节点
            cur.key = successor.key;
            // 接下来删除后继节点（它最多只有一个右子节点）
            cur=successor;
            parent=successorParent;
        }
        // 此时 cur 最多只有一个子节点
        Node child;
        if (cur.left != null) {
            child = cur.left;
        } else {
            child = cur.right;
        }
        // 情况2：删除的是根节点
        if (parent == null) {
            root = child;
        }
        // 情况3：不是根节点，根据 cur 是 parent 的左还是右孩子来更新指针
        else if (parent.left == cur) {
            parent.left = child;
        } else {
            parent.right = child;
        }

        return true;
    }
}

1.6 性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，其平均比较次序为：O(logN)

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

1.7 和Java类集的关系

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

2. 搜索

Map和set是⼀种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。

以前常见的搜索方式有：

  1. 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢

  2. 二分查找，时间复杂度为O(log n)，但搜索前必须要求序列是有序的

上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如：

  1. 根据姓名查询高考成绩

  2. 通讯录，即根据姓名查询联系方式

  3. 不重复集合，即需要先搜索关键字是否已经在集合中

可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本节介绍的Map和Set是一种适合动态查找的集合容器。

2.2 模型

一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种：

  1. 纯key模型，比如：

有一个英文词典，快速查找一个单词是否在词典中

快速查找某个名字在不在通讯录中

  1. key-value模型，比如：

统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>

梁山好汉江湖绰号：每个好汉都有自己的江湖绰号

3. Map的使用

3.1 关于Map的说明

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

3.2 Map.Entry<k,v>的说明

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

注意：Map.Entry<k，v>并没有提供设置key的方法

3.3 Map的常用方法说明

注意：

  1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者 HashMap。

  2. Map中存放键值对的Key是唯一的，value是可以重复的。

  3. 在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以 为空。但是HashMap的key和value都可以为空。

  4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。

  5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。

  6. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

  7. TreeMap和HashMap的区别【HashMap在最后会讲到】

3.4 TreeMap的使用案例

java 复制代码 
public class TestMap {
    public static void TestMap(){
        Map<String,String> m=new TreeMap<>();
        m.put("林冲", "豹⼦头");
        m.put("鲁智深", "花和尚");
        m.put("武松", "⾏者");
        m.put("宋江", "及时⾬");
        String str = m.put("李逵", "⿊旋⻛");
        System.out.println(m.size());
        System.out.println(m);
        // put(key,value): 注意key不能为空，但是value可以为空
        // key如果为空，会抛出空指针异常
        //m.put(null, "花名");
        str = m.put("⽆名", null);
        System.out.println(m.size());
        // put(key, value):
        // 如果key存在，会使⽤value替换原来key所对应的value，返回旧value
        str = m.put("李逵", "铁⽜");
        // get(key): 返回key所对应的value
        // 如果key存在，返回key所对应的value
        // 如果key不存在，返回null
        System.out.println(m.get("李逵"));
        System.out.println(m.get("张三"));
        //GetOrDefault(): 如果key存在，返回与key所对应的value，如果key不存在，返回⼀个默认值
        System.out.println(m.getOrDefault("张三", "张三"));
        System.out.println(m.getOrDefault("李逵", "李逵"));
        System.out.println(m.size());
        //containKey(key)：检测key是否包含在Map中，时间复杂度：O(logN)
        // 按照红⿊树的性质来进⾏查找
        // 找到返回true，否则返回false
        System.out.println(m.containsKey("张三"));
        System.out.println(m.containsKey("李逵"));
        // containValue(value): 检测value是否包含在Map中，时间复杂度: O(N)
        // 找到返回true，否则返回false
        System.out.println(m.containsValue("花和尚"));
        System.out.println(m.containsValue("黑旋风"));
        // 打印所有的key
        // keySet是将map中的key防⽌在Set中返回的
        for (String s:m.keySet()){
            System.out.print(s+" ");
        }
        System.out.println();
        // 打印所有的value
        // values()是将map中的value放在collect的⼀个集合中返回的
        for (String s:m.values()){
            System.out.print(s+" ");
        }
        System.out.println();
        // 打印所有的键值对
        // entrySet(): 将Map中的键值对放在Set中返回了
        for (Map.Entry<String, String> entry:m.entrySet()){
            System.out.println(entry.getKey()+" "+entry.getValue());
        }
        System.out.println();
    }

    public static void main(String[] args) {
        TestMap();
    }
}

4. Set的说明

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

4.1 常见方法说明

注意：

  1. Set是继承自Collection的⼀个接口类

  2. Set中只存储了key，并且要求key一定要唯一

  3. TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的

  4. Set最大的功能就是对集合中的元素进行去重

  5. 实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在 HashSet的基础上维护了一个双向链表来记录元素的插入次序。

  6. Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入。

  7. TreeSet中不能插入null的key，HashSet可以。

  8. TreeSet和HashSet的区别【HashSet在最后会讲到】

4.2 TreeSet的使用案例

java 复制代码 
public class TestSet {
    public static void TestSet(){
        Set<String> s=new TreeSet<>();
        // add(key): 如果key不存在，则插⼊，返回ture
        // 如果key存在，返回false
        boolean isIn=s.add("apple");
        s.add("pear");
        s.add("orange");
        s.add("banana");
        System.out.println(s.size());
        System.out.println(s);
        // contains(key): 如果key存在，返回true，否则返回false
        System.out.println(s.contains("apple"));
        System.out.println(s.contains("watermelen"));
        // remove(key): key存在，删除成功返回true
        // key不存在，删除失败返回false
        // key为空，抛出空指针异常
        s.remove("apple");
        System.out.println(s);
        s.remove("watermelen");
        System.out.println(s);
        Iterator<String> it=s.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        TestSet();
    }
}

5. 哈希表

5.1 概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找⼀个元素时，必须要经过关键码的多次次较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log N)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结 构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建建立映射的关系，那么在 查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。

搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素 比较，若关键码相等，则搜索成功。

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)。

例如：数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key)=key%capacity; capacity为存储元素底层空间总的大小。

5.2 冲突-概念

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

把具有不同关键码而具有相同哈希地址的数据元素称为"同义词"。

5.3 冲突-避免

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

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

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。哈希函数设计原则：

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须 在0到m-1之间。

哈希函数计算出来的地址能均匀分布在整个空间中。

哈希函数应该比较简单。

5.4.1 常见哈希函数

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

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

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

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

注意：哈希函数着急的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

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

负载因子和冲突率的关系粗略演示：

所以当冲突率达到⼀个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。

已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

5.6 冲突-解决

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

5.7 冲突-解决-闭散列

闭散列：也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的"下⼀个"空位置中去。那如何寻找下一个空位置呢？

5.7.1 线性探测

比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

插入

通过哈希函数获取待插入元素在哈希表中的位置。

如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下⼀个空位置，插入新元素。

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

5.7.2 二次探测

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

例如：44：Hi=(4+1^2)%10，14：Hi=(4+2^2)%10

5.7.3 总结

1. 优点

不需要额外的数据结构（如链表），空间利用率高。

实现相对简单。

缓存性能好，因为数据都存储在连续的内存空间中。

不需要存储指针，节省空间。

  1. 缺点：

容易产生聚集现象（尤其是线性探测）。

删除操作复杂（需要特殊处理以保持查找链的完整性）。

装载因子不能太大，否则性能会急剧下降。

二次聚集（对于二次探测）。

5.8 冲突-解决-开散列/哈希桶（重点掌握）

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每⼀个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了。

5.9 冲突严重时的解决办法

刚才我们提到了，哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

  1. 每个桶的背后是一棵搜索树

  2. 每个桶的背后是另一个哈希表

  3. 哈希函数重新设计

  4. .....

5.10 实现

java 复制代码 
public class HashBucket {
    private static class Node{
        private int key;
        private int value;
        Node next;
        public Node(int key, int value){
            this.key = key;
            this.value = value;
        }
    }
    private Node[] array;
    private int size;//当前数据个数
    private static final double LOAD_FACTOR = 0.75;
    public int put(int key,int value){
        int index=key%array.length;
        // 在链表中查找 key 所在的结点
        // 如果找到了，更新
        // 所有结点都不是 key，插⼊⼀个新的结点
        for (Node cur=array[index];cur!=null;cur=cur.next){
            if (key==cur.key){
                int oldValue=cur.value;
                cur.value=value;
                return oldValue;
            }
        }
        Node node=new Node(key,value);
        node.next=array[index];
        array[index]=node;
        size++;
        if (loadFactor()>=LOAD_FACTOR){
            resize();
        }
        return -1;
    }
    private double loadFactor() {
        return size * 1.0 / array.length;
    }
    public HashBucket() {
        array = new Node[8];
        size = 0;
    }
    public void resize(){
        Node[] newArray=new Node[array.length*2];
        for (int i=0;i<array.length;i++){
            Node next;
            for (Node cur=array[i];cur!=null;cur=next){
                next=cur.next;
                int index=cur.key%newArray.length;
                cur.next=newArray[index];
                newArray[index]=cur;
            }
        }
        array = newArray;
    }
    public int get(int key) {
        int index = key % array.length;
        Node head = array[index];
        for (Node cur = head; cur != null; cur = cur.next) {
            if (key == cur.key) {
                return cur.value;
            }
        }
        return -1;
    }
}

5.11 性能分析

虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/ 删除/查找时间复杂度是O(1)。

5.12 和 java 类集的关系

  1. HashMap和HashSet即 java 中利用哈希表实现的Map和Set。

  2. java中使用的是哈希桶方式解决冲突的。

  3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）。

  4. java中计算哈希值实际上是调用的类的hashCode方法，进行key的相等性比较是调用key的equals方法。所以如果要用自定义类作为HashMap的key或者HashSet的值，必须覆写hashCode和equals方法，而且要做到equals相等的对象，hashCode一定是一致的。

相关推荐
西阳未落5 小时前
LeetCode——双指针（进阶）
c++·算法·leetcode
一二学长5 小时前
异或相关的算法题
算法
暴力求解6 小时前
c++类和对象（下）
开发语言·c++·算法
艾莉丝努力练剑6 小时前
【Linux指令 (二)】不止于入门：探索Linux系统核心与指令的深层逻辑，理解Linux系统理论核心概念与基础指令
linux·服务器·数据结构·c++·centos
深栈6 小时前
机器学习：支持向量机
算法·机器学习·支持向量机
刘海东刘海东6 小时前
结构型智能科技理论研究（草稿）
科技·算法
C嘎嘎嵌入式开发7 小时前
（10）100天python从入门到拿捏《Python中的数据结构与自定义数据结构》
数据结构·python·算法
熬了夜的程序员7 小时前
【LeetCode】69. x 的平方根
开发语言·算法·leetcode·职场和发展·动态规划
Niuguangshuo7 小时前
音频特征提取算法介绍
算法·音视频
热门推荐
01BongoCat - 跨平台键盘猫动画工具02两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答03智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践04GitHub 镜像站点05UV安装并设置国内源06Linux下V2Ray安装配置指南07GitLab 零基础入门指南：从安装到项目管理全流程082025羊城杯网络安全大赛 wp09Cursor Plan Mode：AI 终于知道先想后做了10Spring Boot 实现微信登录，So Easy !