几种查找的时间复杂度

最新推荐文章于 2025-04-27 10:05:46 发布
原创 最新推荐文章于 2025-04-27 10:05:46 发布 · 2.8w 阅读 · 118 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了几种常见的查找算法，包括顺序查找、二分查找、插值查找、斐波那契查找、树表查找、分块查找及哈希查找的时间复杂度。通过对比不同算法在最好、最坏及平均情况下的表现，帮助读者理解各种查找算法的效率特点。

1、顺序查找：
（1）最好情况：要查找的第一个就是。时间复杂度为：O(1)
（2）最坏情况：最后一个是要查找的元素。时间复杂度未：O(n)
（3）平均情况下就是：（n+1）/2。
所以总的来说时间复杂度为：O(n)
2、二分查找：O(log2n)->log以2为底n的对数
解释：2^t = n; t = log(2)n;
3、插值查找：O(log(2)(log(2)n))->log以2为底的（log以2为底的n的对数）的对数
4、斐波那契查找：O(log2n)->log以2为底n的对数
5、树表查找：
（1）二叉树：O(log2n)~O(n)之间
（2）红黑树：O(lgn)
（3）B和B+树：O(log2n)
6、分块查找：O(log2n)~O(n)之间
7、哈希查找：O(1)

时间复杂度度详解
yjy000的博客
12-08 715
时间复杂度是衡量算法性能的重要指标，用来描述算法随着输入规模 n 增大，运行时间的增长趋势。： 在每次分割过程中将数组对半分，分割深度为 log⁡ n，每层合并操作的成本为 O(n)。对于 n个元素，需要计算所有可能的排列，时间复杂度为 O(n!其中 f(n)是输入规模 n 的函数，代表操作数量的增长速度。：运行时间随输入规模以阶乘方式增长，通常出现在排列组合问题中。：运行时间随着输入规模平方增长，通常出现在嵌套循环中。：运行时间随输入规模指数增长，通常出现在穷举算法中。：运行时间随输入规模按对数增长。
算法中的各种排序以及查找时间复杂度
等待化茧成蝶的专栏
03-01 8991
今天简单的总结一下算法中经常用到的排序以及查找(用C语言实现，不全，持续更新)一、首先是最常见也是最常被问的冒泡排序（原理就是每趟排序相邻两两比较...因为比较好理解，就省略了）//冒泡排序 -(void)maoPaoPaiXu { int i,j,temp; int a[10]={3,5,1,2,6,5,2,1,3,4}; //输入 /*for(i=0;...
C/C++面试之算法系列－－时间复杂度为o(N)查找1至N-1构成的a[N]重复元素
Sailor_forever
10-12 6954
 时间复杂度为o(N)查找1至N-1构成的a[N]重复元素 Sailor_forever  sailing_9806@163.com 转载请注明http://blog.csdn.net/sailor_8318/archive/2008/10/12/3059935.aspx ××××××××××××××××××××××××××××××××××数组a[N]，1至N-1这N-
搜索算法：插值搜索
新华编程特战队
01-15 1043
因此，如果我们想要搜索像“二进制”这样的单词，人类的自然本能是从字典的开头开始搜索，因为我们知道所有以 b 开头的单词都必须位于此处。如果数组是均匀分布的，我们可以说它将遵循一条直线路径，因此，我们可以使用上面的等式表示数组的元素如下。对于较大的数字，它将在数组末尾的某个位置开始搜索，对于较小的数字，它将在开头的某个位置开始搜索。今天我们学习了一种在均匀分布的排序数据集中查找元素的算法，该算法的灵感来自于我们人类的本能。在均匀分布的数组中，较大的数字将位于数组的末尾，而较小的数字将位于数组的开头。
008.【查找算法】六种查找算法的时间复杂度
热门推荐
qq_42226855的博客
09-05 1万+
上述时间复杂度都是按照各个算法的平均（理想）复杂度进行计算的。情况的不同复杂度就会不同。时间复杂度（大O表示法）
各种查找、排序的时间复杂度
狒狒也是程序猿的专栏
04-15 2447
(1)冒泡排序         冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。 (2)选择排序       选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的。…… 例子说明好多了。序列5 8 5 2 9， 我们知道第一遍选择第1个元素5
算法简介——二分查找，时间复杂度，空间复杂度
qq_55977554的博客
01-26 5484
文章目录前言二分查找时间复杂度大O表示法空间复杂度小结 前言 算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。 算法是一组完成任务的指令。任何代码片段都可视为算法。 二分查找 我相信大家可
算法时间复杂度
11-02
时间复杂度是用来表示一个程序（或算法）执行时间与输入数据量之间关系的一种量度方法。它是通过分析算法执行过程中基本操作的次数来评估算法效率的一个标准。时间复杂度通常用大O符号表示，如O(1)、O(n)、O(n^2)等...
几种数据结构的查找、插入、删除的时间复杂度对比
liu_feng_zi_的专栏
09-23 4654
1、查找是指给定一个元素值进行查找 2、对于数组，插入是指插入到某一下标位置，元素后移 数据结构 查找 插入 删除 数组 O(n) O(n) O(n) 有序数组 O(logn)(二分查找) O(n) O(n) 单链表 O(n) O(n) O(n) 有序单链表 O(n) O(n) O(n) 双链表 O(n) O(n) O(n) 有序双链表 O(n) O(n)
常用查找算法
dtnqy的专栏
05-11 1140
1，顺序查找 条件：无 原理：按顺序比较每个元素，直到找到或遍历完元素为止 时间复杂度：O（n） private static int findSequent(int[] arr,int k){ int p = -1; for(int i=0;i<arr.length;i++){ if(k == arr[i]){
常用的排序/查找算法的时间复杂度和空间复杂度
m0_51697147的博客
10-20 2391
常用的排序/查找算法的时间复杂度和空间复杂度
常见查找算法的时间复杂度与使用场景
shabixsaf的博客
04-27 1773
以下是常见查找算法及其时间复杂度的详细介绍： 顺序查找是最基本的查找算法，它依次遍历数据结构中的每个元素，直到找到目标元素或遍历完整个数据结构。适用场景：适用于无序的数据结构，例如无序数组或链表。时间复杂度：最好情况：目标元素恰好在第一个位置，时间复杂度为 O(1)O(1)O(1)。最坏情况：目标元素在最后一个位置或者不存在，需要遍历整个数据结构，时间复杂度为 O(n)O(n)O(n)，其中 nnn 是数据结构中元素的数量。平均情况：平均需要遍历一半的元素，时间复杂度为 O(n)O(n)O(n)。二分查找要
常见排序、查找算法的时间复杂度&空间复杂度&描述&示例
qq_53217531的博客
09-04 534
常见排序、查找算法的时间复杂度&空间复杂度&描述&示例
查找时间复杂度总结
qq_41958041的博客
07-13 4674
1.二叉排序树 如果二叉排序树是平衡的，则n个节点的二叉排序树的高度为,其查找效率为，近似于折半查找。如果二叉排序树完全不平衡，则其深度可达到n，查找效率为O(n)，退化为顺序查找。一般的，二叉排序树的查找性能在到O(n)之间。因此，为了获得较好的查找性能，就要构造一棵平衡的二叉排序树。 2.排序算法总结 排序法 最好时间分析 最差时间分析 平均时间复杂度 稳定度 空间复杂度 ...
【数据结构与算法】 - 时间复杂度和空间复杂度、二分查找、线性查找
m0_62605243的博客
09-28 648
在计算机科学领域，数据结构是一种数据组织、管理和存储格式，通常被选择用来高效访问数据。二分查找算法也称折半查找，是在一个升序数组中，查找要需要找的值，如果找到就返回该数的索引，否则返回-1。
查找算法时间复杂度1_算法时间复杂度的那些事
weixin_39911066的博客
11-20 543
对于一个算法来说，我们如何评价它的好坏呢？一般来说就是通过程序解决问题的时间和空间。现在的计算机空间效率一般已经不是关注的重点了，但是时间效率仍然是算法关注的重点。而考查一个程序的运行时间，就需要将程序每次执行的操作表示成输入规模的函数。这就是时间复杂度分析。时间复杂度的分析也是算法面试中常考的问题，经过最近的学习，总结如下。什么是大O记法举几个例子来说，O(f(n))是一个集合，表示的...
各种排序以及查找算法的时间复杂度
tianqiztq的博客
09-17 5448
1、各种排序的时间复杂度 2、各种查找算法的时间复杂度
不用顺序查找哪个时间复杂度低
最新发布
11-23
<think> 题目要求不使用顺序查找（即线性查找）而使用时间复杂度更低的方法。由于题目中说明顺序表中无重复元素，且输入的元素不超过100个，但为了追求更低的查找时间复杂度，我们可以考虑使用二分查找（前提是有序）。但是题目没有说明顺序表是有序的，所以我们有两种选择： 1. 先对顺序表排序，然后使用二分查找。这样排序的时间复杂度为O(n log n)，而每次查找的时间复杂度为O(log n)。如果查找次数很多，这种方法更优。 2. 使用哈希表（例如unordered_map）来存储每个元素的位序，这样每次查找的时间复杂度为O(1)，但是需要额外的空间。 根据题目要求，输入的第一行是顺序表元素，且无重复。我们可以使用哈希表（散列表）来实现O(1)的查找。具体做法是： - 用一个数组存储顺序表的元素（按输入顺序） - 同时用一个unordered_map来映射元素值到其位置（位序） 但是注意：题目要求从1开始的位序。 步骤： a. 读入n b. 定义一个数组（可以不用，但为了通用性，我们保留顺序表存储） c. 定义一个unordered_map<int, int>，键为元素值，值为位序（即下标+1） d. 读入n个整数，同时存入数组（可以省略，只存map），并在map中记录每个元素的位序。 e. 然后读入待查找元素，直到-1结束。对于每个元素，在map中查找，如果找到则输出位序，否则输出0。 这样，查找操作的平均时间复杂度为O(1)，最坏情况为O(n)（但通常不会发生，因为哈希表设计良好的话冲突很少）。 由于题目中元素不超过100个，所以哈希表不会很大，而且元素值不超过1000，所以完全可以用数组下标直接映射（即用空间换时间）： - 因为元素值不超过1000，所以我们可以用一个大小为1001的数组（下标0到1000）来直接存储位序。这样查找就是O(1)。 具体代码实现： int *hashTable = new int[1001](); // 初始化全0 然后读入顺序表元素时，对于元素x，令hashTable[x] = i+1;（i是下标） 这样在查找时，直接根据元素值作为下标访问数组即可。 但是注意：题目中元素是正整数，且不超过1000，所以数组大小1001足够（包括0不用，下标1到1000）。 因此，我们使用一个大小为1001的数组作为哈希表，初始化为0。然后读入顺序表元素时，将元素值作为索引，将位序存入该位置。查找时，直接取该元素值对应的数组值，如果为0则说明不存在，否则就是位序。 这种方法比顺序查找快，尤其当查找次数多时。 但是注意：题目要求顺序查找，但这里要求不用顺序查找，所以采用此方法。 代码： 注意：题目要求最后以-1结束，且-1不需要查找。 例如输入样例： 9 3 7 9 1 4 6 2 5 8 3 8 2 9 10 -1 输出：1 9 7 3 0 代码实现： 由于题目要求每个数字后面跟一个空格，我们直接输出即可。 修改后的代码： ```cpp #include <iostream> using namespace std; int main() { int n; cin >> n; // 创建哈希表数组，大小为1001（因为元素值最大为1000），初始化为0 int hashTable[1001] = {0}; // 全部初始化为0 for (int i = 0; i < n; i++) { int num; cin >> num; // 将元素num的位序设为i+1 hashTable[num] = i + 1; } int target; while (cin >> target) { if (target == -1) { break; } // 如果target在哈希表中有记录（非0），则输出记录的值，否则输出0 if (target >= 1 && target <= 1000) { cout << hashTable[target] << " "; } else { // 如果target不在1到1000范围内，则一定不存在（因为顺序表元素都在1到1000） cout << "0 "; } } return 0; } ``` 注意：题目保证顺序表元素是正整数且不超过1000，所以当target在1到1000之间时，我们直接输出hashTable[target]；如果target不在这个范围内（虽然题目输入待查找元素也是正整数，但为了安全，且题目说最后以-1结尾，所以当target为负数且不为-1时，我们不会进入循环，因为-1会break，但其他负数？题目说最后一行给出若干正整数，所以负数只有-1，所以我们在循环条件中读到-1会跳出，所以不会出现负数。但题目说待查找元素是正整数，所以我们可以不考虑负数。但是为了健壮性，我们检查了范围，如果不在1到1000之间，则直接输出0。 但是注意：题目中顺序表元素是正整数且不超过1000，所以如果待查找元素是0或者大于1000的数，那么肯定不存在，所以输出0。 因此，上述代码是安全的。 时间复杂度：初始化哈希表O(1)（固定1001），读入顺序表O(n)，每次查找O(1)，总的时间复杂度O(n+m)（m为查找次数）。 空间复杂度：O(1001) = O(1) 这种方法比顺序查找快得多，尤其是在多次查找的情况下。 §§相关问题§§: 1. 在什么情况下使用顺序查找比二分查找更合适？ 2. 如果顺序表中有重复元素，如何修改哈希表方案以支持查找所有匹配的位置？ 3. 哈希表查找的时间复杂度是多少？最坏情况下的时间复杂度是多少？ 4. 如果元素值的范围非常大（例如10^9），但元素个数n只有100，如何实现高效的查找？ </think> ### 使用哈希表实现高效查找 (O(1)时间复杂度) ```cpp #include <iostream> using namespace std; int main() { const int MAX_VALUE = 1000; // 元素最大值 int hashTable[MAX_VALUE + 1] = {0}; // 哈希表数组 int n; cin >> n; // 建立哈希表：元素值→位置索引 for (int i = 1; i <= n; i++) { int num; cin >> num; hashTable[num] = i; // 存储元素位置（从1开始） } int target; while (cin >> target && target != -1) { // 读取直到-1 // 直接在哈希表中查找 if (target >= 1 && target <= MAX_VALUE && hashTable[target] != 0) { cout << hashTable[target] << " "; } else { cout << "0 "; } } return 0; } ``` ### 代码解释： 1. **哈希表设计**： - 创建大小为1001（元素最大值1000+1）的数组`hashTable` - 初始化所有元素为0（表示未存储） 2. **建立映射关系**： ```cpp for (int i = 1; i <= n; i++) { cin >> num; hashTable[num] = i; // 元素值作为索引，存储位置 } ``` - 将元素值直接作为数组索引 - 存储对应的位置序号（从1开始） 3. **O(1)时间复杂度查找**： ```cpp if (target >= 1 && target <= MAX_VALUE && hashTable[target] != 0) { cout << hashTable[target] << " "; } ``` - 直接通过元素值访问数组位置 - 非0值表示存在，值即为位置序号 - 0值表示不存在 ### 性能对比： | 查找方法 | 时间复杂度 | 空间复杂度 | 适用场景 | |---------|-----------|----------|---------| | 顺序查找 | O(n) | O(1) | 小规模无序数据 | | **哈希表查找** | **O(1)** | O(max_value) | 元素范围有限的无重复数据 | | 二分查找 | O(log n) | O(1) | 有序数据 | ### 为什么哈希表更快？ - **直接寻址**：通过元素值直接计算存储位置 - **无比较操作**：省去了顺序查找中的循环比较 - **常数时间访问**：无论数据规模大小，访问时间恒定
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值