python数据结构与算法学习笔记（二）

排序与搜索

如何从一个数字序列中查找一个特定的目标, 是一个经典的问题. 对于无序序列, 通常只能从头遍历, 这样效率十分低下. 但是当这个序列是有序序列时, 我们可以用二分法来快速找到目标数.

二分查找

顾名思义，二分查找是从有序数列（从小到大）的中间开始，若小于目标数，则在二分的左半部继续查找，反之则在二分的右半部继续查找，直到找到目标数或者新的查找区间为空时停止。
很容易想到，可以用递归方法实现二分查找。

def binary_search(l,item):
    if len(l) == 0:
        return False
    mid = len(l)//2
    if l[mid] == item:
        return True
    else:
        if l[mid]<item:
            return binary_search(l[mid+1:],item)
        else:
            return binary_search(l[:mid-1],item)

递归的方法简单易懂，但是当有序数列过大时，容易导致递归层数过深的问题，而且所有的递归方法都有非递归的实现。下面是二分查找的非递归实现。

def binary_search_noRec(l,item):
    start = 0
    end = len(l)
    mid = end//2
    while start<=end:
        if l[mid]==item:
            return True
        elif l[mid]>item:
            end = mid-1
            mid = (start+end)//2
        else:
            start = mid+1
            mid = (start+end)//2
    return False

非递归方法就是循环判断目标数与当前中值的大小关系，来更新查找的区间以及对应的中值：若当前中值小于目标，则把新查找区间的开头设为当前中值的后一位，结尾不变；若当前中值大于目标，则把新查找区间的结尾设为当前中值的前一位，开头不变。循环的结束条件是新查找区间的开头索引小于结尾索引。

二分查找非常高效，其复杂度为O(logn)，对数复杂度。现在的问题就来到了，如何把一个任意的序列排序成有序的（从小到大排序）。

冒泡排序

冒泡排序的原理是，遍历整个序列，把较大的数一点一点的移动到后面。经过一次遍历，最大的数将会位于末位，经过两次，次大数将会位于倒数第二位，以此类推。因此容易得到冒泡排序的复杂度为O(n^2)，因为执行了一个循环套循环。代码如下。

def bubble_sort(l):
    length = len(l)
    while length>1:
        for i in range(length-1):
            if l[i]>l[i+1]:
                l[i], l[i+1] = l[i+1], l[i]
        length-=1

可以看到，在序列有序后，代码会一直执行，直到循环结束。对于大多数情况，会有时间上的浪费。因此我们可以加一个判据，当某次遍历没有数据的交换位置时，则停止循环。

def short_bubble_sort(l):
    has_changed = True
    length = len(l)
    while length>1 and has_changed:
        has_changed = False
        for i in range(length-1):
            if l[i]>l[i+1]:
                l[i], l[i+1] = l[i+1], l[i]
                has_changed = True
        length-=1

尽管这会提升一点性能，但是总体上的时间复杂度还是O(n^2)，差距不大。