数据结构 - 7（Map和Set 15000字详解）

一： 二叉搜索树

1.1 二叉搜索树的概念

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

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

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

1.2在二叉搜索树进行操作

1.2.1查找

查找操作可以按照以下步骤进行：

1. 从根节点开始遍历。
2. 如果当前节点为空，表示找不到目标值，返回 null。
3. 如果当前节点的值等于目标值，表示找到了目标节点，返回该节点。
4. 如果目标值小于当前节点的值，说明目标值在当前节点的左子树中，继续在左子树中递归查找。
5. 如果目标值大于当前节点的值，说明目标值在当前节点的右子树中，继续在右子树中递归查找。

下面是查找操作图示：

1.2.2插入

插入操作可以按照以下步骤进行：

1. 从根节点开始，将要插入的值与当前节点的值进行比较。
2. 如果要插入的值小于当前节点的值，并且当前节点的左子节点为空，那么将新节点作为当前节点的左子节点。
3. 如果要插入的值大于当前节点的值，并且当前节点的右子节点为空，那么将新节点作为当前节点的右子节点。
4. 如果要插入的值小于当前节点的值，并且当前节点的左子节点不为空，那么将当前节点的左子节点作为新的当前节点，回到步骤1。
5. 如果要插入的值大于当前节点的值，并且当前节点的右子节点不为空，那么将当前节点的右子节点作为新的当前节点，回到步骤1。

这样，新节点就会以正确的位置被插入到二叉搜索树中。下面是插入操作图示：

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

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

1.2.3删除

二叉树的删除操作可以分为以下几个步骤：

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

1. cur.left == null

cur 是 root，则 root = cur.right

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

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

2. cur.right == null

cur 是 root，则 root = cur.left

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

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

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

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

1.2.4 查找插入和删除的代码实现

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) { // 如果找到结点的值等于 key
        return cur; // 返回当前结点
      } else if (key < cur.key) { // 如果 key 小于当前结点的值
        cur = cur.left; // 继续在左子树中查找
      } else { // 如果 key 大于当前结点的值
        cur = cur.right; // 继续在右子树中查找
      }
    }
    
    return null; // 搜索树中未找到 key，返回 null
  }
  
  // 插入操作，return 值为 true 表示插入成功, false 表示插入失败
  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) { // 如果 key 已经存在于树中
        return false; // 返回插入失败
      } else if (key < cur.key) { // 如果 key 小于当前结点的值
        parent = cur; // 更新父结点为当前结点
        cur = cur.left; // 继续在左子树中查找
      } else { // 如果 key 大于当前结点的值
        parent = cur; // 更新父结点为当前结点
        cur = cur.right; // 继续在右子树中查找
      }
    }
    
    Node node = new Node(key); // 新建结点
    
    if (key < parent.key) { // 如果 key 小于父结点的值
      parent.left = node; // 将新结点插入左子树
    } else { // 如果 key 大于父结点的值
      parent.right = node; // 将新结点插入右子树
    }
    
    return true; // 返回插入成功
  }
 

  
  // 获取以指定结点为根的子树的最小结点
private Node getMin(Node node) {
  while (node.left != null) {
    node = node.left;
  }
  return node;
}

// 删除操作，return 值为 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) { // 如果 key 小于当前结点的值
      parent = cur; // 更新父结点为当前结点
      cur = cur.left; // 继续在左子树中查找
    } else { // 如果 key 大于当前结点的值
      parent = cur; // 更新父结点为当前结点
      cur = cur.right; // 继续在右子树中查找
    }
  }
  
  if (null == cur) { // 当前元素不在搜索树中
    return false; // 返回删除失败
  }
  
  // 如果 cur 的左孩子不存在
  if (cur.left == null) {
    // 如果 cur 是根结点
    if (parent == null) {
      root = cur.right; // 将右孩子作为根结点
    } else if (cur == parent.left) { // 如果 cur 是父结点的左孩子
      parent.left = cur.right; // 将 cur 的右孩子赋给父结点的左孩子
    } else { // 如果 cur 是父结点的右孩子
      parent.right = cur.right; // 将 cur 的右孩子赋给父结点的右孩子
    }
  }
  // 如果 cur 的右孩子不存在
  else if (cur.right == null) {
    // 如果 cur 是根结点
    if (parent == null) {
      root = cur.left; // 将左孩子作为根结点
    } else if (cur == parent.left) { // 如果 cur 是父结点的左孩子
      parent.left = cur.left; // 将 cur 的左孩子赋给父结点的左孩子
    } else { // 如果 cur 是父结点的右孩子
      parent.right = cur.left; // 将 cur 的左孩子赋给父结点的右孩子
    }
  }
  // 如果 cur 的左右孩子都存在
  else {
    Node successor = getMin(cur.right); // 获取右子树中的最小结点
    int successorKey = successor.key; // 保存该结点的值
    remove(successor.key); // 递归删除该结点
    cur.key = successorKey; // 将后继结点的值替换到要删除的结点上
  }
  
  return true; // 返回删除成功
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

1.2.5性能分析

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

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

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

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

