精华内容
下载资源
问答
  • 二分查找时间复杂度分析

    千次阅读 2020-01-20 10:51:52
    主要还是从算法所占用的「时间」和「空间」两个维度去考量。...二分查找每次排除掉一半的不适合值,所以对于N个元素的情况: 一次二分剩下:N/2 两次二分剩下:N/2/2 = n/4 三次二分查找剩下:N/2/2/2 = N/8 ...
    主要还是从算法所占用的「时间」和「空间」两个维度去考量。
    时间维度:是指执行当前算法所消耗的时间,我们通常用「时间复杂度」来描述。
    空间维度:是指执行当前算法需要占用多少内存空间,我们通常用「空间复杂度」来描述。
    
    二分查找分析:
    二分查找每次排除掉一半的不适合值,所以对于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(1)O(1)

      二分查找假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

    • 优点:比较次数少,查找速度快,平均性能好;
    • 缺点:要求待查表为有序顺序表,且插入删除困难。
    • 二分查找方法适用于不经常变动而查找频繁的有序列表。
    • 二分查找最优时间复杂度是 O ( 1 ) O(1) O(1),最坏时间复杂度为 O ( l o g 2 n ) O(log_2n) O(log2n)
      假设总共有 n n n个元素,查找操作次数为 k k k,则每次查找的区间大小就是 n , n 2 , n 4 , … , n 2 k n,\frac{n}{2},\frac{n}{4},…,\frac{n}{2^k} n,2n,4n,,2kn(接下来操作元素的剩余个数)。最好第一次操作就找到元素,时间复杂度为 O ( n ) O(n) O(n),最坏最后剩余的一个元素才是要查找的元素,即 n 2 k = 1 ⟹ k = l o g 2 n \frac{n}{2^k}=1\Longrightarrow k=log_2n 2kn=1k=log2n(假设是整数),时间复杂度为 O ( l o g 2 n ) O(log_2n) O(log2n)

    递归实现二分查找

    # 返回 x 在 arr 中的索引,如果不存在返回 -1
    def binarySearch (arr, l, r, x): 
        # 基本判断
        if l <= r: 
            mid = (l+r)//2
            # 元素整好的中间位置
            if arr[mid] == x: 
                return mid 
            # 元素小于中间位置的元素,只需要再比较左边的元素
            elif arr[mid] > x: 
                return binarySearch(arr, l, mid-1, x) 
            # 元素大于中间位置的元素,只需要再比较右边的元素
            else: 
                return binarySearch(arr, mid+1, r, x) 
        else: 
            # 不存在
            return -1
    
    # 函数调用
    result = binarySearch(arr, 0, len(arr)-1, x) 
    

    非递归实现二分查找

    def binarySearch (arr, x): 
    	n=len(arr)
    	l,r=0,n-1
    	while l<=r:
    		mid=(l+r)//2
    		if arr[mid]==x:
    			return mid
    		elif arr[mid]>x
    			r=mid-1
    		else:
    			l=mid+1
    	return -1		
    
    展开全文
  • 二分查找是一个非常常用且简洁的查找算法,相信很多人也知道它的时间复杂度是logN,但是我看网上的大多数博客给出的所谓推导过程都十分不严谨,于是我花了些时间自己写了推导过程。 首先上二分查找的代码: ...

      二分查找是一个非常常用且简洁的查找算法,相信很多人也知道它的时间复杂度是logN,但是我看网上的大多数博客给出的所谓推导过程都十分不严谨,于是我花了些时间自己写了推导过程。

    首先上二分查找的代码:

        public int find(int x, int[] data) {
            return find(x, data, 0, data.length - 1);
        }
    
        /**
         * 查找元素下标,没找到返回-1
         * @param x 待查找元素
         * @param data 有序的元素数组
         * @createTime:2017年3月4日 
         * @author: gaojiabao
         */
        private int find(int x, int[] data, int low, int high) {
            int mid = (low + high) >> 1;
            if (x == data[mid]) {
                return mid;
            } else if (x > data[mid]) {
                low = mid + 1;
            } else if (x < data[mid]) {
                high = mid - 1;
            }
    
            if (low == high) {
                if (x == data[low]) {
                    return low;
                } else {
                    return -1;
                }
            } else {
                return find(x, data, low, high);
            }
        }

    下面是推导过程:

    假设数据的规模为N(即每次调用时的high-low),程序执行的比较次数表示为C(N),假设程序查找的是一个不存在的数据,则此时执行的次数是最多的:

    执行第一次时,有:

    1代表执行了一次x和data[mid]的比较过程,代表下一次递归调用find方法时high-low的值,也就是新的数据规模每次较少一半以上。

    递归上面的公式,有:

    我们知道每一个整数都可以表示为2i+k的形式,如1=20+0,5=22+1,10=23+2,因此

    设N=2i+k

    令上面公式的n=i,则有:

    因为N=2i+k,则有i=⌊lgN⌋,因此:

     

     

    因为我们一直以来的假设是要查找到的元素是找不到的,所以现在的情况是C(N)最大的情况,对于一般情况,则有:

     

    因此二分查找的时间复杂度是logN。 

     

    转载于:https://www.cnblogs.com/sheeva/p/6501591.html

    展开全文
  • 二分查找的基本思想是将n个元素分成大致相等的两部分,去a[n/2]与x做比较,如果x=a[n/2],则找到x,算法中止;如果x&lt;a[n/2],则只要在数组a的左半部分继续搜索x,如果x&gt;a[n/2],则只要在数组a的右半部搜索x...
  • 解析二分查找时间复杂度

    千次阅读 2018-03-20 15:44:33
    话不多说,先来段二分查找的代码。#define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; int BinSearch(int arr[], int sz, int key){//找到返回下标,找不到返回-1 int left = 0; int right = sz -...
  • 注意要点:通过System.... 二分查找时间复杂度为O(log(n)) 但两者的运行时间的结果却千差万别,可知当计算量很大的情况下算法优化的必要性。 import java.util.Arrays; public class Main { public static ...
  • 因为二分查找每次排除掉一半的不适合值,所以对于n个元素的情况:一次二分剩下:n/2两次二分剩下:n/2/2 = n/4。。。m次二分剩下:n/(2^m)在最坏情况下是在排除到只剩下最后一个值之后得到结果,所以为 n/(2^m)=1;2^...
  • 计算二分查找函数的时间复杂度,我们需要对代码进行分析:我们用二分查找法查找数据时,查找一次后可以筛去一半的数据,经过一次次的筛选,最后会使得待查数据只剩一个,那么我们查找的次数就是while循环执行的次数...
  • 二分查找时间复杂度计算

    千次阅读 2020-09-17 19:03:11
    第一次二分后,需要继续在n2\frac{n}{2}2n​个元素中进行查找 第二次二分后,需要继续在n22\frac{n}{2^2}22n​个元素中进行查找 最坏的情况下,只剩下一个元素,也就是继续在n2t\frac{n}{2^t}2tn​个元素中进行查找 ...
  • 摘要 本报告介绍了了遍历查找和二分查找两种算法,并用 python 语言将其实现。通过对要查找的数组的大小的变化控制,用 matplotlib 库函数...通过描述可知二分查找的效率是要比遍历查找高的,下面的实验通过时间复杂
  • 二分查找时间复杂度

    千次阅读 2020-08-17 14:22:10
    搜索的几种常见方法:顺序查找、二分法查找、二叉树查找、哈希查找。 2、二分法查找 二分法查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;缺点是要求待查表为有序表,且插入删除困难。因此,折半...
  • (1)请写出Java代码,实现二分搜索(给定一个按升序排列的数组和一个要查找的值,返回该值在数组中的index) (2)说明该算法时间复杂度 (3)如果改成三分搜索,时间复杂度将会是多少?说明与二分搜索相比较是...
  • 二分法查找,也称折半查找,是一种在有序数组中查找特定元素的搜索算法。查找过程可以分为以下步骤: (1)首先,从有序数组的中间的元素开始搜索,如果该元素正好是目标元素(即要查找的元素),则搜索过程结束,...
  • 二分查找时间复杂度计算分析

    千次阅读 2020-01-14 14:48:43
    二分查找二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。   原理:假设表中元素是...
  • 递归 递归条件 ...二分查找对1~100乱序数字查找 l = list(range(1,101)) def bin_search(data_set,val): low = 0 high = len(data_set) - 1 while low <= high: mid = (low+high)//2 if dat...
  • 二分查找时间复杂度的计算(转)

    千次阅读 2018-02-28 10:06:19
    二分查找的基本思想是将n个元素分成大致相等的两部分,去a[n/2]与x做比较,如果x=a[n/2],则找到x,算法中止;如果x&lt; a[n/2],则只要在数组a的左半部分继续搜索x,如果x &gt;a[n/2],则只要在数组a的右半部...
  • 1.问题 写出两种检索算法:在一个排好序的数组T[1…n]中查找x,如果x在T中,...2.二分查找法。 3.伪代码 顺序查找法:for (int i = 0; i < n; i++) { if (T[i] == x) { printf("%d", i); flag = 1; }...
  • 二分查找属于一种简单却高效的算法,时间复杂度是O(logn),在二分查找之前需要先对其进行排序,C++里面的默认是升序,如果需要降序,需要进行一下修改: //C++排序是升序还是降序 //a>b是降序,a<b是升序 ...
  • 二分查找   二分查找又称为折半查找,是一种查询效率比较高的查找方法,但是二分查找的前提是要求线性表必须采用顺序存储结构而且表中元素按照关键字有序排列。 代码如下:   该程序在循环体内的关键在于三路...
  • 二分查找时间复杂度 partition时间复杂度 O(n) = O(n) + O(n/2) + O(n/4)+.... 然后用等比求和公式得出是O(2n),即O(n) 转载于:https://www.cnblogs.com/ymjyqsx/p/11323383.html...
  • 一、时间复杂度:实际是指程序运行次数,而不是程序运行时间1.我们一般讨论的是最坏时间复杂度,这样做的原因是:最坏情况下的时间复杂度是算法在任何输入实例上运行时间的上限,以最坏代表最全。2.时间复杂度的书写...
  • 算法1——二分查找时间复杂度

    千次阅读 2018-04-20 09:29:06
    如何理解二分查找(binary search)?当我们查字典,查电话时,有两种查询方式,一是简单查找,从头开始找,从字母A开始一页一页找;第二种是近似二分查找,如果我们要查询X开头的姓名,势必会直接翻到字典的后半...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,916
精华内容 47,566
关键字:

二分查找时间复杂度