【数据结构】 | java中 map和set 详解

r囧r小猫 2024-04-29 19:17 11阅读 0赞

> 🎗️ 博客新人，希望大家一起加油进步  
> 🎗️ 乾坤未定，你我皆黑马

#### 目录 ####

*   *   *  1、搜索树("Tree")
         *   *  1.1 概念
             *  1.2 操作 - 查找
             *  1.3 操作 - 插入
             *  1.4 操作-删除（难点）
             *  1.5 性能分析
         *  2、搜索
         *   *  2.1 概念及场景
             *  2.2 模型
         *  3. Map的使用
         *   *  3.1 关于Map的说明
             *  3.2 关于Map.Entry<K, V>的说明
             *  3.3 Map 的常用方法说明
         *  4. Set的说明
         *   *  4.1 常见方法说明

我们首先来看一下集合的框架结构：  
![在这里插入图片描述][0877fa9dd08f4be68cd8e197538bda70.png]  
Set实现了Collection接口，Map是一个单独存在的接口。

而下面又分别各有两个类，分别是TreeSet（HashSet）和 HashSet（HashMap）  
Map和Set的作用是用来查找和搜索的；以后涉及到查找和搜索的可以选择使用这两个接口下面具体的类。  
搜索树(“Tree”)

#### 1、搜索树(“Tree”) ####

##### 1.1 概念 #####

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

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

如图所示：  
![在这里插入图片描述][eb77788d5b5747c29fa64d1eed5adefd.jpeg_pic_center]

##### 1.2 操作 - 查找 #####

思路如图：  
![在这里插入图片描述][d5663f89612f4094b86000758e74e95b.png]

*  **代码实现**

/**
         * 查找二叉搜索树中指定的val值
         *
         * @param val
         * @return
         */
        public TreeNode find(int val) {
        
            TreeNode cur = root;
    //        if(null == cur) {
        
    //            return null;
    //        }
            while (cur != null) {
        
                if (cur.val > val) {
        
                    cur = cur.right;
                } else if (cur.val < val) {
        
                    cur = cur.left;
                } else {
        
                    return cur;
                }
            }
            return null;
        }

##### 1.3 操作 - 插入 #####

*  如果树为空树，即根 == null，直接插入
 *  如果树不是空树，按照查找逻辑确定插入位置，插入新节点
 *  **注意：** 一般情况下是不插入相同的数据的  
    ![在这里插入图片描述][061f6f2f7d6c42bab5a7c0ad3b8cfec0.png]
 *  **代码实现**

/**
         * 插入一个数据
         *
         * @param val
         */
        public void insert2(int val) {
        
            if (root == null) {
        
                root = new TreeNode(val);
                return;
            }
            TreeNode cur = root;
            TreeNode parent = null;
            while (cur != null) {
        
                if(cur.val < val) {
        
                    parent = cur;
                    cur = cur.right;
                }
                if(cur.val > val) {
        
                    parent = cur;
                    cur = cur.left;
                }
            }
            //走完之后判断前一个结点是否比val大
            if(cur.val < val) {
        
                //parent.right.val = val;
                parent.right = new TreeNode(val);
            }
            if(cur.val > val) {
        
                //parent.left.val = val;
                parent.left = new TreeNode(val);
            }
        }

##### 1.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.4.1** 三种情况下也有具体要细分的：
 *  待删除的**左边为空** cur.left == null ，如图所示：  
    ![在这里插入图片描述][a9bf819d1b8a4ffea9c268ed8c932d0c.png]
 *  待删除的**右边为空** cur.left == null ，如图所示：

![在这里插入图片描述][32fa82f732e7458caeaed7b1d855bba2.png]

*  待删除的节点**左右边都不为空** .cur.left != null && cur.right != null ，如图所示：

思路：找到删除节点cur的右边节点中最小的值，替换到cur处，最后把替换到最后的一个节点给删除掉即可。  
![在这里插入图片描述][85abb97264c14f30906bbd24fb9022b2.png]  
![在这里插入图片描述][3b77c83a4969473d807b63717be1a870.png]

*  **代码实现**

