Java·Map和Set

梦里梦外; 2024-04-28 07:06 3阅读 0赞

#### 文章目录 ####

*  🏯1. 搜索🏯
 *   *  1.1 概念及场景
     *  1.2 模型
 *  🏰2. Map 的使用🏰
 *   *  2.1 关于Map的说明
     *  2.2 关于Map.Entry的说明
     *  2.3 Map 的常用方法说明
     *  2.4 TreeMap的使用案例
     *  2.5HashMap源码分析
 *  ⛺️3. Set 的说明⛺️
 *   *  3.1 常见方法说明
 *  🏭4 面试题练习🏭
 *  🗼5. 搜索树🗼
 *   *  5.1 概念
     *  5.2 操作-查找
     *  5.3 操作-插入
     *  5.4 操作-删除（难点）
     *  5.5 实现
     *  5.6 性能分析
     *  5.7 和 java 类集的关系
 *  🗾6. 哈希表🗾
 *   *  6.1 概念
     *  6.2 冲突-概念
     *  6.3 冲突-避免
     *  6.4 冲突-避免-哈希函数设计
     *  6.5 冲突-避免-负载因子调节（重点掌握）
     *  6.6 冲突-解决
     *  6.7 冲突-解决-闭散列 (不推荐使用)
     *  6.8 冲突-解决-开散列/哈希桶（好--重点掌握）
     *  6.9 冲突严重时的解决办法
     *  6.10 实现
     *  6.11 性能分析
     *  6.12 和 java 类集的关系

**大家好，我是晓星航。今天为大家带来的是 Map和Set 相关的讲解！😀**

## 🏯1. 搜索🏯 ##

### 1.1 概念及场景 ###

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

1.  直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
2.  二分查找，时间复杂度为 ,但搜索前必须要求序列是有序的

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

1.  根据姓名查询考试成绩
2.  通讯录，即根据姓名查询联系方式
3.  不重复集合，即需要先搜索关键字是否已经在集合中

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

### 1.2 模型 ###

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

1.  **纯 key 模型**，比如：
2.  1.  有一个英文词典，快速查找一个单词是否在词典中
    2.  快速查找某个名字在不在通讯录中

是否有？！

1.  **Key-Value 模型**，比如：
2.  1.  统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
    2.  梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号

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

次数！

## 🏰2. Map 的使用🏰 ##

[Map 的官方文档][Map]

![202305092104615.png][] ![202305092104646.png][]

### 2.1 关于Map的说明 ###

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

### 2.2 关于Map.Entry的说明 ###

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

![202305092105715.png][]

**注意：Map.Entry并没有提供设置Key的方法**

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

![202305092105750.png][]

V get(Object key) 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
    //        System.out.println(treeMap);//按照字母顺序进行的排序
            Integer val = treeMap.get("abc");
    //        Integer val1 = treeMap.getOrDefault("hello2",100);
            System.out.println(val);
    //        System.out.println(val1);
    //        Set<String> keySet = treeMap.keySet();
    //        System.out.println(keySet);
            
        }

![202305092105428.png][]

V getOrDefault(Object key,V defaultValue) 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            Integer val1 = treeMap.getOrDefault("hello2",100);
            Integer val2 = treeMap.getOrDefault("qi",150);
            System.out.println(val1);
            System.out.println(val2);
        }

![202305092105513.png][]

V put(K key, V value) 方法演示：

![202305092106709.png][]

V remove(Object key) 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            System.out.println(treeMap);//按照字母顺序进行的排序
            treeMap.remove("hello");
            treeMap.remove("the");
            System.out.println(treeMap);//按照字母顺序进行的排序
        }

![202305092106843.png][]

SetkeySet() 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            Set<String> keySet = treeMap.keySet();
            for (String set: keySet) {
        
                System.out.println("key:" + set);
            }
        }

![202305092107721.png][]

Collection values() 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            Collection<Integer> values = treeMap.values();
            for (Integer ret: values) {
        
                System.out.println("value:" + ret);
            }
        }

![202305092107799.png][]

