python_内部排序 二分查找

Task3

【排序】

• 实现归并排序、快速排序、插入排序、冒泡排序、选择排序
• 编程实现 O(n) 时间复杂度内找到一组数据的第 K 大元素

【二分查找】

• 实现一个有序数组的二分查找算法
• 实现模糊二分查找算法（比如大于等于给定值的第一个元素）

【内部排序】

归并排序：

def MergeSort(MyList):
    length = len(MyList)
    if length <= 1:
        return MyList
    mid = length // 2
    left_li = MergeSort(MyList[:mid])
    right_li = MergeSort(MyList[mid:])

    left, right = 0, 0
    result = []

    while left < len(left_li) and right < len(right_li):
        if left_li[left] <= right_li[right]:
            result.append(left_li[left])
            left += 1
        else:
            result.append(right_li[right])
            right += 1
    result += left_li[left:]
    result += right_li[right:]

    return result


li = [56, 88, 12, 62, 54, 79, 32, 11, 96]
print(*li)
li = MergeSort(li)
print(li)

快速排序：

def QuickSort(MyList, first, last):
    # first：索引值  last：索引值
    if first > last:
        return
    mid_value = MyList[first]
    low = first
    high = last
    while low < high:
        while low < high and MyList[high] > mid_value:
            high -= 1
        MyList[low] = MyList[high]

        while low < high and MyList[low] < mid_value:
            low += 1
        MyList[high] = MyList[low]
    MyList[low] = mid_value
    QuickSort(MyList, first, high-1)
    QuickSort(MyList, high+1, last)


li = [56, 88, 12, 62, 54, 79, 32, 11, 96]
print(*li)
QuickSort(li, 0, 8)
print(li)

插入排序：

def InsertSort(Mylist):
    length = len(Mylist)
    for i in range(1, length):
        for j in range(i, 0, -1):
            if Mylist[j] < Mylist[j-1]:
                Mylist[j], Mylist[j-1] = Mylist[j-1], Mylist[j]
            else:
                break


li = [56, 88, 12, 62, 54, 79, 32, 11, 96, 43124, 4231, 32123, 342, 3453, 12, 313, 23, 43]
print(*li)
InsertSort(li)
print(li)

冒泡排序：

def BubbleSort(MyList):
    length = len(MyList)
    for i in range(length-1):
        count = 0
        for j in range(length-1-i):
            if MyList[j] > MyList[j+1]:
                MyList[j], MyList[j+1] = MyList[j+1], MyList[j]
                count += 1
        if count == 0:
                break


li = [56, 88, 12, 62, 54, 79, 32, 11, 96]
print(*li)
BubbleSort(li)
print(li)

选择排序：

def SelectSort(Mylist):
    length = len(Mylist)
    for i in range(length-1):
        for j in range(i+1, length):
            if Mylist[i] > Mylist[j]:
                Mylist[i], Mylist[j] = Mylist[j], Mylist[i]


li = [56, 88, 12, 62, 54, 79, 32, 11, 96]
print(*li)
SelectSort(li)
print(li)

O(n)时间复杂度内查找第K大元素：

def FindK(MyList, first, last, K):
    # first：索引值  last：索引值
    if first >= last:
        return
    mid_value = MyList[first]
    low = first
    high = last
    while low < high:
        while low < high and MyList[high] > mid_value:
            high -= 1
        MyList[low] = MyList[high]
        while low < high and MyList[low] < mid_value:
            low += 1
        MyList[high] = MyList[low]
    MyList[low] = mid_value
    if len(MyList[low+1:]) > K[0]:
        FindK(MyList, high+1, last, K)
    elif len(MyList[:low]) < K[0]:
        FindK(MyList, first, high-1, K)
    else:
        K[0] = mid_value
        return


K = [1]
li = [56, 88, 12, 62, 54, 79, 32, 11, 96]
print(*li)
FindK(li, 0, 8, K)
print(*K)

【二分查找】

二分查找：

def BinarySort(MyList, item):
    length = len(MyList)
    if length > 0:
        mid = (length - 1) // 2
        if MyList[mid] == item:
            return True
        elif item < MyList[mid]:
            return BinarySort(MyList[:mid], item)
        else:
            return BinarySort(MyList[mid + 1:], item)
    else:
        return False


li = [11, 12, 12, 23, 32, 43, 54, 56, 62, 79, 88, 96, 313, 342, 3453, 4231, 32123, 43124]
print(*li)
print(BinarySort(li, 96))

模糊二分查找：

def BlurrdBinarySort(MyList, item):
    # 模糊二分查找：查找给定有序数组中是否存在比item更大的值
    length = len(MyList)
    if length > 0:
        mid = (length - 1) // 2
        if MyList[mid] > item:
            return True
        else:
            return BlurrdBinarySort(MyList[mid + 1:], item)
    else:
        return False


li = [11, 12, 12, 23, 32, 43, 54, 56, 62, 79, 88, 96, 313, 342, 3453, 4231, 32123, 43124]
print(*li)
print(BlurrdBinarySort(li, 11))