精华内容
下载资源
问答
  • """ 二分查找 """ def search(l,key): low = 0 high = len(l) - 1 while low <= high: mid = (low + high) // 2 if l[mid] < key: low = mid + 1 elif l[mid]...
    """
       二分查找
    """
    def search(l,key):
        low = 0
        high = len(l) - 1
        while low <= high:
            mid = (low + high) // 2
            if l[mid] < key:
                low = mid + 1
            elif l[mid] > key:
                high = mid - 1
            else:
                return mid
        return
    
    l = [1,4,5,6,9,15,35,98,102]
    a = search(l,6)
    print(a,l[a]) #3 6
    
    
    展开全文
  • python实现二分查找

    万次阅读 2017-07-27 17:41:51
    利用二分查找来做,事先需要对列表进行排序,二分查找只对有序表有效 下面是具体的实现: #!usr/bin/env python #encoding:utf-8 ''' __Author__:沂水寒城 功能:二分查找 ''' def binary_search(num_...

    题目:

    输入指定列表和一个待查找的元素,输出元素是否在列表中,若存在则返回下标

    思想:

    利用二分查找来做,事先需要对列表进行排序,二分查找只对有序表有效

    下面是具体的实现:


    #!usr/bin/env python  
    #encoding:utf-8  
      
    '''
    __Author__:沂水寒城 
    功能:二分查找
    ''' 
    
    
    def binary_search(num_list, x):
        '''
        二分查找
        '''
        num_list=sorted(num_list)
        left, right = 0, len(num_list)
        while left < right:
            mid = (left + right) / 2
            if num_list[mid] > x:
                right = mid
            elif num_list[mid] < x:
                left = mid + 1
            else:
                return '待查元素{0}在列表中下标为:{1}'.format(x, mid)
        return  '待查找元素%s不存在指定列表中'%x
    
    
    
    if __name__ == '__main__':
        num_list = [34,6,78,9,23,56,177,33,2,6,30,99,83,21,17]
        print binary_search(num_list, 34)
        print binary_search(num_list, 177)
        print binary_search(num_list, 21)
        print binary_search(num_list, 211)
        print binary_search(num_list, 985)


    结果如下:


    待查元素34在列表中下标为:9
    待查元素177在列表中下标为:14
    待查元素21在列表中下标为:5
    待查找元素211不存在指定列表中
    待查找元素985不存在指定列表中


    展开全文
  • Python通过二分查找,查询有序列表中元素的下标 为什么使用二分查找? 因为二分查找可以快速的查找一个有序列表中的元素 注意:查找的对象必须是一个有序的列表!!!! 代码示例 通过while循环的方式可以...

    Python通过二分查找,查询有序列表中元素的下标

    • 为什么使用二分查找?

      因为二分查找可以快速的查找一个有序列表中的元素
      
      注意:查找的对象必须是一个有序的列表!!!!
      
    • 代码示例

      • 通过while循环的方式可以查询出对应的下标,元素不存在在列表中返回-1,就相当于手动给python列表实现了String(字符串)的find方法。

        (注:代码是在下花了四个小时绞尽脑汁才想出来的,肯定还是有不足的地方,比如每次循环都要判断right-left==1)

      def BinarySearch(item, list):
          '''
          二分查找有序列表中的元素
          :param item: 需要查找的元素
          :param list: 列表
          :return: 查找到返回元素在list中的下标,反之返回-1
          '''
          end_time = False  # 结束时间
          left = 0  # 左下标,初始值为0
          right = len(list)  # 右下标,初始值为列表的长度
          while left < right:
              if right - left == 1:  # 判断是否在做最后一次运算   right - left == 1 表示已经开始进行最后一个元素的判断
                  if end_time == True:
                      return -1  # 没有查找到返回-1
                  end_time = True  # 将end_time改成True,标志着已经开始了最后一次的查找
              mid_site = (left + right) // 2
              if item == list[mid_site]:
                  return mid_site  # 查找到返回对应下标
              elif item > list[mid_site]:
                  left = mid_site  # 如果当前元素大于列表中mid_site下标对应的值,就将mid_site赋值给left
              else:
                  right = mid_site  # 如果当前元素小于列表中mid_site下标对应的值,就将mid_site赋值给right
      
      
      if __name__ == '__main__':
          list01 = [1, 2, 4, 6, 7, 9, 10, 11, 13]
          result01 = BinarySearch(10, list01)
          print(result01)  # 6 ==> 表示10在list01中的下标为6
          result02 = BinarySearch(1000, list01)
          print(result02)  # -1 ==> 表示3在list01中查找不到
      
      • 通过递归的方式–目前本人只实现了判断元素是否在列表中,还没有找到有效的替代方法去替换while循环中的left和right两个变量(有那位大佬想到办法了可以再评论里发表想法)

      def BinarySearch(item, list):
          '''
          二分查找有序列表中的元素
          :param item: 需要查找的元素
          :param list: 列表
          :return: 查找到返回True,反之查找不到返回False
          '''
          # 获取列表的长度赋值给list_length
          list_length = len(list)
          # 判断列表的长度是否大于0
          if list_length > 0:
              # 计算列表中间位置
              mid_site = list_length // 2
              if item == list[mid_site]:  # 判断列表中中间位置是否和需要查找的元素相等
                  return True  # 查找到返回True
              elif item > list[mid_site]:  # 如果需要查找的元素大于列表中间的元素
                  # 继续在列表的后半段中查找该元素
                  # 注意:因为中间位置的元素在上面已经计算过一次,为避免重复的运算
                  # 这里需要去除mid_site对应的
                  return BinarySearch(item, list[mid_site + 1:])
              else:  # 如果需要查找的元素小于列表中间的元素
                  # 在列表的前半段中查找该元素
                  # 因为列表的切片并不包含结尾的元素,所以这里不需要减一
                  return BinarySearch(item, list[:mid_site])
          else:
              return False  # 如果查找不到,返回False
      
      
      if __name__ == '__main__':
          list01 = [1, 2, 4, 6, 7, 9, 10, 11, 13]
          result01 = BinarySearch(9, list01)
          print(result01)
          result02 = BinarySearch(12, list01)
          print(result02)
      
      
    展开全文
  • Python二分查找

    2020-10-11 17:42:45
    Python二分查找 前提条件     存储数据的列表或元组中的数据是排好序了的。 实现 设置两个变量,start和end表示开始坐标和末尾坐标,用来计算数组的中间坐标的值; 当中间值和需要查找的值...

    Python:二分查找

    前提条件

        存储数据的列表或元组中的数据是排好序了的。

    实现

    1. 设置两个变量,start和end表示开始坐标和末尾坐标,用来计算数组的中间坐标的值;
    2. 当中间值和需要查找的值相等的时候,即查找完成;
    3. 当需要查找的值大于中间值的时候,就将start赋值为中间坐标值,然后再次计算中间坐标值,进行比较,这样就实现了“二分”和“查找”;
    4. 当需要查找的值小于中间值的时候,就将end赋值为中间坐标值,然后再次计算中间坐标值,进行比较,这样就实现了“二分”和“查找”。

    细节重点

        计算中间值时一般是:(start+end)//2,但是这样处理的时候需要注意一个容易忽略的点:

    Python中整除运算是向下圆整的

    所以当我们的 start=0 和 end=(列表长度-1) 时,我们列表中的最后一个元素无论怎样都是不会被遍历到的(好好想一下中值的运算和整除向下圆整的规则)


    解决方法:
        将end设置为列表的长度。即人为多设一个位置给列表的最后一个元素去当“替死鬼”。


    代码示例

    x = [1, 2, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 16]
    length = len(x)
    num = int(input('请输要查找的数:'))
    
    
    def erFeng(number, start, end):
        middle = (start + end) // 2
        if x[middle] == number:
            print(middle)
        else:
            if x[middle] > number:
                erFeng(number, start, middle)
            elif x[middle] < number:
                erFeng(number, middle, end)
    
    
    erFeng(num, 0, length)
    

    这里只体现出了问题,更多细节请自己完善。

    展开全文
  • Python实现二分查找

    2020-03-20 14:43:18
    对于包含nnn个元素的列表,用二分查找最多需要log⁡2n\log_2{n}log2​n步,而简单查找最多需要nnn步. 例如:在1-100之间猜数字,假设正确数字是100 简单查找:从1开始顺序查找(最长路径),则最多需要100步,才能找到100; ...
  • 输入一个数,使用二分查找法查找它是否在列表[34,64,67,72,73,82,83,85,87,88,90,91,96,98]中。如果找到,输出此数及其索引值,否则输出”没有找到“的信息。 如果lis[mid]<key,则min=mid+1 如果lis[mid]>key...
  • Python二分查找

    2020-04-19 17:54:15
    二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表...
  • 二分查找二分查找这个概念是非常简单的一个算法,也就是我们俗称的折半查找,原理是在一个有序的数组中,先取中间的值,如果中间值大于或者小于我们需要查找的值,那么就舍弃一般,在另一半中进行查找."...
  • 对于大数据量,则可以用二分查找进行优化。 二分查找要求对象必须有序,其基本原理如下:  1.从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜素过程结束;  2.如果某一特定元素大于或者小于中间元素...
  • python 实现二分查找

    2019-08-16 10:06:37
    二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表...
  • python实现二分查找算法 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法。但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列。 查找又称折半查找,优点是比较...
  • Python实现二分查找

    2021-02-04 21:13:18
    Python来实现二分查找 1、问题需求 输入列表[1,4,4,5,7,7,8,9,9,10]和目标整数1,输出其所在的位置为0,即第1次出现在第0个位置。输入列表[1,2,3,3,4,5,10]和整数目标3,输出2,即第一次出现2的位置。输入列表[1,2...
  • python二分查找

    2018-03-14 12:43:40
    首选,仅当列表是有序的时候,二分查找才有用,函数binary_search 接受一个有序数组和一个元素,规定low=0, high=len(list)-1,那么每次都将检查中间的元素:mid=(high+low)//2 如果(high+low)不是偶数,Python 3...
  • 二分查找算法 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法。 def half_select(): num=random.randint(0,100) # 生成随机数 lists=[i for i in range(1,101)] # 定义一个用于查找的列表 ...
  • python关于二分查找

    2019-02-12 11:54:00
    如果有这样一个列表,让你从这个列表中找到66的位置,你要怎么做? l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] 你说,so easy! l.index(66) 我们之所以用index...
  • python——二分查找

    2019-05-21 08:58:55
    首先将元素存储在列表里,顺序排列。 给定指针pow与hight对应列表起始位置。 - 第一次利用前后指针,找到中间位置元素 中间元素大于所找元素---->让队尾指针指向中间,在前半段再取中间,在再对比查找。 中间...
  • Python-二分查找

    2018-07-21 17:02:00
    解决问题:给定一个有序的列表, 一个待查找的目标值, 判断目标值是否在有序的列表中, 并返回目标值在列表中的索引实现步骤:1. 因为是一个有序的列表, 起始最小值为第一个元素, 起始最大值为最后一个元素2. 取列表的...
  • 二分查找怎么事就不写了,直接上干货 aList=[1,3,5,7,9,11,13,15,17,19] #这个列表得是排好序的 x=int(input('请输入要查找的整数:')) start=0 end=len(aList)-1 #这里start和end是对应数字的下标 while start...
  • Python 二分查找

    万次阅读 2020-06-11 10:20:37
    Python 二分查找法 算法要求 必须采用顺序存储结构 必须按照关键字大小有序排列 复杂度 平均时间复杂度:O(log n) 最坏时间复杂度:O(log n) 最优时间复杂度:O(1) 空间复杂度:O(1) 示例代码 def binary_...
  • Python-二分查找

    2019-03-15 19:47:33
    #二分查找/折半查找 #先排序 list_01.sort() print('首先要对列表进行排序:',list_01) num = int(input('请输入要查找到数:')) frist = 0 last = len(list_01)-1 while frist &lt;= last: mid = (frist+...
  • 算法系列11—python实现二分查找

    千次阅读 2020-05-31 16:01:17
    python实现二分查找 具备条件: 1、顺序列表 最优时间复杂度O(1),最坏为O(logn) 算法思想: 以lst = [1, 3, 7, 8, 10, 11]为例 先有初始比较区间:[0-len(lst)] 第一次比较中间值:7 如果7比待比较的值大,则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 566
精华内容 226
关键字:

python列表二分查找

python 订阅