Set<Map.Entry<K,V>>entrySet() 方法演示:

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            Set<Map.Entry<String,Integer>> set = treeMap.entrySet();
            for (Map.Entry<String,Integer> entry:set) {
        
                System.out.println("key:" + entry.getKey() + " value: "+entry.getValue());
            }
        }

![202305092108058.png][]

boolean containsKey(Object key) 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            System.out.println(treeMap.containsKey("qi"));
            System.out.println(treeMap.containsKey("world"));
            System.out.println(treeMap.containsKey("abc"));
        }

![202305092109919.png][]

boolean containsValue(Object value) 方法演示：

public static void main(String[] args) {
        
            Map<String,Integer> treeMap = new TreeMap<>();
            treeMap.put("abc",4);
            treeMap.put("hello",3);
            treeMap.put("the",8);
            treeMap.put("qi",5);
            treeMap.put("uit",9);
            System.out.println(treeMap.containsValue(4));
            System.out.println(treeMap.containsValue(2));
            System.out.println(treeMap.containsValue(7));
        }

![202305092109446.png][]

注意：

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

![202305092109733.png][]

### 2.4 TreeMap的使用案例 ###

import java.util.TreeMap;
    import java.util.Map;
    public static void TestMap1(){
        
            Map<String, String> m = new TreeMap<>();
            // put(key, value):插入key-value的键值对
            // 如果key不存在，会将key-value的键值对插入到map中,返回null
            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)
            // 因为TreeMap是按照Key进行组织的，因此查找value时候就需要整体遍历
            // 找到返回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();
            }

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

### 2.5HashMap源码分析 ###

![202305122031097.png][] ![202305122032032.png][] ![202305122032820.png][] ![202305122040502.png][]

## ⛺️3. Set 的说明⛺️ ##

[Set 的官方文档][Set]

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

### 3.1 常见方法说明 ###

![202305092110995.png][]

boolean add(E e) 方法演示：

![202305092111909.png][]

void clear() 方法演示：

public static void main(String[] args) {
        
        Set<String> set1 = new TreeSet<>();
        set1.add("abc");
        set1.add("hello");
        set1.add("qi");
        set1.add("xxh");
        set1.add("xxh");//重复的元素虽然不会报错 但是不会添加成功
        set1.add("the");
        System.out.println(set1);
        System.out.println("===================");
        set1.clear();
        System.out.println(set1);
    }

![202305092111763.png][]

boolean contains(Object o) 方法演示：

public static void main(String[] args) {
        
            Set<String> set1 = new TreeSet<>();
            set1.add("abc");
            set1.add("hello");
            set1.add("qi");
            set1.add("xxh");
            set1.add("xxh");//重复的元素虽然不会报错 但是不会添加成功
            set1.add("the");
            System.out.println(set1.contains("qi"));
            System.out.println(set1.contains("qiq"));
        }

![202305092111333.png][]

boolean remove(Object o) 方法演示：

public static void main(String[] args) {
        
            Set<String> set1 = new TreeSet<>();
            set1.add("abc");
            set1.add("hello");
            set1.add("qi");
            set1.add("xxh");
            set1.add("xxh");//重复的元素虽然不会报错 但是不会添加成功
            set1.add("the");
            System.out.println(set1);
            set1.remove("hello");
            System.out.println(set1);
        }

![202305092112694.png][]

int size() 方法演示：

public static void main(String[] args) {
        
            Set<String> set1 = new TreeSet<>();
            set1.add("abc");
            set1.add("hello");
            set1.add("qi");
            set1.add("xxh");
            set1.add("xxh");//重复的元素虽然不会报错 但是不会添加成功
            set1.add("the");
            int size = set1.size();
            System.out.println(size);
        }

![202305092112350.png][]

boolean isEmpty() 方法演示：

public static void main(String[] args) {
        
            Set<String> set1 = new TreeSet<>();
            set1.add("abc");
            set1.add("hello");
            set1.add("qi");
            set1.add("xxh");
            set1.add("xxh");//重复的元素虽然不会报错 但是不会添加成功
            set1.add("the");
            System.out.println(set1.isEmpty());
        }

