常见简单算法-Python实现(3) 选择排序、插入排序、冒泡排序

声明：

本文给出选择排序、插入排序、冒泡排序算法的Python实现方法和运行结果；

代码有问题或疑惑下方评论，有错勿喷；更多大学简单算法的实现进我博客；

1. 选择排序 selection_sort

程序代码

# 选择排序
# 作用：对给出的n个顺序不定的数进行排序
# 输入：任意数组A
# 输出：按顺序排列的数组A
# 时间复杂度 (n(n-1))/2

# 选择排序
# 第一趟：选择第一个元素，依次与每个元素比较，用k记录下最小的元素的位置，
#           然后第一个元素与最小的元素交换，此时第一个元素变为最小
# 第二趟：选择第二个元素，依次与除了第一个之外的每个元素比较，用k记录下最小的元素的位置，
#           然后第二个元素与最小的元素交换，此时第二个元素变为除第一个之外的最小
# 以此类推，进行n趟后，得到结果


# 在此修改初始数据
A = [12,56,92,-1,5,110,92,999,-39,21,76,33,56]
print('初始数据为：');print(A)

n = len(A)          # 用n获取数组长度
i = 0       # 外循环数组元素下标
k = 0       # 内循环的次数，即数组进行k次内循环后前k个数被确定
j = 0       # 内循环数组元素下标

while i <= n-1:      # 循环n次
    while j <= n-1:          
        if A[i] >  A[j]:    # 若大于，则交换，若小于，继续比较下一个
            temp = A[i]
            A[i] = A[j]
            A[j] = temp
            j = j+1
        else:
            j = j+1
    k = k+1         # 完成一次内循环，则确定一个数
    i = i+1         # 选择下个元素进行内循环     
    j = k       # 每次循环后将j的值设为k，则下一次循环就不用比较之前已确定的数
    print(A)    # 查看程序执行过程

print('排序结果为：')
print(A)

运行结果

初始数据为：
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]

排序过程为：
[-39, 56, 92, 12, 5, 110, 92, 999, -1, 21, 76, 33, 56]
[-39, -1, 92, 56, 12, 110, 92, 999, 5, 21, 76, 33, 56]
[-39, -1, 5, 92, 56, 110, 92, 999, 12, 21, 76, 33, 56]
[-39, -1, 5, 12, 92, 110, 92, 999, 56, 21, 76, 33, 56]
[-39, -1, 5, 12, 21, 110, 92, 999, 92, 56, 76, 33, 56]
[-39, -1, 5, 12, 21, 33, 110, 999, 92, 92, 76, 56, 56]
[-39, -1, 5, 12, 21, 33, 56, 999, 110, 92, 92, 76, 56]
[-39, -1, 5, 12, 21, 33, 56, 56, 999, 110, 92, 92, 76]
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 999, 110, 92, 92]
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 999, 110, 92]
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 999, 110]
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]

排序结果为：
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]

2. 插入排序 insertion_sort

程序代码

# 插入排序程序
# 作用：对给出的n个顺序不定的数进行排序
# 输入：任意数组A
# 输出：按顺序排列的数组A
# 时间复杂度 n(n-1) 至 (n(n-1))/2

# 插入排序过程
# 第一趟：选择第一个元素，之前没有其他元素可以比较，故放在第一位
# 第二趟：选择第二个元素，与前一个元素比较，若比之大，则不动；若比之小，则与之交换
# 第三趟：选择第三个元素，与前一个元素比较，若比之大，则不动；若比之小，则与之交换
#        直到该元素前面没有再比它小的数
# 每次循环确定一个数的相对位置，以此类推


# 在此修改初始数据
A = [12,56,92,-1,5,110,92,999,-39,21,76,33,56]

print('初始数据为：')
print(A)
n = len(A)          # 用n获取数组长度
i = 0               # 外循环时数组的下标
j = 0               # 内循环时数组的下标

while i <= n-1:
    x = A[i]
    j = i - 1
    while j > -1 and A[j] > x:
        A[j+1] = A[j]
        j = j - 1
    A[j+1] = x
    i = i + 1
    print(A)

print('排序结果为：')
print(A)

运行结果

初始数据为：
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]

