查找算法

二分查找

二分查找（Binary Search）是一种高效的查找算法，也叫折半查找。核心思想：对于一个有序的数据集合，每次查找都将查找范围缩小为原来的一半，直到找到目标值或确定目标值不存在。二分查找要求数据必须是有序的，经常应用于数组等支持随机访问的数据结构里。跟线性查找相比，二分查找的效率要高得多，特别是对于大规模数据集。
算法步骤

• 确定查找范围的左边界 left 和右边界 right
  
• 计算中间位置 mid = (left + right) / 2（注意整数溢出问题，更安全的做法是 mid = left + (right - left) / 2）
  
• 将中间位置的元素与目标值比较
  
  
  
  • 如果中间元素等于目标值，查找成功，返回中间元素的位置
    
  • 如果中间元素大于目标值，目标值可能在左半部分，将右边界调整为 mid - 1
    
  • 如果中间元素小于目标值，目标值可能在右半部分，将左边界调整为 mid + 1
    
  
  
• 重复步骤2-3，直到找到目标值或者左边界大于右边界（此时表示目标值不存在）
  

核心特性：

• 要求有序：二分查找只适用于有序数据集合
  
• 时间复杂度：O(log n)，在大规模数据集上非常高效
  
• 空间复杂度：迭代实现为O(1)，递归实现为O(log n)（因为递归调用栈的深度）
  
• 随机访问：要求数据结构支持O(1)时间复杂度的随机访问（比如数组）
  

基础实现

下面是二分查找算法在各种主流编程语言中的实现：

1. public class BinarySearch {
2.     // 迭代实现
3.     public static int binarySearch(int[] arr, int target) {
4.         int left = 0;
5.         int right = arr.length - 1;
6.         
7.         while (left <= right) {
8.             // 避免整数溢出
9.             int mid = left + (right - left) / 2;
10.             
11.             // 找到目标值
12.             if (arr[mid] == target) {
13.                 return mid;
14.             }
15.             // 在左半部分继续查找
16.             else if (arr[mid] > target) {
17.                 right = mid - 1;
18.             }
19.             // 在右半部分继续查找
20.             else {
21.                 left = mid + 1;
22.             }
23.         }
24.         
25.         // 未找到目标值
26.         return -1;
27.     }
28.    
29.     // 递归实现
30.     public static int binarySearchRecursive(int[] arr, int target, int left, int right) {
31.         if (left > right) {
32.             return -1;
33.         }
34.         
35.         int mid = left + (right - left) / 2;
36.         
37.         if (arr[mid] == target) {
38.             return mid;
39.         } else if (arr[mid] > target) {
40.             return binarySearchRecursive(arr, target, left, mid - 1);
41.         } else {
42.             return binarySearchRecursive(arr, target, mid + 1, right);
43.         }
44.     }
45.    
46.     // 测试
47.     public static void main(String[] args) {
48.         int[] arr = {2, 3, 4, 10, 40, 50, 70, 80};
49.         int target = 10;
50.         
51.         // 迭代方法
52.         int result = binarySearch(arr, target);
53.         if (result == -1) {
54.             System.out.println("元素 " + target + " 不存在于数组中");
55.         } else {
56.             System.out.println("元素 " + target + " 在数组中的索引为 " + result);
57.         }
58.         
59.         // 递归方法
60.         result = binarySearchRecursive(arr, target, 0, arr.length - 1);
61.         if (result == -1) {
62.             System.out.println("元素 " + target + " 不存在于数组中");
63.         } else {
64.             System.out.println("元素 " + target + " 在数组中的索引为 " + result);
65.         }
66.     }
67. }

复制代码

优点

• 查找效率非常高，时间复杂度为 O(log n)
  
• 在大规模数据集上表现优异
  
• 实现相对简单
  
• 不需要额外的空间（迭代实现）
  

缺点

• 要求数据必须是有序的
  
• 只适用于支持随机访问的数据结构（如数组）
  
• 对于频繁插入和删除的数据结构，维护有序性的成本很高
  
• 不适合小数据量的查找（这种情况下线性查找可能更快）
  

应用场景

二分查找在很多场景中都有广泛的应用：

• 数据库索引的实现（如 B 树和 B+ 树的查找过程）
  
• 查找最接近某个值的元素（下界查找和上界查找）
  
• 计算平方根等数值计算中（二分法求解）
  