![202305092112327.png][]

Object\[\] toArray() 方法演示：

public static void main(String[] args) {
        
            Set<String> set1 = new TreeSet<>();
            set1.add("abc");
            set1.add("hello");
            set1.add("qi");
            set1.add("xxh");
            set1.add("xxh");//重复的元素虽然不会报错 但是不会添加成功
            set1.add("the");
            Object[] ret = set1.toArray();
            for(Object a: ret){
        
                String b = a.toString();
                System.out.println(b.getClass().getName()+ "数据为" + b);
        }

![202305092113558.png][]

注意：

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。
8.  TreeSet和HashSet的区别

![202305092113378.png][]

**3.2 TreeSet的使用案例**

import java.util.TreeSet;
    import java.util.Iterator;
    import java.util.Set;
    public static void TestSet(){
        
            Set<String> s = new TreeSet<>();
            // add(key): 如果key不存在，则插入，返回ture
            // 如果key存在，返回false
            boolean isIn = s.add("apple");
            s.add("orange");
            s.add("peach");
            s.add("banana");
            System.out.println(s.size());
            System.out.println(s);
            isIn = s.add("apple");
            // add(key): key如果是空，抛出空指针异常
            //s.add(null);
            // 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);
            // 抛出空指针异常
            // s.remove(null);
            Iterator<String> it = s.iterator();
            while(it.hasNext()){
        
            System.out.print(it.next() + " ");
            }
            System.out.println();
        }

将TreeSet换为HashSet，试试TreeSet和HashSet的不同。

## 🏭4 面试题练习🏭 ##

1.  [只出现一次的数字][Link 1]

![202305092122739.png][]

class Solution {
        
        public int singleNumber(int[] nums) {
        
            Set<Integer> set = new HashSet<>();
            for (int num : nums) {
        
                if (!set.contains(num)) {
        
                    set.add(num);
                } else {
        
                    set.remove(num);
                }
            }
    /*        for (int i = 0; i < nums.length; i++) {
                if (!set.contains(nums[i])) {
                    set.add(nums[i]);
                } else {
                    set.remove(nums[i]);
                }
            }*/
            for (int num : nums) {
        
                if (set.contains(num)) {
        
                    return num;
                }
            }
            /*for (int i = 0; i < nums.length; i++) {
                if (set.contains(nums[i])) {
                    return nums[i];
                }
            }*/
            return -1;
        }
    }

思路：我们对数组进行两次遍历，第一遍我们用来过滤删除出现两次的数字，第二遍我们用来找我们set数组中仅存的那一个不重复的元素。

![202305092123319.png][]

1.  [复制带随机指针的链表][Link 2]

![202305122037376.png][] ![202305122037656.png][] ![202305122037983.png][] ![202305122037825.png][] ![202305122038269.png][]

思路：先用cur遍历我们的单链表一次，将地址和值先对应拿过来。再让cur遍历第二次单链表通过map.get(cur.next)来拿到我们next的值，通过map.get(cur.random)来拿到random的值。

/*
    // Definition for a Node.
    class Node {
        int val;
        Node next;
        Node random;
    
        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }
    */
    
    class Solution {
        
        public Node copyRandomList(Node head) {
        
            Map<Node,Node> map = new HashMap<>();
            Node cur = head;
            while (cur != null) {
        
                Node node = new Node(cur.val);
                map.put(cur,node);
                cur = cur.next;
            }
            cur = head;
            while (cur != null) {
        
                 map.get(cur).next = map.get(cur.next);
                 map.get(cur).random = map.get(cur.random);
                 cur = cur.next;
            }
            return map.get(head);
        }
    }

![202305122038951.png][]

1.  [宝石与石头][Link 3]

![202305122038502.png][]

思路：我们直接用Set来遍历两次我们所需要的东西，第一遍遍历宝石，第二遍遍历石头，并在石头中找我们所需要的宝石，找到我们的计数器count就加加，最后返回count。

class Solution {
        
        public int numJewelsInStones(String jewels, String stones) {
        
            int count = 0;
            Set<Character> set = new HashSet<>();
            //1.遍历jewels
            for(int i = 0;i < jewels.length();i++) {
        
                char ch = jewels.charAt(i);
                set.add(ch);
            }
            //2.遍历stones
            for(int i = 0;i < stones.length();i++) {
        
                char ch = stones.charAt(i);
                if (set.contains(ch)) {
        
                    count++;
                }
            }
            return count;
        }
    }

![202305122038350.png][]

1.  [坏键盘打字][Link 4]

![202305122039273.png][] ![202305122039759.png][]

思路：通过Set来添加这两个字符串，并在添加过程中直接将小写字符转化为大写字符并转化为字符数组到Set中，然后通过foreach来遍历我们的第一个字符串输出不包含的字符(坏掉键盘中无法输出的字符)，可通过加入SetBroken来过滤掉已经打印过的漏掉的字符。

import java.util.Scanner;
    import java.util.Set;
    import java.util.HashSet;
    // 注意类名必须为 Main, 不要有任何 package xxx 信息
    public class Main {
        
        public static void func(String str1, String str2) {
        
            Set<Character> set = new HashSet<>();
            for (char ch : str2.toUpperCase().toCharArray()) {
        
                set.add(ch);
            }
            Set<Character> setBroken = new HashSet<>();
            for (char ch : str1.toUpperCase().toCharArray()) {
        
                if (!set.contains(ch) && !setBroken.contains(ch)) {
        
                    setBroken.add(ch);
                    System.out.print(ch);
                }
            }
        }
        public static void main(String[] args) {
        
            Scanner scan = new Scanner(System.in);
            // 注意 hasNext 和 hasNextLine 的区别
            while (scan.hasNextLine()) {
         // 注意 while 处理多个 case
                String str1 = scan.nextLine();
                String str2 = scan.nextLine();
                func(str1, str2);
            }
        }
    }

![202305122039920.png][]

1.  [前K个高频单词][K]

![202305122039360.png][]

class Solution {
        
        public static List<String> topKFrequent(String[] words, int k) {
        
            //1、遍历数组 统计每个单词出现的频率
            Map<String,Integer> hashMap = new HashMap<>();
            for (String s : words) {
        
                if (hashMap.get(s) == null) {
        
                    hashMap.put(s,1);
                } else {
        
                    hashMap.put(s,hashMap.get(s) + 1);
                }
            }
    
            //2、建立小根堆
            PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(
                    k, new Comparator<Map.Entry<String, Integer>>() {
        
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
        
                    if (o1.getValue().compareTo(o2.getValue()) == 0) {
        
                        return o2.getKey().compareTo(o1.getKey());
                    }
                    return o1.getValue().compareTo(o2.getValue());
                }
            }
            );
            //3、遍历hashMap 把里面 的数据 放到小根堆
            for (Map.Entry<String,Integer> entry:hashMap.entrySet()) {
        
                if (minHeap.size() < k) {
        
                    minHeap.offer(entry);
                } else {
        
                    //小根堆放满了K个，下一个entry和堆顶元素比较
                    Map.Entry<String,Integer> top = minHeap.peek();
                    //堆顶的频率小于当前entry的频率 就出队 然后入队entry
                    if (top.getValue() < entry.getValue()) {
        
                        minHeap.poll();
                        minHeap.add(entry);
                    } else {
        
                        //频率相同的情况
                        if (top.getValue().compareTo(entry.getValue()) == 0) {
        
                            if (top.getKey().compareTo(entry.getKey()) > 0) {
        
                                minHeap.poll();
                                minHeap.add(entry);
                            }
                        }
                    }
                }
            }
            //4、此时小根堆当中已经有了结果
            //System.out.println(minHeap);
            List<String> ret = new ArrayList<>();
            for (int i = 0; i < k; i++) {
        
                String key = minHeap.poll().getKey();
                ret.add(key);
            }
            Collections.reverse(ret);
            //System.out.println("ret: "+ret);
            return ret;
        }
    }