二：Map和Set的引入

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

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

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

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

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

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

2.1Key-value键值对

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

1. 纯 key 模型，比如：

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

3. Key-Value 模型，比如：

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

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

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

三：Map

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

3.1Map.Entry

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

下面是这些方法使用的示例代码：

import java.util.*;

public class MapEntryExample {
    public static void main(String[] args) {
        // 创建一个Map，并添加一些键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Orange", 3);

        // 使用entrySet()方法获取Map中所有的键值对
        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        // 遍历键值对并执行操作
        for (Map.Entry<String, Integer> entry : entries) {
            // 获取键
            String key = entry.getKey();
            // 获取值
            Integer value = entry.getValue();

            // 打印键值对
            System.out.println("Key: " + key + ", Value: " + value); // Key: Apple, Value: 1
                                                                   // Key: Banana, Value: 2
                                                                   // Key: Orange, Value: 3

            // 替换值为指定值
            entry.setValue(value * 10);
        }

        // 打印替换后的键值对
        System.out.println("After replacing values:");
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue()); // Key: Apple, Value: 10
                                                                                            // Key: Banana, Value: 20
                                                                                            // Key: Orange, Value: 30
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

3.2Map 的常用方法

下面是这些方法的使用示例：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Collection;

public class MapEntryExample {
    public static void main(String[] args) {
        // 创建一个Map对象
        Map<String, Integer> scores = new HashMap<>();

        // 添加元素到Map
        scores.put("Alice", 90);
        scores.put("Bob", 85);
        scores.put("Charlie", 95);

        // 获取指定key的value
        Integer aliceScore = scores.get("Alice");
        System.out.println("Alice的成绩是：" + aliceScore); // 输出：Alice的成绩是：90

        // 获取指定key的value，如果key不存在则返回默认值
        Integer davidScore = scores.getOrDefault("David", 0);
        System.out.println("David的成绩是：" + davidScore); // 输出：David的成绩是：0

        // 设置指定key的value
        scores.put("Bob", 88);
        System.out.println("Bob的新成绩是：" + scores.get("Bob")); // 输出：Bob的新成绩是：88

        // 删除指定key的映射关系
        scores.remove("Charlie");
        System.out.println("Charlie的成绩已删除，现在的Map大小是：" + scores.size()); // 输出：Charlie的成绩已删除，现在的Map大小是：2

        // 获取所有的key集合
        Set<String> keySet = scores.keySet();
        System.out.println("所有的学生姓名：" + keySet); // 输出：所有的学生姓名：[Alice, Bob]

        // 获取所有的value集合
        Collection<Integer> values = scores.values();
        System.out.println("所有的学生成绩：" + values); // 输出：所有的学生成绩：[90, 88]

        // 获取所有的key-value映射关系
        Set<Map.Entry<String, Integer>> entrySet = scores.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            String name = entry.getKey();
            Integer score = entry.getValue();
            System.out.println(name + " 的成绩是：" + score);
        }
        // 输出：
        // Alice 的成绩是：90
        // Bob 的成绩是：88

        // 判断是否包含指定的key
        boolean containsAlice = scores.containsKey("Alice");
        System.out.println("是否包含 Alice：" + containsAlice); // 输出：是否包含 Alice：true

        // 判断是否包含指定的value
        boolean contains85 = scores.containsValue(85);
        System.out.println("是否包含成绩 85：" + contains85); // 输出：是否包含成绩 85：false
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

注意：

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删除掉，然后再来进行重新插入。

TreeMap和HashMap的区别【HashMap在课件最后会讲到】

四：Set

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

4.1 Set的常用方法

Set的常见方法：

下面是这些方法的使用示例：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        // 创建一个HashSet对象
        Set<String> set = new HashSet<>();

        // 使用add方法添加元素到set中
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Grape");
        set.add("Apple"); // 重复元素，不会被添加成功

        // 打印set中的元素个数
        System.out.println("Set size: " + set.size()); // 输出: Set size: 4

        // 判断元素是否存在于set中
        System.out.println("Set contains Apple: " + set.contains("Apple")); // 输出: Set contains Apple: true

        // 使用iterator方法获取set的迭代器
        Iterator<String> iterator = set.iterator();

        // 使用while循环通过迭代器遍历set中的元素
        System.out.print("Set elements: ");
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.print(element + " "); // 输出: Set elements: Apple Banana Orange Grape
        }
        System.out.println();

        // 从set中移除特定的元素
        set.remove("Orange");

        // 打印移除元素之后的set
        System.out.println("Set after removal: " + set); // 输出: Set after removal: [Apple, Banana, Grape]

        // 检测set是否为空
        System.out.println("Set is empty: " + set.isEmpty()); // 输出: Set is empty: false

        // 将set中的元素转换为数组
        Object[] array = set.toArray();

        // 打印转换后的数组元素
        System.out.print("Array elements: ");
        for (Object element : array) {
            System.out.print(element + " "); // 输出: Array elements: Apple Banana Grape
        }
        System.out.println();

