精华内容
下载资源
问答
  • 查找时间复杂度总结

    千次阅读 2020-07-13 16:19:23
    1.二叉排序树 如果二叉排序树是平衡的,则n个节点的二叉排序树的高度为,其查找效率为,近似于折半查找。如果二叉排序树完全不平衡,则其深度可... 平均时间复杂度 稳定度 空间复杂度 ...

    1.二叉排序树

    如果二叉排序树是平衡的,则n个节点的二叉排序树的高度为,其查找效率为,近似于折半查找。如果二叉排序树完全不平衡,则其深度可达到n,查找效率为O(n),退化为顺序查找。一般的,二叉排序树的查找性能在到O(n)之间。因此,为了获得较好的查找性能,就要构造一棵平衡的二叉排序树。

     

     2.排序算法总结

     

    排序法

    最好时间分析

    最差时间分析

    平均时间复杂度

    稳定度

    空间复杂度

    插入排序

    直接插入排序

    O(n)

    O(n2)

    O(n2)

    稳定

    O(1)

    折半插入排序 与直接插入排序相比,仅仅是减少了比较元素的次数,O(nlog2n) O(n2) 稳定 O(1)
    希尔排序   O(n2)  

    不稳定

    O(1)

    交换排序

    冒泡排序

    O(n)

    O(n2)

    O(n2)

    稳定

    O(1)

    快速排序

    O(nlog2n)

    O(n2)

    O(n*log2n)

    不稳定

    O(log2n)

    选择排序

    简单选择排序

    O(n2)

    O(n2)

    O(n2)

    稳定

    O(1)

    堆排序

    O(nlog2n)

    O(n*log2n)

    O(n*log2n)

    不稳定

    O(1)

    归并排序

    2路归并排序

    O(nlog2n)

    O(nlog2n)

    O(n*log2n)

    稳定

    O(n)

    基数排序 基数排序 O(d(n+r)) O(d(n+r)) O(d(n+r)) 稳定 O(r)

    3.查找算法时间复杂度

     

    查找

    平均时间复杂度

    查找条件

    算法描述

    线性结构

    顺序查找

    O(n)

    无序或有序队列

    按顺序比较每个元素,直到找到关键字为止(存储可以使顺序的也可以是链式)

    二分查找(折半查找)

    O(logn)

    有序数组

    查找过程从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜素过程结束;如果某一特定元素大于或者小于中间元素,则在数组大于或小于中间元素的那一半中查找,而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空,则代表找不到。(只适用有序的顺序表)

    分块查找

    O(logn)

    无序或有序队列

    将n个数据元素"按块有序"划分为m块(m ≤ n)。

    每一块中的结点不必有序,但块与块之间必须"按块有序";即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字;而第2块中任一元素又都必须小于第3块中的任一元素,……。

    1.在索引表中确定待查记录所在的块,可使用顺序查找或折半查找;

    2.在块内顺序查找

     

    二叉排序树查找

    O(logn)

    二叉排序树

    在二叉查找树b中查找x的过程为:

    1. 若b是空树,则搜索失败

    2. 若x等于b的根节点的数据域之值,则查找成功;

    3. 若x小于b的根节点的数据域之值,则搜索左子树

    4. 查找右子树。

     

    哈希表法(散列表)

    O(1)

    先创建哈希表(散列表)

    根据键值方式(Key value)进行查找,通过散列函数,定位数据元素。

     

    展开全文
  • ​​​​​​​顺序查找时间复杂度为O(n) 二分查找时间复杂度为O(log(n)) 但两者的运行时间的结果却千差万别,可知当计算量很大的情况下算法优化的必要性。 import java.util.Arrays; public class Main { ...
    • 注意要点:通过System.currentTimeMills();来获取当前时间,来计算该算法运行运算时间
    1. ​​​​​​​顺序查找的时间复杂度为O(n)
    2. 二分查找的时间复杂度为O(log(n))
    • 但两者的运行时间的结果却千差万别,可知当计算量很大的情况下算法优化的必要性。
    import java.util.Arrays;
    
    public class Main {
    	public static int a[] = new int[10000*10000];
    	
    	public static void main(String[] args) {
    		for(int i = 0; i < 10000* 10000; i ++) {
    			a[i] = i + 1;
    		}
    		int target = 10000 * 10000;
    //计算顺序查找所用时间
    		long start = System.currentTimeMillis();
    		find(target);
    		long end = System.currentTimeMillis();
    		System.out.println(end - start + "ms");
    //计算二分查找所用时间	
    	    start = System.currentTimeMillis();
    		Arrays.binarySearch(a, target);
    		end = System.currentTimeMillis();
    		System.out.println(end - start + "ms");
    
    
    	}
    
    	private static void find(int target) {
    		for(int i = 0; i < 10000 * 10000; i ++) {
    			if(a[i] == target) {
    				return;
    			}
    		}
    	}
    
    }
    

    运行结果:

    55ms
    0ms

     

    展开全文
  • 时间维度:是指执行当前算法所消耗的时间,我们通常用「时间复杂度」来描述。 空间维度:是指执行当前算法需要占用多少内存空间,我们通常用「空间复杂度」来描述。 二分查找分析: 二分查找每次排除掉一半的不适合...
    主要还是从算法所占用的「时间」和「空间」两个维度去考量。
    时间维度:是指执行当前算法所消耗的时间,我们通常用「时间复杂度」来描述。
    空间维度:是指执行当前算法需要占用多少内存空间,我们通常用「空间复杂度」来描述。
    
    二分查找分析:
    二分查找每次排除掉一半的不适合值,所以对于N个元素的情况:
    一次二分剩下:N/2
    两次二分剩下:N/2/2 = n/4
    三次二分查找剩下:N/2/2/2 = N/8
    .....
    M次二分剩下:n / (2^M)
    
    在最坏情况下是在排除到只剩下最后一个值之后得到结果,即
    N / (2^m) = 1
    所以由上式可得:2^m = N
    推出时间复杂度是以2为底的对数公式:
    m = log2(N)
    注意:m为查找次数, N为元素个数.
    
    例如:求0-10000个元素中最多几次查找到73?
    m = log2(10000)
    m = 13次

     

    展开全文
  • 二分查找时间复杂度计算与分析

    万次阅读 多人点赞 2017-04-05 21:18:41
    二分查找:  二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按...

    二分查找:

      二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

      概括之:1)序列有序;2)可以随机访问

      争议:表必须有序,表可以顺序方式存储,也可以链表方式存储。有人说,表只能顺序存储;但也有人说,折半查找也可以用跳表实现,跳表即不是顺序存储。跳表维基百科

    时间复杂度:T(logn)

    我们首先来看一下实现代码:

    public static int biSearch(int []array,int a){
            int lo = 0;
            int hi = array.length-1;
            int mid;
            while(lo <= hi) {
                mid = lo + (hi - lo) / 2;
                if(array[mid] == a) {
                    return mid;
                }else if(array[mid] < a) {
                    lo = mid + 1;
                }else{
                    hi = mid - 1;
                }
            }
            return -1;
        }
    

    分析:

    因为二分查找每次排除掉一半的不适合值,所以对于n个元素的情况:

    一次二分剩下:n/2
    两次二分剩下:n/2/2 = n/4

    m次二分剩下:n/(2^m)

    在最坏情况下是在排除到只剩下最后一个值之后得到结果,即

    n/(2^m)=1

    所以由上式可得 : 2^m=n

    进而可求出时间复杂度为: log2(n)

    嘿嘿,公众号粉丝越来越多了,大佬,随手点个关注呗,不光有新鲜的 LeetCode 题解(多种思路,包教包会,开拓思维),还有经典的文章及短视频和大家分享,谢谢!一起嘿嘿嘿!三种静态查找算法:顺序、二分/折半、索引/分块查找
    在这里插入图片描述

    ------致所有正在努力奋斗的程序猿们!加油!!
    有码走遍天下 无码寸步难行
    1024 - 梦想,永不止步!
    爱编程 不爱Bug
    爱加班 不爱黑眼圈
    固执 但不偏执
    疯狂 但不疯癫
    生活里的菜鸟
    工作中的大神
    身怀宝藏,一心憧憬星辰大海
    追求极致,目标始于高山之巅
    一群怀揣好奇,梦想改变世界的孩子
    一群追日逐浪,正在改变世界的极客
    你们用最美的语言,诠释着科技的力量
    你们用极速的创新,引领着时代的变迁

    ——乐于分享,共同进步,欢迎补充
    ——Treat Warnings As Errors
    ——Any comments greatly appreciated
    ——Talking is cheap, show me the code
    ——简书:https://www.jianshu.com/u/4968682d58d1
    ——GitHub:https://github.com/selfconzrr

    展开全文
  • 单向链表要删除某一节点时,必须要先通过遍历的方式找到前驱节点(通过待删除节点序号或按值查找)。若仅仅知道待删除节点,是不能知道前驱节点的,故单链表的增删...否则只能按序或按值查找前驱节点,时间复杂度为O(..
  • 二分查找是一个非常常用且简洁的查找算法,相信很多人也知道它的时间复杂度是logN,但是我看网上的大多数博客给出的所谓推导过程都十分不严谨,于是我花了些时间自己写了推导过程。 首先上二分查找的代码: ...
  • ​之前一直不太懂,为什么跳表的平均时间复杂度为O(logN) 但是后来看了下[url]http://blog.xiaoheshang.info/?p=248[/url] 算是理解了一些,再结合自己的思考,记录一下 首先,需要理解刚才那篇文章中的 "如果...
  • 二分查找的基本思想是将n个元素分成...时间复杂度无非就是while循环的次数! 总共有n个元素, 渐渐跟下去就是n,n/2,n/4,....n/2^k,其中k就是循环的次数 由于你n/2^k取整后>=1 即令n/2^k=1 可得k=log2n,(是以2为
  • 今天简单的总结一下算法中经常用到的排序以及查找(用C语言实现,不全,持续更新)一、首先是最常见也是最常被问的冒泡排序(原理就是每趟排序相邻两两比较...因为比较好理解,就省略了)//冒泡排序 -(void)...
  • 因为二分查找每次排除掉一半的不适合,所以对于n个元素...所以时间复杂度为:log2(n) 快速排序的基本思想是:每次从无序的序列中找出一个数作为中间点(可以把第一个数作为中间点),然后把小于中间点的数放在中间点
  • 查找算法时间复杂度 问题描述 写出两种检索算法:在一个排好序的数组T[1…n]中查找x,如果x在T中,输出x在 T的下标j;如果x不在T中,输出j=0.按实验模板编写,“分析”部分仅给出复杂度 结果即可。 算法 顺序查找:...
  • 几种查找时间复杂度

    千次阅读 2020-04-03 22:32:20
    时间复杂度为:O(1) (2)最坏情况:最后一个是要查找的元素。时间复杂度未:O(n) (3)平均情况下就是:(n+1)/2。 所以总的来说时间复杂度为:O(n) 2、二分查找:O(log2n)->log以2为底n的对数 解释:2^t = n; ...
  • 数组适合查找操作,但是查找时间复杂度并不为O(1),即便是排序好的数据,你用二分查找时间复杂度也是O(logn),所以正确的表述是,数组支持随机访问,根据下标随机访问的时间复杂度为O(1) 转载于:...
  • 1、各种排序的时间复杂度 2、各种查找算法的时间复杂度
  • 二叉树查找时间复杂度

    万次阅读 2018-10-30 09:18:52
    给定的比较次数等于给定节点在二叉排序树中的层数。如果二叉排序树是平衡的,则n个节点的二叉排序树的高度为Log2(n+1),其查找效率为O(Log2n),近似于折半查找。如果二叉排序树完全不平衡,则其深度可达到n,查找...
  • 今天刷到一道题,求两个正序数组的中位数(长度分别为m、n)要求时间复杂度降到 O(log(m+n)) 首先我们很容易想到O(m+n)的解法...如果对时间复杂度的要求有 log,通常都需要用到二分查找。 废话不多说直接上图 ...
  • 二分查找也叫折半查找,根据字面意思大概知道是怎么个查找具体一个元素的吧。首先分析下查询过程: 我们先通过被查询的数组得到该被查询数组的第一个索引和最后一个索引,假如我们拿数组10个元素来做例子我们得到...
  • 本篇包括: 通过代码来理解线性查找 时间复杂度 什么是算法 通过代码来理解线性查找 什么叫"线性"?还是在代码中体会吧。 首先需要一个集合或数组,如何得到呢?就生成一个固定长度的随机数组吧。然后输入...
  • 利用下面代码可以定义一个集合S,对该集合所有的操作,比如插入、删除元素和查找元素都是O(1),代码如下: function newset() local reverse = {} --以数据为key,数据在set中的位置为value local set = {} --一...
  • 二分查找时间复杂度

    千次阅读 2020-08-17 14:22:10
    搜索的几种常见方法:顺序查找、二分法查找、二叉树查找、哈希查找。 2、二分法查找 二分法查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;缺点是要求待查表为有序表,且插入删除困难。因此,折半...
  • 时间复杂度

    2019-05-21 14:25:10
    O(n)不是算法,它是一个函数,是一个表征算法时间复杂度的一...使用这种方式时,时间复杂度可被称为是渐近的,它考察当输入大小趋近无穷时的情况。 扩展资料: 算法复杂度分为时间复杂度和空间复杂度。 其作用: ...
  • 常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) ...
  • 常用的排序/查找算法的时间复杂度和空间复杂度 常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n²) O(n²) 稳定 O(1) 插入排序 O(n²) O(n...
  • 二分查找时间复杂度计算分析

    千次阅读 2020-01-14 14:48:43
    二分查找: 二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。   原理:假设表中元素是...
  • 时间复杂度和空间复杂度的简单讲解

    万次阅读 多人点赞 2018-01-07 12:55:26
    一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。 把今年很流行,淡淡的基佬紫送给各位看官,原谅绿就算了,怕被打死...当我们面前有多个算法时,我们可以通过计算时间复杂度,判断出哪一

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,309
精华内容 61,723
关键字:

值查找时间复杂度