![202305122039557.png][] ![202305122041114.png][]

## 🗼5. 搜索树🗼 ##

### 5.1 概念 ###

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

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

![202305092114975.png][]

### 5.2 操作-查找 ###

![202305092115799.png][]

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

### 5.3 操作-插入 ###

1.  如果树为空树，即根 == null，直接插入

![202305092115685.png][]

1.  如果树不是空树，按照查找逻辑确定插入位置，插入新结点

![202305092115105.png][]

/**
     * 插入一个数据
     * @param val
     */
    public void insert(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;
            } else if (cur.val == val) {
        
                return;
            } else {
        
                parent = cur;
                cur = cur.left;
            }
        }
        TreeNode node = new TreeNode(val);
        if (parent.val > val) {
        
            parent.left = node;
        } else {
        
            parent.right = node;
        }
    }

### 5.4 操作-删除（难点） ###

**设待删除结点为 cur, 待删除结点的双亲结点为 parent**

1.  cur.left == null
2.  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

![202305092116349.png][]

1.  cur.right == null
2.  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

![202305092116903.png][]

1.  cur.left != null && cur.right != null
2.  1.  需要使用**替换法**进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题

### 5.5 实现 ###

public class BinarySearchTree {
        
        static class TreeNode {
        
            public int val;
            public TreeNode left;
            public TreeNode right;
            public TreeNode(int val) {
        
                this.val = val;
            }
        }
        TreeNode root = null;
        /**
         * 查找二叉搜索树指定的val值
         * @param val
         * @return
         */
        public TreeNode find(int val) {
        
            TreeNode cur = root;
            while (cur != null) {
        
                if (cur.val == val) {
        
                    return cur;
                } else if (cur.val > val) {
        
                    cur = cur.left;
                } else {
        
                    cur = cur.right;
                }
            }
            return null;
        }
    