/**
         * 删除值为val的节点
         * @param val
         */
        //自己练习写的
        public void remove(int val) {
        
            TreeNode cur = root;
            TreeNode parent = null; //用于记录cur的前一个节点
            while(cur != null) {
        
                if(cur.val == val) {
        
                    removeNode2(parent,cur);
                    return;
                }else if(cur.val > val) {
        
                    parent = cur;
                    cur = cur.left;
                }else {
        
                    parent = cur;
                    cur = cur.right;
                }
            }
        }
    
    	//自己练习写的
        private void removeNode2(TreeNode parent, TreeNode cur) {
        
            //第一种情况 cur是root
            if(cur.left == null) {
        
                if(cur == root) {
        
                    root = cur.right; //此时cur所在节点是要删除的节点
                    return;
                } else {
        
                    if(cur == parent.right) {
        
                        //第二种情况 cur不是root，cur是parent.right
                        parent.right = cur.right;
                    } else {
        
                        //第三种情况 cur不是root，cur是parent.left
                        parent.left = cur.right;
                    }
                }
            } else if(cur.right == null) {
        
                    if(cur == root) {
             //第一种情况 cur是root
                        root = cur.left; //此时cur所在节点是要删除的节点
                        return;
                    } else {
        
                        if(cur == parent.right) {
        
                            //第二种情况 cur不是root，cur是parent.right
                            parent.right = cur.left;
                        } else {
        
                            //第三种情况 cur不是root，cur是parent.left
                            parent.left = cur.left;
                        }
                    }
            } else {
             //cur左右都不为空节点  思路：找到cur右边节点最小的值与之进行交换就可以了
                TreeNode targetP = cur;
                TreeNode target = cur.right;
                while(target.left != null) {
        
                    targetP = target;
                    target = target.left;
                }
                //走到这说明target的左节点为空了
                //进行交换
                cur.val = target.val;
                if(target == targetP.left) {
        
                    targetP.left = target.right; //target.right为空也没事，给到targetP.left，说明targetP节点左侧为空了
                }
                if(target == targetP.right) {
        
                    targetP.right = target.right;  //这种情况是target没有左节点，相当于cur右边节点是个右单树
                }
            }
        }

##### 1.5 性能分析 #####

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

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

*  TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set；实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 + 颜色以及红黑树性质验证。

#### 2、搜索 ####

##### 2.1 概念及场景 #####

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

1.  直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
2.  二分查找，时间复杂度为 ,但搜索前必须要求序列是有序的  
    上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如：
3.  根据姓名查询考试成绩
4.  通讯录，即根据姓名查询联系方式
5.  不重复集合，即需要先搜索关键字是否已经在集合中可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本节介绍的Map和Set是一种适合动态查找的集合容器。

##### 2.2 模型 #####

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

1.  纯 key 模型，比如：  
    有一个英文词典，快速查找一个单词是否在词典中快速查找某个名字在不在通讯录中
2.  Key-Value 模型，比如：  
    统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>  
    梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号

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

![在这里插入图片描述][60fa661b3abe4e9bb3a39e531a9d82b6.png]

#### 3. 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的比较方式。

<table> 
 <thead> 
  <tr> 
   <th><strong>方法</strong></th> 
   <th><strong>解释</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>K getKey()</td> 
   <td>返回 entry 中的 key</td> 
  </tr> 
  <tr> 
   <td>V getValue()</td> 
   <td>返回 entry 中的 value</td> 
  </tr> 
  <tr> 
   <td>V setValue(V value)</td> 
   <td>将键值对中的value替换为指定value</td> 
  </tr> 
 </tbody> 
</table>

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

##### 3.3 Map 的常用方法说明 #####

![在这里插入图片描述][a8af46297e9241eb802a661453aa2f32.png]

> **注意：**
> 
>  *  **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的区别如下图所示：  
>     ![在这里插入图片描述][a202810f7cba465c838873acc93d8e23.png]

#### 4. Set的说明 ####

