python数据结构与算法学习之顺序与查找

顺序查找

• 在Python List中，数据项的存储位置称为下标（index），这些下标都是有序的整数。通过下标，我们就可以按照顺序来访问和查找数据项，这种技术称为“顺序查找”。
• 顺序查找是从列表中的第一个数据项开始。按照下标增长的顺序，逐个比对数据项，如果到最后一个都未发现要查找的项，那么查找失败。

1. 顺序查找：无序表查找代码
算法复杂度是O(n)

def sequentialSearch(alist, item):
    pos = 0
    found = False
    
    while pos < len(alist) and not found:
        if alist[pos] == item:
            found = True
        else:
            pos = pos + 1   # 下标顺序增长
   
    return found

testlist = [1,2,32,8,17,19,42,13,0]
print(sequentialSearch(testlist,3)) # False
print(sequentialSearch(testlist,13)) # True

2. 顺序查找：有序表查找代码
当数据项存在时，查找有序表和无序表的方法完全相同。但是当数据项不在表中时，有序表可以提前结束。
算法复杂度仍然是O(n), 只是在数据项不存在的时候，有序表的查找能节省一些比对次数，但并不改变其数量级。

def sequentialSearch(alist, item):
    pos = 0
    found = False
    stop = False
    while pos < len(alist) and not found and not stop:
        if alist[pos] == item:
            found = True
        else:
            if alist[pos] > item:
                 stop = True  # 提前退出
        else:
            pos = pos + 1   # 下标顺序增长
   
    return found

testlist = [1,2,32,8,17,19,42,13,0]
print(sequentialSearch(testlist,3)) # False 只需要比对4次，少于无序表
print(sequentialSearch(testlist,13)) # True

二分法查找

二分法利用有序表的特性，缩小待比对数据项的范围。从列表中间开始比对，如果列表中间的项匹配查找项，则查找结束如果不匹配，那么就有两种情况：

• 列表查找项比中间项小，那么查找项只可能出现在前半部分
• 列表查找项比中间项大，那么查找项只可能出现在后半部分

无论如何，我们都会将比对范围缩小到原来的一半：n/2
继续采用上面的方法查找，每次都会将比对范围缩小一半

def binarySearch(alist, item):
    found = False
    first = 0
    last = len(thelist) - 1

    while first <= last and not found:
        midpoint = (first + last) // 2 # // 是除法取整数
        if alist[midpoint] == item:  # 中间项比对
            found = True  
        else:
            if item < alist[midpoint]:  # 缩小比对范围
                 last = midpoint - 1
            else first = midpoint + 1
    return found
    
testlist = [1,2,32,8,17,19,42,13,0]
print(sequentialSearch(testlist,3)) 
print(sequentialSearch(testlist,13))

二分查找算法实际上体现了解决问题的典型策略：分而治之

• 将问题分为若干更小规模的部分
• 通过解决每一个小规模部分问题，并将结果汇总得到原问题的解

二分查找的递归算法

def binarySearch(alist, item):
    if len(alist) == 0:
        return False  # 结束条件
    else:
        midpoint = len(alist) // 2 
        if alist[midpoint] == item:  # 中间项比对
            return True  
        else:
            if item < alist[midpoint]:  # 缩小规模
              return binarySearch(alist[:midpoint],item) #调用自身
            else:
              return binarySearch(alist[midpoint+1:],item)

当比对次数足够多以后，比对范围内就会仅剩余1个数据项
n / 2 ^ i = 1
i = $lo{g}_{2}n$
二分法查找的算法复杂度是O(log n)

另外，虽然二分查找在时间复杂度上优于顺序查找,但也要考虑到对数据项进行排序的开销。换句话说，二分查找需要先排序，会更麻烦一点。

冒泡排序和选择排序

冒泡排序Bubble Sort

• 冒泡排序的算法思路在于对无序表进行多趟比较交换，每趟包括了多次两两相邻比较，并将逆序的数据项互换位置，最终能将本趟的最大项就位，经过n-1趟比较交换，实现整表排序。
• 第1趟比较交换，共有n-1对相邻数据进行比较，一旦经过最大项，则最大项会一路交换到达最后一项。
• 第2趟比较交换时，最大项已经就位，需要排序的数据减少为n-1，共有n-2对相邻数据进行比较，直到第n-1趟完成后，最小项一定在列表首位，就无需再处理了。
  

def bubbleSort(thelist):
    for i in range(len(thelist) - 1): # 一共有n - 1趟对比
        for j in range(len(thelist) - 1 - i): # 一趟对比n - i次
            if thelist[j] > thelist[j + 1]:
                temp = thelist[j]     
                thelist[j] = thelist[j + 1]
                thelist[j + 1] = temp
   # 交换值 也可以写成 alist[j],alist[j+1]=alist[j+1],alist[j]
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
bubbleSort(alist)
print(alist)

算法分析：
一共对比n - 1趟
对比次数从n - 1 到 1次
对比的总次数是 1 + 2 +。。。 + n - 1 = $0.5n^2-0.5n$
时间复杂度是$O（n^2）$

• 最好的情况是列表在排序前已经有序，交换次数为0
• 最差的情况是每次比对都要进行交换，交换次数等于比对次数
• 平均情况则是最差情况的一半

冒泡排序通常作为时间效率较差的排序算法，来作为其它算法的对比基准。其效率主要差在每个数据项在找到其最终位置之前，必须要经