• 猜数字游戏（每次猜测中间值）
  
• 在旋转排序数组中查找元素
  
• 查找数组中第一个或最后一个满足某条件的元素
  

相关的 LeetCode 热门题目

• 704. 二分查找 - 二分查找的基础应用
  
• 35. 搜索插入位置 - 查找元素应该插入的位置（下界）
  
• 34. 在排序数组中查找元素的第一个和最后一个位置 - 查找目标值的第一次和最后一次出现位置
  
• 69. x 的平方根 - 使用二分查找求解平方根
  
• 33. 搜索旋转排序数组 - 在旋转过的有序数组中用二分查找
  
• 153. 寻找旋转排序数组中的最小值 - 在旋转数组中查找最小值
  
• 74. 搜索二维矩阵
  

哈希查找

哈希查找（Hash Search），又称散列查找，是一种高效的查找算法，它用哈希函数将数据转换为数组下标，然后直接访问数组中的元素。哈希查找的核心思想是将数据元素通过哈希函数映射到哈希表中的位置，实现快速查找。
在理想情况下，哈希查找的时间复杂度为 O(1)，这就意味着无论数据规模多大，查找操作都能在常数时间内完成，这是哈希查找相比其他查找算法（如二分查找、线性查找）的最大优势。
不过使用哈希查找必须要考虑哈希冲突（不同的数据被映射到相同的位置）问题。
算法步骤

• 设计一个适合数据特点的哈希函数，将数据映射到哈希表的索引位置
  
• 构建哈希表，将所有元素通过哈希函数映射、存储到相应位置
  
• 解决可能出现的哈希冲突（通常采用链地址法或开放寻址法）
  
• 查找时，通过同样的哈希函数计算目标数据的哈希值
  
• 根据哈希值定位到哈希表中的位置
  
• 如果存在冲突，则按照解决冲突的方法查找目标元素
  

核心特性：

• 快速访问：理想情况下查找时间复杂度为 O(1)
  
• 哈希函数：哈希查找的核心，将数据映射到数组索引的函数
  
• 哈希冲突：不同数据映射到相同位置的情况，需要特殊处理
  
• 空间换时间：通过额外的内存空间换取查找时间的提升
  
• 负载因子：表示哈希表的填充程度，影响查找效率和冲突概率
  
• 动态扩容：负载因子过高时，需要扩大哈希表并重新哈希所有元素
  

基础实现