Set 的官方文档：[https://docs.oracle.com/javase/8/docs/api/java/util/Set.html][https_docs.oracle.com_javase_8_docs_api_java_util_Set.html]

##### 4.1 常见方法说明 #####

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

注意：

> 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的区别 如下图所示：

<table> 
 <thead> 
  <tr> 
   <th>Set底层结构</th> 
   <th>TreeSet</th> 
   <th>HashSet</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>底层结构</td> 
   <td>红黑树</td> 
   <td>哈希桶</td> 
  </tr> 
  <tr> 
   <td>插入/删除/查找时间复杂度</td> 
   <td>0(Log N)</td> 
   <td>O(1)</td> 
  </tr> 
  <tr> 
   <td>是否有序</td> 
   <td>关于Key有序</td> 
   <td>不一定有序</td> 
  </tr> 
  <tr> 
   <td>线程安全</td> 
   <td>不安全</td> 
   <td>不安全</td> 
  </tr> 
  <tr> 
   <td>插入/删除/查找区别</td> 
   <td>按照红黑树的特性来进行插入和删除</td> 
   <td>1. 先计算key哈希地址 2. 然后进行插入和删除</td> 
  </tr> 
  <tr> 
   <td>比较与覆写</td> 
   <td>key必须能够比较，否则会抛出ClassCastException异常</td> 
   <td>自定义类型需要覆写equals和hashCode方法</td> 
  </tr> 
  <tr> 
   <td>应用场景</td> 
   <td>需要Key有序场景下</td> 
   <td>Key是否有序不关心，需要更高的时间性能</td> 
  </tr> 
 </tbody> 
</table>

**解决下面的三个问题:**

1.  统计10W个数据当中，不重复的数据？(去重)
2.  统计10W个数据当中，第一个重复的数据？
3.  统计10W个数据当中，每个数据出现的次数？(对应的关系)

*  **解题思路：** 利用set可以达到去重的效果，出现的次数可以用到K - V 模型，即是map
 *  **代码实现**

import java.util.*;
    
    public class Test {
        
        //1、统计10W个数据当中，不重复的数据？[去重]
        public static void func1(int[] array) {
        
            Set<Integer> set = new HashSet<>();
            for (int i = 0; i < array.length; i++) {
        
                set.add(array[i]);
            }
            System.out.println(set);
        }
        //2、统计10W个数据当中，第一个重复的数据？
        public static void func2(int[] array) {
        
            Set<Integer> set = new HashSet<>();
            for (int i = 0; i < array.length; i++) {
        
                if(!set.contains(array[i])) {
        
                    set.add(array[i]);
                }else {
        
                    System.out.println(array[i]);
                    break;
                }
            }
        }
        //3、统计10W个数据当中，每个数据出现的次数？ 对应的关系
        public static void func3(int[] array) {
        
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < array.length; i++) {
        
                int key = array[i];
                if(map.get(key) == null) {
        
                    map.put(key, 1);
                }else {
        
                    int val = map.get(key);
                    map.put(key, val+1);
                }
            }
            //利用foreach语句 来遍历Map.Entry<K, V>导出的K-V 对应的关系来获取次数
            for (Map.Entry<Integer, Integer> entry:map.entrySet()) {
        
                System.out.println("key: "+ entry.getKey()+"出现了: "+entry.getValue()+" 次");
            }
        }
    
        public static void main(String[] args) {
        
            int[] array = new int[10_0000];
            Random random = new Random();
            for (int i = 0; i < array.length; i++) {
        
                array[i] = random.nextInt(5_0000);
            }
            func1(array);
            func2(array);
            func3(array);
        }
    }

> 🎗️🎗️🎗️ 好啦，到这里我们的 Set 和 Map 的分享就没了，如果感觉做的还不错的可以点个赞，关注一下，你的支持就是我继续下去的动力，蟹蟹大家了，我们下期再见，拜拜~ ☆\*: .｡. o(≧▽≦)o .｡.:\*☆

[0877fa9dd08f4be68cd8e197538bda70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/b8c5ad42e4834a22bae61fdee5692583.png
[eb77788d5b5747c29fa64d1eed5adefd.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/2218c38d299041f28d940b979e8c5e4d.jpeg
[d5663f89612f4094b86000758e74e95b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/c5998bd4310f4773b0307d29fa338c75.png
[061f6f2f7d6c42bab5a7c0ad3b8cfec0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/bd2cad0f3add4e0cb7d05442c999ee17.png
[a9bf819d1b8a4ffea9c268ed8c932d0c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/cf1c2c090184485c85103af46776d9d9.png
[32fa82f732e7458caeaed7b1d855bba2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/381ebf1ec05f44249dc1eddc8718ca75.png
[85abb97264c14f30906bbd24fb9022b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/aa94fbd6952245dc83f0745e0406b064.png
[3b77c83a4969473d807b63717be1a870.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/a6f79a59425c465e84a80e7c5a99d3b1.png
[60fa661b3abe4e9bb3a39e531a9d82b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/43971f477cf342d2aafe6de8dd221cd4.png
[a8af46297e9241eb802a661453aa2f32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/1ff492fa437f4728b7a8b87513fb3b47.png
[a202810f7cba465c838873acc93d8e23.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/073627f6d3444172aae211e270613afa.png
[https_docs.oracle.com_javase_8_docs_api_java_util_Set.html]: https://docs.oracle.com/javase/8/docs/api/java/util/Set.html