[算法]排序

排序

冒泡排序

if __name__ == '__main__':
    while True:
        try:
            arr = list(map(int, input().split(" ")))[1:]
            flag = True
            while flag:
                flag = False
                for i in range(len(arr) - 1):
                    if arr[i] > arr[i + 1]:  # 第一个数大于第二个数,交换他们两个
                        arr[i], arr[i + 1] = arr[i + 1], arr[i]
                        flag = True
            print(" ".join(map(str, arr)))
        except EOFError:
            break

希尔排序

if __name__ == '__main__':
    for _ in range(int(input())):
        arr = list(map(int, input().strip().split(" ")))
        arr2 = list(map(int, input().strip().split(" ")))
        n = len(arr)
        idx_arr = list(range(n))
        for k in arr2:
            # 排序过程
            for p in range(k):
                num_arr = arr[p::k]  # 获取要排序的数组 从p开始,每隔k个取
                for i in range(1, len(num_arr)):
                    if num_arr[i] < num_arr[i - 1]:
                        temp = num_arr[i]
                        while temp < num_arr[i - 1] and i > 0:  # 插入排序
                            num_arr[i] = num_arr[i - 1]
                            i -= 1
                        num_arr[i] = temp
                # 赋值过程
                num_arr = num_arr[::-1]
                for j in range(p, n, k):
                    arr[j] = num_arr.pop()
        print(" ".join(map(str, arr)))

插入排序

if __name__ == '__main__':
    for _ in range(int(input())):
        arr = list(map(int, input().split(" ")))[1:]
        for i in range(1, len(arr)):
            j, temp = i, arr[i]
            if temp < arr[j - 1]:  # 如果当前数比前一个小,证明该数位置不对
                while j > 0:
                    if temp < arr[j - 1]:  # 如果小就一直找它的前一个
                        arr[j] = arr[j - 1]  # 找的时候用下一个值将这个值覆盖掉
                        j -= 1
                    else:
                        break
                arr[j] = temp  # 找到位置j,并把其覆盖掉
            else:
                continue
        print(" ".join(map(str, arr)))

并归排序:递归

# 直接在原数组上修改
def merge_sort(l, r, arr):
    if l == r:
        return
    mid = (l + r) >> 1
    merge_sort(l, mid, arr)
    merge_sort(mid + 1, r, arr)
    i, j = l, mid + 1
    temp = []
    while i <= mid and j <= r:
        if arr[i] < arr[j]:
            temp.append(arr[i])
            i += 1
        else:
            temp.append(arr[j])
            j += 1
    while i <= mid:
        temp.append(arr[i])
        i += 1
    while j <= r:
        temp.append(arr[j])
        j += 1
    temp = temp[::-1]  # 倒置之后便于pop
    for idx in range(l, r + 1):  # 修改数组的值
        arr[idx] = temp.pop()


if __name__ == '__main__':
    while True:
        try:
            # s = "13 24 3 56 34 3 78 12 29 49 84 51 9 100"
            arr = list(map(int, input().split(" ")))[1:]
            merge_sort(0, len(arr) - 1, arr)
            print(" ".join(map(str, arr)))
        except EOFError:
            break

计数排序

创建一个[min,max]的数组统计个数

if __name__ == '__main__':
    while True:
        try:
            arr = list(map(int, input().split(" ")))[1:]
            min_num, max_num = min(arr), max(arr)
            count_arr = [0] * (max_num - min_num + 1)  # 初始化一个大小等于差值的数组,用于计数,数组下标代表元素,数组值代表出现了几次
            for x in arr:  # 对所有x进行一次缩小,x - min_num为当前位置
                count_arr[x - min_num] += 1  # 将当前数字所在的位置加一
            res = []
            for i in range(len(count_arr)):
                v = count_arr[i]
                while v > 0:
                    res.append(str(i + min_num))  # 将i还原成原来的数字i + min_num还原
                    v -= 1
            print(" ".join(res))
        except EOFError:
            break

快速排序

快速排序:递归

# 可以使用覆盖元素或者交换元素的方法,这里用交换元素的方法
def quick_sort(l, r, arr):
    if l < r:  # 每次排序保证比基准值小的在其左边,比基准值大的在其右边
        temp, low, high = arr[l], l, r  # 基准值选定为第一个数
        while low < high:
            while low < high and arr[high] >= temp:  # 从后往前,如果找到了大于基准值的元素
                high -= 1  # high向左移动
            while low < high and arr[low] <= temp:  # 从前往后,如果找到了小于基准值的元素
                low += 1  # low向右移动
            arr[low], arr[high] = arr[high], arr[low]  # 交换low,high的值
        arr[low], arr[l] = arr[l], arr[low]  # 交换基准值与当前位置的值
        quick_sort(l, low, arr)  # 对左边进行快速排序
        quick_sort(low + 1, r, arr)  # 对右边进行快速排序


if __name__ == '__main__':
    while True:
        try:
            arr = list(map(int, input().split(" ")))[1:]
            quick_sort(0, len(arr) - 1, arr)
            print(" ".join(map(str, arr)))
        except EOFError:
            break

快速排序:非递归

使用栈来存储每次要递归的low与high

# 非递归快排实际上是使用栈来记录每次要遍历的low和high的下标,每次遍历都弹出下标,直到栈为空则停止
# 将左边的l,h放入栈的条件是基准值的左边至少要有两个数(一个数就不用排序了),右边同理


# 可以使用覆盖元素或者交换元素的方法,这里用交换元素的方法
def quick_sort(arr):
    stack = [0, len(arr) - 1]  # 使用一个栈来记录每次要遍历的low和high的下标 ,定义第一个放low,第二个放high
    while len(stack) > 0:  # 如果栈中有元素
        r = stack.pop()  # 第一个弹出来的是high
        l = stack.pop()  # 第二个弹出来的是low
        # ====这里不变
        temp, low, high = arr[l], l, r  # 基准值选定为第一个数
        while low < high:
            while low < high and arr[high] >= temp:  # 从后往前,如果找到了大于基准值的元素
                high -= 1  # high向左移动
            while low < high and arr[low] <= temp:  # 从前往后,如果找到了小于基准值的元素
                low += 1  # low向右移动
            arr[low], arr[high] = arr[high], arr[low]  # 交换low,high的值
        arr[low], arr[l] = arr[l], arr[low]  # 交换基准值与当前位置的值
        # ====这里不变
        if l + 1 < low:  # 代表low左边至少有两个数,扔需要排序
            stack.append(l)  # 则把下一次要快排的low和high压入栈
            stack.append(low - 1)  #
        if low + 1 < r:
            stack.append(low + 1)  # 则把下一次要快排的low和high压入栈
            stack.append(r)  #


if __name__ == '__main__':
    while True:
        try:
            arr = list(map(int, input().split(" ")))[1:]
            quick_sort(arr)
            print(" ".join(map(str, arr)))
        except EOFError:
            break