算法导论——二分查找

Posted 2021-04-10 代码综合征

二分查找

对于一个已排序的序列，可以从序列的中点开始与给定的值进行比较，根据比较的结果，序列中可以有一半不做考虑。

二分查找重复这个过程，每次都将序列剩余部分的规模减半。二分查找最坏情况运行时间为θ(lgn)。

 
   
   
 

  
    
    
  
def binary_search(data_set, val):
  
    
    
  
    low = 0
  
    
    
  
    high = len(data_set) - 1
  
    
    
  
    while low <= high:
  
    
    
  
        mid = (low + high) // 2
  
    
    
  
        if data_set[mid] == val:
  
    
    
  
            return mid
  
    
    
  
        elif data_set[mid] > val:
  
    
    
  
            high = mid - 1
  
    
    
  
        else:
  
    
    
  
            low = mid + 1
  
    
    
  
    return
 
   
   
 

插入排序用二分查找的改进

插入排序算法可以使用二分查找来改进。可以将其最坏情况运行时间改进到θ(nlgn)。

 
   
   
 

  
    
    
  
def insertion_sort_binary_search(a):
  
    
    
  
    for j in range(1, len(a)):
  
    
    
  
        key = a[j]
  
    
    
  
        left = 0
  
    
    
  
        right = j - 1
  
    
    
  
        while left <= right:
  
    
    
  
            middle = (right + left) // 2
  
    
    
  
            if a[middle] > key:
  
    
    
  
                right = middle - 1
  
    
    
  
            else:
  
    
    
  
                left = middle + 1
  
    
    
  
        i = j - 1
  
    
    
  
        while i > right:
  
    
    
  
            a[i + 1] = a[i]
  
    
    
  
            i = i - 1
  
    
    
  
        a[right + 1] = key
 
   
   
 

寻找是否存在两数之和等于目标数

需要一个运行时间为θ(nlgn)的算法，给定n个整数的集合S和另一个整数x，确定S中是否存在两个数的和刚好为x的元素。

使用二分查找是可以得到θ(nlgn)的最坏情况运行时间。但是实际这个问题还有另一个更好的算法。使用哈希表能够使其达到θ(n)的时间。

 
   
   
 

  
    
    
  
def find_sum_target(self, nums, target):
  
    
    
  
    dic=dict()
  
    
    
  
    for index, value in enumerate(nums):
  
    
    
  
        if target-value in dic:
  
    
    
  
            return [dic[target-value],index]
  
    
    
  
        else:
  
    
    
  
            dic[value]=index
 
   
   
 

在归并排序中对小数组采用插入排序

尽管合并排序的最坏情况运行时间为θ(nlgn)，插入排序的最坏情况运行时间为θ(n^2)，但插入排序中的常数因子使得它在n较小时，运行得要更快一些。

因此，在合并排序算法中，当子问题足够小时，采用插入排序就比较合适了。

考虑对合并排序做这样的修改，即采用插入排序策略，对n/k个长度为k的子列表进行排序，然后，再用标准的合并机制将它们合并起来，此处k是一个特定的值。

n/k个子表的插入排序最坏情况时间为θ(nk)，最坏情况合并时间为θ(nlg(n/k))。

在实践中，在满足插入排序比合并排序更快的情况下，k取最大值。

冒泡排序

解决桶排序空间的问题，但是效率太低。

 
   
   
 

  
    
    
  
def bubbleSort(nums):
  
    
    
  
    for i in range(len(nums)-1):    # 这个循环负责设置冒泡排序进行的次数
  
    
    
  
        for j in range(len(nums)-i-1):  # ｊ为列表下标
  
    
    
  
            if nums[j] > nums[j+1]:
  
    
    
  
                nums[j], nums[j+1] = nums[j+1], nums[j]
  
    
    
  
    return nums