基于python常用排序与查找

"""
排序与查找
    -- 冒泡排序
    -- 选择排序
    -- 快速排序 --****经典
    -- 希尔排序
"""
# 常用排序的实现

# 冒泡排序-每轮排出最大 时间复杂度O(n**2)
def bubble(list_):
    if list_: # 非空列表排序
        # 外层表示比较轮数
        for i in range(len(list_)-1):
            # 表示每轮两两比较的次数
            for j in range(len(list_)-1-i):
                if list_[j] > list_[j+1]:
                    list_[j],list_[j+1] = list_[j+1],list_[j]
    else: # 空列表报异常
        raise ValueError

# 选择排序
def select_sort(list_):
    # 外侧循环n-1轮
    for i in range(len(list_)-1):
        # 假设list_[i]最小
        min = i
        for j in range(i+1,len(list_)):
            if list_[min] > list_[j]:
                # 擂主换人
                min = j
        #进行交换，将最小值换到应该在的位置
        if min != i:
            list_[i],list_[min] = list_[min],list_[i]

# 插入排序
def insert_sort(list_):
    # 外侧循环n-1轮,每次比较的数，从第二个数开始
    for i in range(1,len(list_)):
        # 空出list_[i]的位置
        x = list_[i]
        j = i-1
        while j >= 0 and list_[j] > x:
            list_[j+1] = list_[j]
            j -= 1
        list_[j +1] = x

# 完成一轮交换
def sub_sort(list_,low,high):
    # 选定基准
    x = list_[low]
    # low 向后，high向前
    while low < high:
        # 后面的数前放
        while list_[high] >= x and high > low:
            high -= 1
        list_[low] = list_[high]
        # 前面数后放
        while list_[low] < x and low < high:
            low += 1
        list_[high] = list_[low]
    list_[low] = x


# 快速排序(升序) # low,high = 0,len(list01)-1
# low表示列表的第一个元素索引，high表示最后一个元素索引
def quick_sort(list_,low,high):
    """
    1.取出0号元素，赋值，从列表尾部开始比较，
        只要比较出比该值小的，被比较的值放头部，
            赋值值放那个移动额位置
    2.因第一次比较，分出大于原0号元素和小于0号
        元素的两部分数，两部分数分别重复1,2
    3.直到比较完，结束
    :return:
    """
    if low < high:
        sub_sort(list_,low,high)

#快排的主函数，传入参数为一个列表，左右两端的下标
def QuickSort(list,low,high):
    if high > low:
        #传入参数，通过Partitions函数，获取k下标值
        k = Partitions(list,low,high)
        #递归排序列表k下标左侧的列表
        QuickSort(list,low,k-1)
        # 递归排序列表k下标右侧的列表
        QuickSort(list,k+1,high)

def Partitions(list,low,high):
    left = low
    right = high
    #将最左侧的值赋值给参考值k
    k = list[low]
    #当left下标，小于right下标的情况下，此时判断二者移动是否相交，若未相交，则一直循环
    while left < right :
        #当left对应的值小于k参考值，就一直向右移动
        while list[left] <= k:
            left += 1
        # 当right对应的值大于k参考值，就一直向左移动
        while list[right] > k:
            right = right - 1
        #若移动完，二者仍未相遇则交换下标对应的值
        if left < right:
            list[left],list[right] = list[right],list[left]
    #若移动完，已经相遇，则交换right对应的值和参考值
    list[low] = list[right]
    list[right] = k
    #返回k值
    return right

# 二分查找(有序数组)
def binary_search(list_,key):
    low, high = 0,len(list_)-1
    # 判断条件
    while low < high:
        mid = (low+high) // 2
        if list_[mid] < key:
            low = mid + 1
        elif list_[mid] > key:
            high = mid -1
        else:
            return mid


list02 = [1,2,3,4,5,6,7,8,9,10]
print("key index:",binary_search(list02,8))

# list_demo = [6,1,2,7,9,3,4,5,10,8]
# print(list_demo)
# QuickSort(list_demo,0,9)
# print(list_demo)

#----------------------------
# if __name__ == "__main__":
#     print("-"*30)
#     list01 = [5,2,57,12,4,9,40,25,3]
#     # bubble(list01)
#     #print(list01)
#     print(sub_sort(list01,0,8))
#     print(list01)