1. public class HashSearch {
2.     // 哈希表节点类
3.     static class Node {
4.         String key;
5.         int value;
6.         Node next;
7.         
8.         public Node(String key, int value) {
9.             this.key = key;
10.             this.value = value;
11.             this.next = null;
12.         }
13.     }
14.    
15.     // 哈希表类
16.     static class HashTable {
17.         private Node[] buckets;
18.         private int capacity;
19.         private int size;
20.         private final float LOAD_FACTOR = 0.75f; // 负载因子阈值
21.         
22.         public HashTable(int capacity) {
23.             this.capacity = capacity;
24.             this.buckets = new Node[capacity];
25.             this.size = 0;
26.         }
27.         
28.         // 哈希函数
29.         private int hash(String key) {
30.             int hash = 0;
31.             for (char c : key.toCharArray()) {
32.                 hash = (hash * 31 + c) % capacity;
33.             }
34.             return Math.abs(hash);
35.         }
36.         
37.         // 插入键值对
38.         public void put(String key, int value) {
39.             if ((float)size / capacity >= LOAD_FACTOR) {
40.                 resize(2 * capacity);
41.             }
42.             
43.             int index = hash(key);
44.             Node newNode = new Node(key, value);
45.             
46.             // 如果桶为空，直接插入
47.             if (buckets[index] == null) {
48.                 buckets[index] = newNode;
49.                 size++;
50.                 return;
51.             }
52.             
53.             // 处理哈希冲突，使用链地址法
54.             Node current = buckets[index];
55.             
56.             // 检查是否已存在相同的键
57.             while (current != null) {
58.                 if (current.key.equals(key)) {
59.                     current.value = value; // 更新值
60.                     return;
61.                 }
62.                 if (current.next == null) {
63.                     break;
64.                 }
65.                 current = current.next;
66.             }
67.             
68.             // 在链表末尾添加新节点
69.             current.next = newNode;
70.             size++;
71.         }
72.         
73.         // 查找键对应的值
74.         public Integer get(String key) {
75.             int index = hash(key);
76.             Node current = buckets[index];
77.             
78.             // 遍历链表查找匹配的键
79.             while (current != null) {
80.                 if (current.key.equals(key)) {
81.                     return current.value;
82.                 }
83.                 current = current.next;
84.             }
85.             
86.             // 未找到
87.             return null;
88.         }
89.         
90.         // 删除键值对
91.         public boolean remove(String key) {
92.             int index = hash(key);
93.             Node current = buckets[index];
94.             Node prev = null;
95.             
96.             // 查找目标节点
97.             while (current != null) {
98.                 if (current.key.equals(key)) {
99.                     break;
100.                 }
101.                 prev = current;
102.                 current = current.next;
103.             }
104.             
105.             // 未找到目标节点
106.             if (current == null) {
107.                 return false;
108.             }
109.             
110.             // 删除节点
111.             if (prev == null) {
112.                 buckets[index] = current.next;
113.             } else {
114.                 prev.next = current.next;
115.             }
116.             
117.             size--;
118.             return true;
119.         }
120.         
121.         // 扩容并重新哈希
122.         private void resize(int newCapacity) {
123.             Node[] oldBuckets = buckets;
124.             
125.             // 创建新的哈希表
126.             buckets = new Node[newCapacity];
127.             capacity = newCapacity;
128.             size = 0;
129.             
130.             // 重新哈希所有元素
131.             for (Node bucket : oldBuckets) {
132.                 Node current = bucket;
133.                 while (current != null) {
134.                     put(current.key, current.value);
135.                     current = current.next;
136.                 }
137.             }
138.         }
139.     }
140.    
141.     public static void main(String[] args) {
142.         HashTable hashTable = new HashTable(10);
143.         
144.         // 插入数据
145.         hashTable.put("apple", 5);
146.         hashTable.put("banana", 10);
147.         hashTable.put("orange", 15);
148.         hashTable.put("grape", 20);
149.         
150.         // 查找数据
151.         System.out.println("apple: " + hashTable.get("apple"));
152.         System.out.println("banana: " + hashTable.get("banana"));
153.         System.out.println("orange: " + hashTable.get("orange"));
154.         System.out.println("grape: " + hashTable.get("grape"));
155.         System.out.println("watermelon: " + hashTable.get("watermelon"));
156.         
157.         // 删除数据
158.         hashTable.remove("orange");
159.         System.out.println("After removing orange: " + hashTable.get("orange"));
160.     }
161. }

复制代码

优点

• 查找、插入和删除操作的平均时间复杂度为 O(1)
  
• 适用于快速查找
  
• 不要求数据有序，更灵活
  
• 支持动态数据集，高效地添加和删除元素
  
• 通过合适的哈希函数和解决冲突策略，能实现非常优秀的性能
  

缺点

• 哈希冲突会降低查找效率，最坏情况下时间复杂度可能退化到 O(n)
  
• 需要额外的空间存储哈希表
  
• 不支持范围查询，不适合按顺序遍历场景
  
• 负载因子过高会导致性能下降，过低会浪费空间
  

应用场景

哈希查找适用于以下场景：

• 需要快速查找、插入和删除操作的数据结构，如字典或映射
  
• 实现缓存系统，比如LRU缓存、内存缓存等
  
• 数据库索引，特别是等值查询
  
• 符号表实现，如编译器和解释器中的变量表
  
• 去重操作，判断元素是否已存在
  
• 网页爬虫的URL去重
  

一致性哈希

一致性哈希是分布式系统中的重要概念，目的是尽可能少地重新分配数据
详情可以看一致性哈希算法
布隆过滤器

布隆过滤器是一种空间效率高的概率型数据结构，判断一个元素是否在集合中
详情可以看布隆过滤器
相关的 LeetCode 热门题目

• 1. 两数之和 - 使用哈希表记录已遍历元素，查找目标值的补数
  
• 3. 无重复字符的最长子串 - 使用哈希表记录字符最后出现的位置
  
• 136. 只出现一次的数字 - 可以用哈希表记录每个数字的出现次数
  
• 146. LRU 缓存 - 结合哈希表和双向链表实现LRU缓存
  
• 217. 存在重复元素 - 使用哈希表检查重复元素
  
• 349. 两个数组的交集
  
• 387. 字符串中的第一个唯一字符 - 使用哈希表统计字符出现次数
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！