查找算法

要点概论：

1. 顺序查找法

2. 二分查找法

附录1. python语言提供的查找算法

　　

1. 顺序查找法

　　查找算法是在程序设计中最常用到的算法。假定要从 n 个元素中查找 x 的值是否存在，最原始的办法是从头到尾逐个查找，这种查找方法称为顺序查找法。

　　顺序查找算法有三种情形可能发生：最好的情况下，第一项就是要找的数据对象，只有一次比较；最差的情况下，需要 n 次比较，全部比较完之后查不到数据；平均情况下，比较次数为 n/2 次。即算法的复杂度为 O(n)。

　　1）在列表中顺序查找特定数值 x 。

def sequentialSearch(alist,item):
    pos = 0           #初始查找位置
    found = False     #未找到数据对象
    while pos < len(alist) and not found:        #列表未结束并且还未找到则一直循环
        if alist[pos] == item:                   #找到匹配对象，返回True
            found = True
        else:         #否则查找位置 + 1
            pos = pos + 1
    return found

def main():
    testlist = [1,3,33,8,24,52,15,6]          #测试数据列表
    print(sequentialSearch(testlist,3))       #查找数据3
    print(sequentialSearch(testlist,13))      #查找数据13

if __name__ == '__main__':
    main()
# 程序运行结果如下：
#         True
#         False

 　　2）在列表中顺序查找最大值和最小值。

def maxl(alist):                #查找最大值
    pos = 0                     #初始查找位置
    iMax = alist[0]             #假设第一个值最大
    while pos < len(alist):    #在列表中循环
        if alist[pos] > iMax:  #如果列表当前值大于最大值iMAX
            iMax = alist[pos]  #则当前值未最大值iMax
        pos += 1               #查找位置 + 1
    return iMax               #返回最大值
def minl(alist):               #查找最小值
    iMin = alist[0]            #假设第一个值最小
    for item in alist:        #遍历列表中每个数值
        if item < iMin:       #如果列表当前值小于最小值iMin
            iMin = item       #则当前值为最小值iMin
    return iMin              #返回最小值

def main():
    testlist = [1,2,4,2,12,5,232,65,2,756,123]      #测试数据列表
    print('最大值 = ',maxl(testlist))              #查找并打印列表中最大值
    print('最小值 = ',minl(testlist))              #查找并打印列表中最小值
if __name__ == '__main__':
    main()
#  程序运行结果如下：
    #最大值 = 756
    #最小值 = 1

2. 二分查找法

　　二分查找法又称折半查找法，用于预排序列表的查找问题。

　　【要在排序列表 a 中查找元素 t ，首先，将列表 alist 中间位置的项与查找关键字 t 比较，如果两者相等，则查找成功；否则利用中间项将列表分成前，后两个子表，如果中间位置项目大于 t ，则进一步查找前一子表，否则进一步查找后一子表。

　　　重复以上过程，直到找到满足条件的记录，即查找成功；或直到子表不存在为止，即查找不成功】。

　　对于包含 N 个元素的表，其时间复杂度为 O(㏒₂N)。

　　1）二分查找法的递归实现

def _binarySearch(key,a,low,high):
    if high <= low: return -1                 #查找失败，返回 -1
    mid = (low + high) // 2                   #计算中间位置
    if a[mid] > key:                          #中间位置项目大于查找关键字
        return _binarySearch(key,a,low,mid)   #递归查找前一子表
    elif a[mid] < key:                        #中间位置项目小于查找关键字
        return _binarySearch(key,a,mid+1,high)#递归查找后一子表
    else:                                     #中间位置项目等于查找关键字
        return mid                            #查找成功，返回下标位置
def binarySearch(key,a):                      #二分查找
    return _binarySearch(key,a,0,len(a))      #递归二分查找法
def main():
    testlist = [1,2,3,23,33,54,77]            #测试数据列表
    print('关键字位于列表索引',binarySearch(33,testlist))  #二分查找关键字33
    print('关键字位于列表索引',binarySearch(58,testlist))  #二分查找关键字58

if __name__ == '__main__':
    main()
#程序运行结果如下：
    # 关键字位于列表索引   4
    # 关键字位于列表索引  -1

　　2）二分查找法的非递归实现

def binarySearch(key,a):          #二分查找法的非递归实现
    low = 0                       #左边界
    high = len(a) - 1             #右边界
    while low <= high:            #左边界小于右边界，则循环
        mid = (low + high) // 2   #计算中间位置
        if a[mid] < key:          #中间位置项目小于查找关键字
            low = mid + 1         #调整左边界（在后一子表查找）
        elif a[mid] > key:        #中间位置项目大于查找关键字
            high = mid -1         #调整右边界（在前一子表查找）
        else:                     #中间位置项目等于查找关键字
            return mid            #查找成功，返回下标位置
    return -1                     #查找不成功（不存在关键字），返回 -1
def main():
    testlist = [1,13,26,28,33,46,48,77,99]    #
    print('关键字位于列表索引',binarySearch(33,testlist))  #
    print('关键字位于列表索引',binarySearch(58,testlist))  #
if __name__ == '__main__':
    main()
#程序运行结果如下：
    # 关键字位于列表索引   4
    # 关键字位于列表索引  -1

 　　PS: 另一种思路的二分查找算法 ：http://www.cnblogs.com/Eva-J/articles/7197403.html

附录1：python语言提供的查找算法

　　python语言提供了下列查找算法。

　　　　1）运算符 in ："x in alist" 测试值 x是否在列表 alist 中存在。

　　　　2）内置函数 max , min：查找列表的最大值和最小值。

　　示例如下：

testlist = [1,3,44,5,2,55,534,23,77]

>>>3 in testlist     #True

>>>13 in testlist    #False  

>>>max(testlist)     #534

>>>min(testlist)     #1