python数据结构课堂笔记5：排序与查找

排序与查找

查找算法

顺序查找

如果数据项保存在列表这样的集合中，我们会称这些数据项具有线性或者顺序关系
在python list中，这些数据项的存储位置称为下标（index）,这些下标都是有序的整数
通过下标，我们就可以按照顺序来访问和查找数据项，这种技术叫做“顺序查找”

• 要确定列表中是否存在需要查找的数据项
  首先从列表的第一个数据项开始，
  按照下标增长的顺序，逐个比对数据项
  如果到最后一个都未发现要查找的项，那么查找失败

无序表中进行顺序查找：

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))
print(sequentialSearch(testlist, 13))

算法分析

要对查找算法进行分析，首先要确定其中的计算步骤
基本计算步骤必须足够简单，并且在算法中反复执行
在查找算法中，这种基本步骤就是进行数据项的比对
当前数据项等于还是不等于要查找的数据项，比对的次数决定了算法复杂度

在顺序的查找算法中，为了保证是讨论的一般情况，需要假定列表中的数据项并没有按值排序，而是随机放置在表中的各个位置。
即，数据项在列表中各处出现的概率是相同的。

• 数据项是否存在列表中，比对次数是不一样的。
  • 如果数据项不在列表中，需要比对数据项才能得知，比对次数是n。
  • 如果数据项在列表中，要比对的次数，其情况就比较复杂。
    • 最好的情况是，第一次比对就找到
    • 最坏的情况是，要n次比对。

数据项在列表中各个位置出现的概率是相同的，平均情况下，比对的概率是n/2.
顺序查找的算法复杂度是O(n)。

顺序查找无序表复杂度：

Case	Best Case	Worst Case	Average Case
item is present	1	n	n/2
item is not present	n	n	n

如果对数据项排序：
当数据项存在时，比对过程与无序表完全相同
不同之处在于，当数据项不存在时，比对可以提前结束，即当比对到较大的数时，可直接返回
有序表查找：

def orderedSequentialSearch(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 = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(orderedSequentialSearch(testlist, 3))
print(orderedSequentialSearch(testlist, 13))

顺序查找有序表复杂度：

Case	Best Case	Worst Case	Average Case
item is present	1	n	n/2
item is not present	1	n	n/2

实际上，就算法复杂度而言，仍然是O(n)
只是在数据项不存在的时候，有序表的查找能节省一些比对次数，但并不改变其数量级

二分查找

• 1.对于有序表，更好的查找算法，从列表中间开始比对：
  • 1.如果列表中间的项匹配查找项，则查找结束
  • 2.如果不匹配，那么就有两种情况：
    • 列表中间项比查找项大，那么查找项只可能出现在前半部分
    • 列表中间项比查找项小，那么查找项只可能出现在后半部分
  • 如论如何，我们都会将比对范围缩小为原来的一般：n/2
• 2.继续采用上面的方法查找，每次都会将比对范围缩小一半

二分查找代码实现：

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

    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 = [0, 1, 2, 8, 13, 17, 19, 32, 42,]#必须排好序
print(binarySearch(testlist, 3))
print(binarySearch(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)

testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binarySearch(testlist, 3))
print(binarySearch(testlist, 13))

算法分析

由于二分查找，每次比对都将下一步的比对范围缩小一半
每次比对后剩余数据项如下表所示

Comparisons	Approximate Number of Items Left
1	n/2
2	n/4
3	n/8
…
i	n/(2**i)

当比对次数足够多的时候，比对范围内就会仅剩1个数据项
无论这个数据项是否匹配查找项，比对最终都会结束：
即i = log2(n)
二分查找的算法复杂度为：O(log n)
如果使用递归来求解，那么就会调用列表切片（binarySearch(alist[:midpoint],item)）
切片操作的复杂度为O(k),这样会使整个算法的时间复杂度增加
也可以不用切片

虽然二分查找在时间复杂度上优于顺序查找，但也要考虑对数据项进行排序的开销
如果一次排序后可进行多次查找，那么排序的开销就可以摊薄
如果数据集经常变动，查找次数相对较少，那么可能还是直接用无序表加上顺序查找合适
算法的选择需要考虑实际应用

排序算法

冒泡排序和选择排序算法

冒泡排序Bubble Sort

冒泡排序的算法思路在于对无序表进行多趟比较交换
每趟包含了多次两两相邻比较，并将逆序的数据项互换位置，最终将本趟的最大项就位
经过n-1趟比较交换，实现整表排序
每趟的过程类似于“气泡”在水中不断上浮到水面的过程

• 第一趟比较交换，共有n-1对相邻数据进行比较
  一旦经过最大项，则最大项会一路交换到最后一项
• 第二趟比较交换时，最大项已经就位，需要排序的数据减少为n-1，共有n-2对相邻数据进行比较
• 直到第n-1趟完成后，最小项一定在列表首位，就无需再处理

def bubbleSort(alist):
    for passnum in range(len(a