二分查找

以下内容是个人学习笔记的整理。

原理：
每次查找后，查找范围都折半，一步步缩小查找范围，直到找到要查找的元素。

步骤：

1. 初始化头尾指针，并计算出中间下标；
2. 中间下标所对应的元素与目标值对比，如果刚好等于目标值，则返回；
3. 如果大于目标值，则左指针更新为中间下标+1；
4. 如果小于目标值，则右指针更新为中间下标-1；
5. 如果遍历完整个序列都没有找到，返回-1。

实现代码（python）:

# -*- conding:utf-8 -*-

class Binary_Search(object):
    
    def Simple_Search(self, alist, target):
        '二分查找，适应于没有重复元素序列的查找'
        low = 0
        high = len(alist) - 1
        while low <= high:
            if alist[low] == target:
                return low
            elif alist[high] == target:
                return high   
            mid = low + (high - low) // 2
            if alist[mid] == target:
                return mid 
            elif alist[mid] < target:
                low = mid + 1
            else:
                high = mid - 1
            
        return -1
    
    
    def SearchFirstElement(self, alist, target):
        '二分查找，查找第一次出现的目标元素'
        low = 0
        high = len(alist) - 1
        while low <= high:  
            mid = low + (high - low) // 2
            if alist[mid] > target:
                high = mid - 1
            elif alist[mid] < target:
                low = mid + 1
            else:
                if mid == 0 or alist[mid - 1] != target:
                    return mid
                else:
                    high = mid -1        
        return -1
    
    
    def SearchLastElement(self, alist, target):
        '二分查找，查找最后出现的目标元素'
        low = 0
        high = len(alist) - 1
        while low <= high:  
            mid = low + (high - low) // 2
            if alist[mid] > target:
                high = mid - 1
            elif alist[mid] < target:
                low = mid + 1
            else:
                if mid == (len(alist) - 1) or alist[mid + 1] != target:
                    return mid
                else:
                    low = mid + 1        
        return -1     
    
    
    def SearchFirstGreater(self, alist, target):
        '二分查找，查找第一个大于等于目标值的元素'
        low = 0
        high = len(alist) - 1
        while low <= high:  
            mid = low + (high - low) // 2
            if alist[mid] >= target:
                if mid == 0 or alist[mid - 1] < target:
                    return mid
                else:
                    high = mid - 1
            else:
                low = mid + 1            
        return -1    
    
    
    def SearchLastGreater(self, alist, target):
        '二分查找，查找最后出现的小于等于目标的元素'
        low = 0
        high = len(alist) - 1
        while low <= high:  
            mid = low + (high - low) // 2
            if alist[mid] <= target:
                if mid == (len(alist) - 1) or alist[mid + 1] > target:
                    return mid
                else:
                    low = mid + 1
            else:
                high = mid -1        
        return -1

复杂度分析：
-时间复杂度
–最优时间复杂度：O(1)
–最坏时间复杂度：O(logn)
–平均时间复杂度：O(logn)

适应范围：

1. 有序序列；
2. 使用顺序表存储的数据；
3. 数据量太大不适合，因为顺序表需要连续的内存空间。