常见的排序算法（py）

常见的排序

1.插入排序

1.1 直接插入排序
思想：将整个列表分为两部分，有序部分和无序部分，如何从无序部分的元素一个个插入到有序表的合适位置，直到无序表中没有元素，排序完成。

#插入排序
l = [3,4,2,7,0,2,8]

for i in range(1,len(l)):
    if l[i]<l[i-1]:
        t = l[i]
        for j in range(i-1,-1,-1):
            if l[j]>=t:
                l[j+1]=l[j]
                l[j]=t
            else:
                break
        l[j] = t
print(l)

1.2 折半插入排序
思想：同直接插入，区别是采用折半查找的方式在有序表中找到待插入的位置；

l = [3, 4, 2, 7, 0, 2, 8]

for i in range(1, len(l)):
    t = l[i]
    low, high = 0, i - 1
    while (low < high):
        m = (low + high) // 2
        if (t < l[m]):
            high = m - 1
        else:
            low = low + 1
    for j in range(i - 1, high + 1, -1):
        l[j + 1] = l[j]
    l[j] = t
print(l)

1.3 希尔排序
思想：通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。

2.交换排序

2.1 冒泡排序
思想：从前往后或从后往前，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。

#冒泡（从前王后）
l = [1,4,2,7,0,2,8]

for i in range(len(l)-1):
    for j in range(len(l)-i-1):
        if l[j]>l[j+1]:
            temp = l[j]
            l[j] = l[j+1]
            l[j+1] = temp
print(l)

2.2 快排
思想:首先任意选取一个数据为基准数据，将待排序列表中的数据分割成独立的两部分，所有比基准数据小的数都放到它左边，所有比基准数据大的数都放到它右边，此时基准数据排序完成，第一轮快速排序完成。
然后再按此方法对两部分的数据分别进行快速排序，整个排序过程可以递归进行，直到被分割的数据只有一个或零个时，递归结束，列表排序完成。

l = [3,4,2,7,0,2,8]

def quick_sort(array, start, end):
    if start >= end:
        return
    mid_data, left, right = array[start], start, end
    while left < right:
        while array[right] >= mid_data and left < right:
            right -= 1
        array[left] = array[right]
        while array[left] < mid_data and left < right:
            left += 1
        array[right] = array[left]
    array[left] = mid_data
    quick_sort(array, start, left - 1)
    quick_sort(array, left + 1, end)


quick_sort(l, 0, len(l) - 1)
print(l)

搬运地址：https://blog.csdn.net/weixin_43790276/article/details/104033641

3.选择排序

3.1 简单选择排序
思想:初始时在序列中找到最小(大）元素，放到序列的起始位置作为已排序序列;然后，再从剩余未排序元素中继续寻找最小(大）元素，放到已排序序列的前端或末尾，直到所有元素均排序完毕。

#选择排序
l = [1,4,2,7,0,2,8]

for i in range(len(l)):
    l_min = i
    for j in range(i,len(l)):
        if l[l_min]>l[j]:
            l_min = j
    t = l[i]
    l[i] = l[l_min]
    l[l_min] = t

print(l)

3.2 堆排序
堆是一种近似完全二叉树的结构（通常堆是通过一维数组来实现的），并满足性质：以最大堆（也叫大根堆、大顶堆）为例，其中父结点的值总是大于它的孩子节点。
算法步骤：
1.由输入的无序数组构造一个最大堆，作为初始的无序区
2.把堆顶元素（最大值）和堆尾元素互换
3.把堆（无序区）的尺寸缩小1，并调用heapify(A, 0)从新的堆顶元素开始进行堆调整
4.重复步骤2，直到堆的尺寸为1

4.归并排序

4.1 二路归并排序
思想：归并排序的实现分为递归实现与非递归(迭代)实现。递归实现的归并排序是算法设计中分治策略的典型应用，我们将一个大问题分割成小问题分别解决，然后用所有小问题的答案来解决整个大问题。非递归(迭代)实现的归并排序首先进行是两两归并，然后四四归并，然后是八八归并，一直下去直到归并了整个数组

归并排序算法主要依赖归并(Merge)操作。归并操作指的是将两个已经排序的序列合并成一个序列的操作，归并操作步骤如下：
1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2.设定两个指针，最初位置分别为两个已经排序序列的起始位置
3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4.重复步骤3直到某一指针到达序列尾
5.将另一序列剩下的所有元素直接复制到合并序列尾