排序过程为：
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]
[-1, 12, 56, 92, 5, 110, 92, 999, -39, 21, 76, 33, 56]
[-1, 5, 12, 56, 92, 110, 92, 999, -39, 21, 76, 33, 56]
[-1, 5, 12, 56, 92, 110, 92, 999, -39, 21, 76, 33, 56]
[-1, 5, 12, 56, 92, 92, 110, 999, -39, 21, 76, 33, 56]
[-1, 5, 12, 56, 92, 92, 110, 999, -39, 21, 76, 33, 56]
[-39, -1, 5, 12, 56, 92, 92, 110, 999, 21, 76, 33, 56]
[-39, -1, 5, 12, 21, 56, 92, 92, 110, 999, 76, 33, 56]
[-39, -1, 5, 12, 21, 56, 76, 92, 92, 110, 999, 33, 56]
[-39, -1, 5, 12, 21, 33, 56, 76, 92, 92, 110, 999, 56]
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]

排序结果为：
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]

3. 冒泡排序 bubble_sort

程序代码

# 冒泡排序
# 作用：对给出的n个顺序不定的数进行排序
# 输入：任意数组A
# 输出：按顺序排列的数组A

# 冒泡排序过程
# 第一趟：以第一个数为基准，从最后一位数开始，依次与它比较，
#               若大于它，则交换，若小于它，则继续判断前一个数
#               完成一趟后，这个基准数(即第一个数)是所有数里最大的
# 第二趟：以第二个数为基准，从最后一位数开始，依次与它比较，
#               若大于它，则交换，若小于它，则继续判断前一个数
#               完成一趟后，这个基准数(即第二个数)是除了第一个数之外最大的
# 以此类推，直到以最后一个数位基准时，得到倒序的数组

# 在此修改初始数据
A = [12,56,92,-1,5,110,92,999,-39,21,76,33,56]

print('您的初始数据为：')
print(A);print('\n'*1)      # print('\n'*1) 意思为空一行，仅起使输出美观的作用
n = len(A)          # 用n获取数组长度
i = 0               # 外循环时数组的下标
j = n-1             # 内循环时数组的下标

while i <= n-1:
    while j != i:
        if A[j] > A[i]:
            temp = A[i]
            A[i] = A[j]
            A[j] = temp
            j = j - 1
        else:
            j = j - 1
    j = n -1        # 重置j，使得下次循环能j能从最后一个数开始
    i = i + 1       # 完成一次循环后，第i个数已被确定，是当前剩余的数中最大的
    print(A)
 
print('\n'*1)       
print('冒泡排序的结果：')       # 输出的数据是逆向排序的
print(A)

A.reverse()         # python自带的函数，使逆序
print('取倒序后数据为：')     
print(A)

运行结果

您的初始数据为：
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]


[999, 56, 92, -1, 5, 110, 92, 76, -39, 21, 56, 33, 12]
[999, 110, 92, -1, 5, 92, 76, 56, -39, 21, 56, 33, 12]
[999, 110, 92, -1, 5, 92, 76, 56, -39, 21, 56, 33, 12]
[999, 110, 92, 92, 5, 76, 56, 56, -39, 21, 33, 12, -1]
[999, 110, 92, 92, 76, 56, 56, 33, -39, 21, 12, 5, -1]
[999, 110, 92, 92, 76, 56, 56, 33, -39, 21, 12, 5, -1]
[999, 110, 92, 92, 76, 56, 56, 33, -39, 21, 12, 5, -1]
[999, 110, 92, 92, 76, 56, 56, 33, -39, 21, 12, 5, -1]
[999, 110, 92, 92, 76, 56, 56, 33, 21, 12, 5, -1, -39]
[999, 110, 92, 92, 76, 56, 56, 33, 21, 12, 5, -1, -39]
[999, 110, 92, 92, 76, 56, 56, 33, 21, 12, 5, -1, -39]
[999, 110, 92, 92, 76, 56, 56, 33, 21, 12, 5, -1, -39]
[999, 110, 92, 92, 76, 56, 56, 33, 21, 12, 5, -1, -39]


冒泡排序的结果：
[999, 110, 92, 92, 76, 56, 56, 33, 21, 12, 5, -1, -39]
取倒序后数据为：
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]