        // 创建另一个集合
        Set<String> anotherSet = new HashSet<>();
        anotherSet.add("Apple");
        anotherSet.add("Banana");

        // 检查集合anotherSet中的元素是否都在set中存在
        boolean containsAll = set.containsAll(anotherSet);
        System.out.println("Set contains all elements from anotherSet: " + containsAll); // 输出: Set contains all elements from anotherSet: true

        // 将另一个集合中的元素添加到set中
        boolean addedAll = set.addAll(anotherSet);
        System.out.println("Elements added from anotherSet: " + addedAll); // 输出: Elements added from anotherSet: false (因为已经存在了，所以没有添加成功)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

注意：

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

五：哈希表

5.1 哈希表的引入

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

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

当向该结构中：

1. 插入元素

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

3. 搜索元素

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

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

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

5.2 哈希冲突

在这个示图中 hash（4）和hash（7）便发生了哈希冲突

哈希冲突，也称为散列冲突，发生在哈希函数将不同的输入映射到相同的哈希值时。我们把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

哈希冲突对于哈希表的性能和效率有影响。哈希表是一种常用的数据结构，用于实现快速的插入、删除和查找操作。当哈希冲突发生时，会导致额外的时间开销，因为需要解决冲突。

哈希冲突是不可避免的，因为哈希函数的输出空间比输入空间更小。当输入的数量超过输出空间的大小时，必然会出现冲突。

5.3 冲突的避免

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

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

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

常见哈希函数

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)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

5. 折叠法–(了解)

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

6. 随机数法–(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法

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

5.4负载因子

负载因子是指哈希表中已存储元素数量与哈希表容量的比值。通常用来衡量哈希表的装填程度。

计算公式：负载因子 = 已存储元素数量 / 哈希表容量

例如，如果哈希表容量为 10，已存储元素数量为 5，则负载因子为 5/10 = 0.5。

负载因子的取值范围通常在 0 到 1 之间，可以表示哈希表的装填程度。当负载因子接近 1 时，说明哈希表已经非常拥挤，冲突的可能性会增加；反之，当负载因子接近 0 时，说明哈希表还有很多空闲槽位，哈希冲突的可能性较低。

负载因子的选择是一个权衡取舍的过程。过高的负载因子可能会导致哈希冲突增加，从而影响哈希表的性能和效率，而过低的负载因子则会浪费空间。

一般情况下，负载因子较小的哈希表会相对稀疏，但拥有较低的冲突率；负载因子较大的哈希表则会更加紧凑，但可能会增加冲突的概率。

当负载因子达到一个设定的阈值时，可以考虑对哈希表进行动态调整，即进行扩容操作。扩容可以通过增加哈希表的容量，并重新计算已存储元素的哈希值和位置来重新分配元素。这样可以减少冲突的概率，提高哈希表的性能。

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

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

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

5.5闭散列和开散列

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

5.5.1 闭散列

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

1. 线性探测

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

线性探测：从发生冲突的位置开始，依次向后探测，找到下一个空位置，插入新元素

2. 二次探测

二次探测（Quadratic Probing）是一种改进的开放寻址法。与一次探测不同，二次探测使用二次方函数来确定下一个探测位置。

如果哈希函数将关键字K映射到位置h(K)，而该位置已经被占用，那么它会计算下一个探测位置为（h(K) + i²）%m，或者h(K) - i²）%m，其中i = 1,2,3…，m为表的大小。

如果该位置也被占用，继续增加步长的平方进行探测，直到找到一个空槽。

5.5.2 线性探测和二次探测的优劣

一次探测和二次探测都有一定的优缺点。

一次探测容易产生聚集效应，即冲突项在哈希表中连续存储，可能导致查找时间增加。

而二次探测相对较好地解决了聚集效应的问题，但在填装因子较高时，容易产生探测次数的循环重复，称为二次探测算法的饱和现象。

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

5.5.3 开散列

开散列，也称为链地址法或开链法，是一种解决哈希冲突的方法。

它通过使用散列函数将关键码集合映射到散列地址上，若有多个关键码映射到同一地址上，则将它们存储在同一个桶中。

具体来说，开散列的过程如下：

1. 首先，使用散列函数将关键码计算成散列地址。
2. 如果有多个关键码映射到同一个散列地址上，就将它们存储在同一个桶中。
3. 每个桶都是一个链表，通过指针将该地址上的关键码链接起来。链表的头结点存储在哈希表中。

当需要使用散列表时，我们可以通过散列函数计算关键码的散列地址，并在对应的桶中搜索或插入关键码。

开散列的优点是：

• 简单且易于实现。
• 冲突处理灵活，不需要考虑哈希表的装填因子。

然而，开散列也存在一些缺点：

• 需要额外的存储空间用于存储链表指针，占用的内存空间相对较大。
• 搜索或插入关键码的平均时间复杂度可能较高，特别是当桶中的链表过长时。

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

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

5.6哈希表和 java 类集的关系

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

哈希表和 java 类集的关系如下：

1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set
2. java 中使用的是哈希桶方式解决冲突的
3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
4. java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals 方法。
5. 所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的。