排序 —— 插入排序、选择排序与冒泡排序

最新推荐文章于 2024-06-09 21:33:55 发布

Paul-LangJun

最新推荐文章于 2024-06-09 21:33:55 发布

阅读量115

点赞数

分类专栏：数据结构与算法 Python 文章标签：冒泡排序选择排序插入排序排序

本文链接：https://blog.csdn.net/gaoxueyi551/article/details/88641798

版权

数据结构与算法同时被 2 个专栏收录

45 篇文章 2 订阅

订阅专栏

Python

18 篇文章 0 订阅

订阅专栏

一、插入排序

对含有个元素的数组 $\textit{\textbf{a}}$ 进行 N - 1 次遍历，第 $\textit{i}(\textit{i}\geqslant 1)$ 次遍历将元素 $\textit{\textbf{a}}\left [ i \right ]$ 插入到位置区间 [0,i) 中合适的位置上。

# !/usr/bin/python
# coding=utf-8

def insert_sort(a):
    loop_num = len(a) - 1
    if loop_num == -1:
        return
    for i in range(loop_num):
        tmp = a[i + 1]
        p = -1
        for j in range(i, -1, -1):
            if tmp >= a[j]:
                break
            a[j + 1] = a[j]
            p = j
        if p != -1:
            a[p] = tmp
    return a

def main():
    # 测试用例
    a = [34, 2, 14, 5, 6, 200, 122, 79]
    insert_sort(a)
    a = [2, 1]
    insert_sort(a)
    a = [1, 2]
    insert_sort(a)
    a = [1]
    insert_sort(a)
    a = []
    insert_sort(a)

if __name__ == '__main__':
    main()

最好情况: 有序，仅需n-1次比较，

最坏情况: 逆序，需n * (n-1) / 2次比较和交换
时间复杂度: O(n*n)

二、选择排序

对有个元素的数组 $\textit{\textbf{a}}$ 进行 N - 1 次遍历，第 $\textit{i}(\textit{i}\geqslant 1)$ 次遍历顺序扫描子数组 a[i...N-1] ，并将其中最小的元素与 $\textit{\textbf{a}}\left [ i - 1\right ]$ 相交换。

# !/usr/bin/python
# coding=utf-8

def select_sort(a):
    loop_num = len(a) - 1
    if loop_num == -1:
        print('empty array!')
        return
    for i in range(loop_num):
        t = i
        for j in range(i + 1, loop_num + 1):
            if a[j] < a[t]: t = j
        a[i], a[t] = a[t], a[i]
    return a

def main():
    # 测试用例
    a = [34, 2, 14, 5, 6, 200, 122, 79]
    select_sort(a)
    a = [2, 1]
    select_sort(a)
    a = [1, 2]
    select_sort(a)
    a = [1]
    select_sort(a)
    a = []
    select_sort(a)

if __name__ == '__main__':
    main()

    最好情况: 有序，需n-1次比较
    最坏情况: 逆序，需n * (n-1) / 2次比较, 以及n - 1次交换
    时间复杂度: O(n*n)

三、冒泡排序

对有个元素的数组 $\textit{\textbf{a}}$ 进行 N - 1 次遍历，第 $\textit{i}(\textit{i}\geqslant 1)$ 次遍历将按顺序对子数组 a[0...N-i] 中所有毗邻元素对进行交换，交换原则是小元素排在大元素之前，最多执行 N-i 次交换，遍历结束后， a[N-i] 成为子数组中的最大元素。

# !/usr/bin/python
# coding=utf-8

def bubble_sort(a):
    loop_num = len(a) - 1
    if loop_num == -1:
        print('empty array!')
        return
    for i in range(loop_num):
        for j in range(i, loop_num):
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
    return a

def main():
    # 测试用例
    a = [34, 2, 14, 5, 6, 200, 122, 79]
    bubble_sort(a)
    a = [2, 1]
    bubble_sort(a)
    a = [1, 2]
    bubble_sort(a)
    a = [1]
    bubble_sort(a)
    a = []
    bubble_sort(a)

if __name__ == '__main__':
    main()

最好情况: 有序，需n-1次比较

最坏情况: 逆序，需n * (n-1) / 2次比较, 以及n * (n-1) / 2次交换
时间复杂度: O(n*n)

四、插入排序和冒泡排序的优劣性比较

实质上，三种简单排序的性能与一个概念——逆序紧密相关。逆序定义为数组中 $\textit{i}< \textit{j}$ 但 A[i] > A[j] 的序偶 <A[i],A[j]> ，数组中序偶中的数量即执行插入排序需要进行的交换次数。情况总是这样，因为交换两个不按原序排序的元素恰好消除一个逆序，而一个排过序的数组没有逆序。