        /**
         * 插入一个数据
         * @param val
         */
        public void insert(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;
                } else if (cur.val == val) {
        
                    return;
                } else {
        
                    parent = cur;
                    cur = cur.left;
                }
            }
            TreeNode node = new TreeNode(val);
            if (parent.val > val) {
        
                parent.left = node;
            } else {
        
                parent.right = node;
            }
        }
        public void inorder(TreeNode root) {
        
            if (root == null) {
        
                return;
            }
            inorder(root.left);
            System.out.print(root.val + " ");
            inorder(root.right);
        }
    
        /**
         * 删除值为val的节点
         * @param val
         */
        public void remove(int val) {
        
            TreeNode cur = root;
            TreeNode parent = null;
            while (cur != null) {
        
                if (cur.val == val) {
        
                    removeNode(parent,cur);
                } else if (cur.val < val) {
        
                    parent = cur;
                    cur = cur.right;
                } else {
        
                    parent = cur;
                    cur = cur.left;
                }
            }
    
        }
    
        private void removeNode(TreeNode parent, TreeNode cur) {
        
            if (cur.left == null) {
        
                if (cur == root) {
        
                    root = cur.right;
                } else if (parent.left == cur) {
        
                    parent.left = cur.right;
                } else {
        
                    parent.right = cur.right;
                }
            } else if (cur.right == null) {
        
                if (cur == root) {
        
                    root = cur.left;
                } else if (parent.left == cur) {
        
                    parent.left = cur.left;
                } else {
        
                    parent.right = cur.left;
                }
            } else {
        
                TreeNode target = cur.right;
                TreeNode targetParent = cur;
                while (target.left != null) {
        
                    targetParent = target;
                    target = target.left;
                }
                cur.val = target.val;
                if (target == targetParent.left) {
        
                    targetParent.left = target.right;
                } else {
        
                    targetParent.right = target.right;
                }
            }
        }
    
    }

### 5.6 性能分析 ###

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

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

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

![202305092117881.png][] ![202305092117843.png][]

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2 N

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

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，都可以是二叉搜索树的性能最佳？

### 5.7 和 java 类集的关系 ###

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

![202305122041002.png][]

## 🗾6. 哈希表🗾 ##

### 6.1 概念 ###

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

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

