冒泡/选择排序与二分查找

排序

冒泡排序

相邻比较，逆序交换

# 如果某一趟排序，没有 发送任何 交换， 证明数据已经有序， 可以结束排序
def bubble_sort(alist):
    n = len(alist)  # 列表中元素个数
    
    # 冒泡排序， n个数字需要 排序 (n-1) 趟
    for i in range(1, n):
        
        # 在每一趟排序之前，设置一个标志
        flag = False
        
        for j in range(0, n - i):  # 每一趟排序结束之后，就减少一个需要比较的元素
            
            if alist[j] > alist[j + 1]:  # 相邻比较，逆序交换
                alist[j], alist[j + 1] = alist[j + 1], alist[j]
                
                # 发生交换，改变标志
                flag = True
                
        if flag is False:
            # 说明这一趟排序没有发生任何交换
            break
            
    return alist


alist = [2, 5, 8, 11]
r = bubble_sort(alist)
print(r)

• n个元素，需要 n-1 趟排序
• 如果一趟排序中， 没有 发生 任何 交换， 说明 数据 已经 有序， 可以结束 排序过程

装饰器中实现 冒泡排序

# 定义一个函数， 接收一个列表作为参数，返回一个列表
# 定义一个装饰器，在装饰器中对列表进行排序， 使用冒泡升序排序

# self 一般用在 类中的实例方法里的形参，指实例化对象本身
# cls  一般用在类方法里的形参，指类本身

def outer(func):
    def inner(alist):
        # 在装饰器中 对 参数 升序排序
        n = len(alist)
        for i in range(1, n):  # n个元素比较 n-1 趟
            for j in range(0, n - i):  # 需要比较的数字下标
                if alist[j] > alist[j + 1]:  # 相邻比较，逆序交换
                    alist[j], alist[j + 1] = alist[j + 1], alist[j]
                    
        r = func(alist)

        return r

    return inner


@outer
def func(alist):
    return alist


r = func([1, 4, 2, 9])
print(r)

选择排序

每一趟找到一个最小值，然后和 假设的 那个最小值 交换

def select_sort(alist):
    
    n = len(alist) # n个元素
    
    for i in range(1, n):  # n-1 趟排序
        
        # 第 i 趟 排序
        min_index = i - 1  # 假设 最小值 下标

        for j in range(i, n):
            # 在后面的数字中，如果出现一个比假设的最小值还要小的数字, 也就是说  如果 alist[j] 更小
            if alist[min_index] > alist[j]:
                # 只更新最小值下标，保证 min_index 存的 始终是真正的最小值下标
                min_index = j

        # 说明后面有比假设的最小值 还小的数字, 把 假设的最小值和 真正的最小值 交换
        if min_index != i - 1:
            alist[i - 1], alist[min_index] = alist[min_index], alist[i - 1]

    return alist


alist = [2, 7, 5, 4, 2]

alist = select_sort(alist)

print(alist)

二分查找(折半查找)

查找： 在 一定的范围内，判断 某个元素 是否存在

折半查找的前提是: 数据已经有序

## 前提是数据有序，且为 升序

def find(num, alist):
    n = len(alist)
    
    start = 0  # 开始下标
    end = n - 1  # 结束下标

    # 始终保证 开始的下标 不能大于 结束的下标
    while start <= end:

        mid = (start + end) // 2  # 中间值下标

        if num > alist[mid]:
            # 如果比中间值元素 大， 去中间值之后的范围查找， 开始的下标需要更新为 mid+1
            start = mid + 1

        elif num < alist[mid]:
            # 如果比中间值元素 小， 去中间值之前的范围查找， 结束的下标需要更新为 mid-1
            end = mid - 1

        else:
            # 中间值和要查找的数字 正好相等
            return True
	
    # 如果循环走完，也没有找到，返回False
    return False


alist = [1, 5, 7, 23]
num = 77

r = find(num, alist)
print(r)

---