冒泡排序，快速排序，选择排序，二分查找

'''
冒泡排序原理: 每一趟只能将一个数归位, 如果有n个数进行排序,只需将n-1个数归位, 也就是说要进行n-1趟操作(已经归位的数不用再比较)，每一次都是得到比较列表中最大的数。

冒泡排序算法及其优化
冒泡排序的基本特征是只能交换相邻的元素。
从下边界开始，一趟扫描下来，可以把当前最大值顶到上边界；
如果没有发生交换操作，则表示数组是有序的
'''

def bubble_sort(seq): 
    for i in range(len(seq)-1): #每一趟只能将一个数据归位，所以需要有 len(seq)-1 次循环比较。每一次归位的数为列表中最大的数。
        for j in range(len(seq)-i-1): #每一次循环有 len(seq)-i-1  次比较。  
            if seq[j] > seq[j+1]:  #将相邻的两个数进行比较  
                seq[j], seq[j+1] = seq[j+1], seq[j]  #把数值小的放前面，数值大的放后面.
    return seq


'''
优化冒泡排序：
我们可以假设一种场景，比如 8 1 2 3 5 7，进行一次排序之后，结果就变成了 1 2 3 5 7 8，那我们还有必要再像上面代码里那样继续循环下去吗？肯定没有必要了，因为这已经是最终结果了。
那针对上面的代码，我们优化的点主要在于：假如某一趟排序之后已经有序，我们需要减少排序的趟数。否则就做了很多无用功。
针对这个问题，我们可以考虑在算法中加入一个布尔变量，来标识该轮有没有进行数据的交换，若在某一趟排序中未发现数据位置的交换，则说明待排序的无序区中所有的项均已满足排序后的结果。那么就没有必要再次排序下去了。可以如下改造：
'''
def bubble_sort(seq):
    for i in range(len(seq)-1):  #for i in range(len(seq)-1, 0, -1):
        swap_flag = False  #设置一个标识，假设先让他为False
        for j in range(len(seq)-i-1):  #for j in range(i):
            if seq[j] > seq[j+1]:  #如果程序执行以下代码，说明数据发生了交换。
                seq[j], seq[j+1] = seq[j+1], seq[j]
                swap_flag = True
        if not swap_flag:
            return seq
    return seq

'''
这样就优化完了，其实代码逻辑很简单，通过一个布尔变量即可监控一趟过程有没有进行数据交换。
'''

'''
选择排序：(每次得到最小值)
选择排序比较好理解，好像是在一堆大小不一的球中进行选择（以从小到大，先选最小球为例）：
　　1. 选择一个基准球
　　2. 将基准球和余下的球进行一一比较，如果比基准球小，则进行交换
　　3. 第一轮过后获得最小的球
　　4. 在挑一个基准球，执行相同的动作得到次小的球
　　5. 继续执行4，直到排序好
'''


def selected_sort(seq):
    '''
    选择排序
    :param seq:
    :return:
    '''
    swap_flag = False
    for i in range(len(seq)-1):
        index = i
        for j in range(i+1, len(seq)):
            if seq[index] > seq[j]:
                index = j
                seq[i], seq[index] = seq[index], seq[i]
                index = i
                swap_flag = True
        if not swap_flag:
            return seq
    return seq

'''
快速排序
'''

# 使用递归
def quick_sort(seq):
    if seq == []:
        return []
    else:
        pivot = seq[0]
        lesser = quick_sort([x for x in seq[1:] if x < pivot])
        greater = quick_sort([x for x in seq[1:] if x >= pivot])
        return lesser + [pivot] + greater

'''
二分查找法：递归方法
'''

def binary_chop(alist, data):
    n = len(alist)
    if n < 1:
        return False

    mid = n // 2
    if alist[mid] > data:
        # Python 中的切片 alist[0:mid] 从0开始，到mid，但是不包括mid
        return binary_chop(alist[0:mid], data)
    elif alist[mid] < data:
        return binary_chop(alist[mid+1:], data)
    else:
        return True