当向该结构中：

*  **插入元素**

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

*  **搜索元素**

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

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

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

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

![202305092117865.png][]

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快 问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

### 6.2 冲突-概念 ###

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

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

### 6.3 冲突-避免 ###

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

### 6.4 冲突-避免-哈希函数设计 ###

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

*  哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
 *  哈希函数计算出来的地址能均匀分布在整个空间中
 *  哈希函数应该比较简单

**常见哈希函数**

1.  **直接定制法**–(常用)

**取关键字的某个线性函数为散列地址：Hash（Key）= A\*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况** 面试题：[字符串中第一个只出现一次字符][Link 5]

![202305092117104.png][]

class Solution {
        
        public int firstUniqChar(String s) {
        
            int[] array = new int[26];
            for (int i = 0; i < s.length(); i++) {
        
                array[s.charAt(i) - 'a']++;
            }
    
            for (int i = 0; i < s.length(); i++) {
        
                if(array[s.charAt(i) - 'a'] == 1) {
        
                    return i;
                }
            }
            return -1;
        }
    }

![202305092118371.png][]

1.  **除留余数法**–(常用)

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

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

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。

**折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况**

1.  **随机数法**–(了解)

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

**通常应用于关键字长度不等时采用此法**

1.  **数学分析法**–(了解)

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：

![202305092118495.png][]

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。

**数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况**

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

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

![202305092118972.png][]

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

![202305092118179.png][]

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

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

### 6.6 冲突-解决 ###

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

### 6.7 冲突-解决-闭散列 (不推荐使用) ###

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

1.  **线性探测**

比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

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

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

![202305092119498.png][]

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

1.  **二次探测**

**线性探测的缺陷是产生冲突的数据堆积在一块**，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：H i = (H 0 +i^2 )% m, 或者：

H i= (H 0 - i^2 )% m。其中：i = 1,2,3…， 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小(10)。 对于2.1中如果要插入44，产生冲突，使用解决后的情况为：

![202305092119164.png][]

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

因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

### 6.8 冲突-解决-开散列/哈希桶（好–重点掌握） ###

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

![202305092119912.png][]

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

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

### 6.9 冲突严重时的解决办法 ###

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

1.  每个桶的背后是另一个哈希表
2.  每个桶的背后是一棵搜索树

### 6.10 实现 ###

// key-value 模型
    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 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;
        }
        private double loadFactor() {
        
            return size * 1.0 / array.length;
        }
        public HashBucket() {
        
            array = new Node[8];
            size = 0;
        }
        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;
        }
    }

### 6.11 性能分析 ###

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

### 6.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 一定是一致的。

![202305122042579.png][]

*感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘*

[Map]: https://docs.oracle.com/javase/8/docs/api/java/util/Map.html
[202305092104615.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305092104615.png
[202305092104646.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/4947ed29931d41279638686b67e5d8fd.png
[202305092105715.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/bb8900255d644826b4fe096c00a3d82f.png
[202305092105750.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/c3fe4888935246db82c4b518f43a81a3.png
[202305092105428.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f3256477fde145d5a72dcc13b9b36bb1.png
[202305092105513.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f30e40c3eb224751a039dff176ac6cbe.png
[202305092106709.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/4ca1afb7e41e4501907c0164e890e016.png
[202305092106843.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2a800960cf6346358396655e03ec9658.png
[202305092107721.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/30b078c97c2e46ab8162d4b3d34b0568.png
[202305092107799.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/18c5cd852c544dab88e2a83685a88a7a.png
[202305092108058.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/847c4fcc3dc54a9695899bc4d8a0331d.png
[202305092109919.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/3022b49589e9478ba085ca6108ddafa0.png
[202305092109446.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/3fd60712c9d246a2bd8b70b0f15b3591.png
[202305092109733.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/a87b754a72e44c7c98b582c0f3118fd6.png
[202305122031097.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122031097.png
[202305122032032.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122032032.png
[202305122032820.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122032820.png
[202305122040502.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/1b6ed5288a8a4b7f9c7fb120984d408d.png
[Set]: https://docs.oracle.com/javase/8/docs/api/java/util/Set.html
[202305092110995.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/31b80d9bf6e6422abc29f8bfc7be56a0.png
[202305092111909.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f5f39bc206cb4dd687fd6236a486431e.png
[202305092111763.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/fda335ec17844d2892dc14c51b0bb8a7.png
[202305092111333.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/0822198a38c34c4da728546f15e612c1.png
[202305092112694.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/d9c5ba4f51a54ccc8b967c71682b7d79.png
[202305092112350.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/c4b22ee191ca4068a2e4c640981ffe3b.png
[202305092112327.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/8297c387b27c4cadae86b465358f5c01.png
[202305092113558.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f3d593d109cb47e0bb8a421694a001b0.png
[202305092113378.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/5adc8e0faaf744678d20a53bba57d0b8.png
[Link 1]: https://leetcode.cn/problems/single-number/
[202305092122739.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/0aeefe412c014abfbd0af5a018ddddba.png
[202305092123319.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/7ef54e4e37924713b2e75e739490f707.png
[Link 2]: https://leetcode.cn/problems/copy-list-with-random-pointer/
[202305122037376.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122037376.png
[202305122037656.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122037656.png
[202305122037983.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122037983.png
[202305122037825.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122037825.png
[202305122038269.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/6f6d606db7ef43e0a0a3817ebc9046f6.png
[202305122038951.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/afec1a2ba76f46a0b74edaed1ee013f5.png
[Link 3]: https://leetcode.cn/problems/jewels-and-stones/
[202305122038502.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/50d60ca1464e48eb838ba7608abf34e2.png
[202305122038350.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/6241f5997f4b482aa77f08cd93a67d47.png
[Link 4]: https://www.nowcoder.com/questionTerminal/f88dafac00c8431fa363cd85a37c2d5e
[202305122039273.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122039273.png
[202305122039759.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/90a8c6ca357a414485a3505f0ab9e213.png
[202305122039920.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/372a41af6ebe485c8f23b6649ebbe618.png
[K]: https://leetcode.cn/problems/top-k-frequent-words/description/
[202305122039360.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/36ea7457babc499d83d123df4c1953a7.png
[202305122039557.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305122039557.png
[202305122041114.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/64825124dfc94c7ab15eb9b96f4b5cfd.png
[202305092114975.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/c5e5197a612d44f39e281fc63b3c43b9.png
[202305092115799.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/13081a72588846b796822050f2c3f62d.png
[202305092115685.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2974cf93d83145d0a0cf447ae8b891a4.png
[202305092115105.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/57f6c1a2853f454b8da15ac66424cb38.png
[202305092116349.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/94550f7c79b14be79722cca6e974148d.png
[202305092116903.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/d67be3be647d40f5bc3b785fb55b8cb2.png
[202305092117881.png]: https://7078909xxh.oss-cn-shanghai.aliyuncs.com/csdn图床专用区/202305092117881.png
[202305092117843.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/9a50613f89da4558ad9288ae5b9ea4db.png
[202305122041002.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/0dfce207ac3245c2a3044a6fbe695dfa.png
[202305092117865.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/239931f5742c457e8cdbbd232d768f2c.png
[Link 5]: https://leetcode.cn/problems/first-unique-character-in-a-string/
[202305092117104.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/cc117feba2074b62b6479f08c6712ea4.png
[202305092118371.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/0c6b53ab2eec4770be3590d474658ca8.png
[202305092118495.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f55dbf938648453a9c5b85f23ae26b1c.png
[202305092118972.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/34a4a951ac9a479dabffcdb32901d0a2.png
[202305092118179.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/e24051db37964b4781379dbdc94607ca.png
[202305092119498.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/bf0e018c70ab47cdac5d3617625d223c.png
[202305092119164.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/e6746e996b3f4bd093cca1a5559ac75a.png
[202305092119912.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/e4b7dfdc4315499aa68508086b8e7cf5.png
[202305122042579.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/c25ab9004c5e4aafb9b5d8084d6ef21c.png