【数据结构】Python实现 冒泡、选择、插入、希尔、快速、归并排序算法

数据结构中的排序方式有很多，本文介绍六大排序。

一、冒泡排序
一个数组中相邻的两个数值进行比较，将较大的值放在后面，直到比较完所有数值。即找到了最大值放在数组的最后，在剩余的n-1个数值中依次执行这种操作，最终将数值从小到大排序。

步骤：

1. 比较相邻的元素。如果第一个比第二个大，就交换两个数的位置
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。注意，最后的元素应该会是最大的数
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
   代码实现

#冒泡排序，当前值与后一个值进行比较，较大的放在后面，循环执行，直到遍历完所有
#时间复杂度o（n……2） 稳定
def bubble_sort(alist):
    """冒泡排序"""
    n= len(alist)
    #执行的总最大值查找次数
    for j in range(n-1,0,-1):
        count = 0
        #完成一次最大值的查找
        for i in range(j):
            #比较当前值和后一个值的大小
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
                count += 1
            #如果某次没有进行任何交换，则证明有序，不用进行下一次循环
        if 0 == count:
            return
if __name__ == '__main__':
    li = [12,41,7,62,56,77,95]
    print(li)
    bubble_sort(li)
    print(li)

二、选择排序

它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

代码实现

#选择排序，从右边无序的数字中选择最小的，放在左边有序数组中
#时间复杂度o（n……2） 不稳定
def select_sort(alist):
    """选择排序"""
    n = len(alist)
    #找到确定位置后的所有元素中最小值
    for j in range(n-1):
        min_index = j
        #找到当前值后面所有元素与其对比，将最小的放置在前面
        for i in range(j+1,n):
            if alist[min_index] > alist[i]:
                min_index = i
            
        alist[j],alist[min_index] = alist[min_index],alist[j]
            
if __name__ == '__main__':
    li = [12,41,7,82,56,37,95]
    print(li)
    select_sort(li)
    print(li) 

三、插入排序

插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。

步骤：

1. 假设左边为有序，右边为无序，将右边的元素与左边的依次比较，并放入适当的位置
2. 对所有的元素进行这种操作，直到最左边的元素为最小值，形成从小到大的顺序

代码实现

#插入排序 始终从右边选择第一个 与左边数字比较并放入适当位置
def insert_sort(alist):
    """插入排序"""
    n = len(alist)
    #从右边的无序序列中取出多少个元素执行这样过程
    for j in range(1,n):
        i = j
        #执行从右边的无序序列中取出第一个元素，即i的位置的元素，然后将其插入但前面正确的位置中
        while i>0:
            #如果所选择元素比前一个小，则交换位置
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -=1
            else:
                break

if __name__ == '__main__':
    li = [12,45,23,35,82,47]
    print(li)
    insert_sort(li)
    print(li)

四、希尔排序
和插入排序方法类似，区别在于希尔排序将整个数据按照不同的gap值分成小块，对每部分的数据执行插入排序，同样非稳定排序，并且时间复杂度，最坏为o（n……2），最好为o（n……3/2）
希尔排序是基于插入排序的以下两点性质而提出改进方法的：

1. 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

代码实现

#希尔排序 类似于分块后的插入排序
def shell_sort(alist):
    """希尔排序"""
    n = len(alist)
    #定义gap 确定每块元素的长度，具体如何选择gap是数学计算的东西，并且目前没有具体的方法可以找到最优的gap
    gap = n // 2
    #需要定义一个外层循环，用来控制选择多少个gap及什么时候停止
    while gap >0:
        for j in range(gap,n):
            i = j
            #排序方式和插入排序一样，区别在于后一个元素和前一个元素的间隔是gap不是1
            while i >0:
               #如果所选择元素比前一个小，则交换位置 
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -=gap
                else:
                    break
        #缩短gap
        gap //=2
if __name__ == '__main__':
    li = [12,89,34,56,27,26,88,95,39]
    print(li)
    shell_sort(li)
    print(li)
    

五、快速排序

快速排序的思想是，先定义一个基准，并将一组数据分成两部分，左边的大于基准，右边的小于基准，利用递归方式对左右两部分再进行划分。

快速排序步骤如下：

• 首先设定一个分界值，通过该分界值将数组分成左右两部分
• 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值
• )然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理
• 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了

代码实现

#快速排序 
#可选择列表中的第一个元素作为基准
#利用两个游标从两段分别游走，使得基准坐标元素比其小，右边的比其大
#将左右两部分的元素分别执行上述操作，直到不可再分为止，可采用递归的方法
def quick_sort(alist,first,last):
    """快速排序"""
    #如果坐标的游标下标大于右边停止
    if first >= last:
        return
    #定义一个基准，可选择第一个元素作为基准
    mid_value = alist[first]
    low = first
    high = last
    while low < high:
        #high 左移
        while low < high and alist[high]>= mid_value:
            high -=1
        alist[low] = alist[high]
        #右移
        while low< high and alist[low]< mid_value:
            low +=1
        alist[high] = alist[low]
    #找到基准所在位置，此时 low=high 因此可以设置alist[low ]= mid_value 
    alist[low] = mid_value
    
    #递归 对 基准左右两边的元素执行同样操作
    #low 左边元素
    quick_sort(alist,first,low-1)
    #low 右边元素
    quick_sort(alist,low+1,last)

if __name__ == '__main__':
    li = [45,23,67,86,18,46,92,60]
    print(li)
    quick_sort(li,0,len(li)-1)
    print(li)

六、归并排序

归并排序的工作原理：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置重复步骤3直到某一指针超出序列尾
4. 将另一序列剩下的所有元素直接复制到合并序列尾

代码实现

#归并排序  将列表拆分 按照1/2的大小循环差分 直到将列表中的元素拆成单个元素
#将拆分好的元素进行合并，按照拆分的相反大小进行合并，合并的同时并将 每一组中较小的元素排在前面
def merge_sort(alist):
    #截止条件， 列表只包括一个元素则停止
    if len(alist)<=1:
        return alist
    #拆分过程
    mid = len(alist)//2
    #拆分后形成的新的列表 left
    left_li = merge_sort(alist[:mid])
    #拆分后形成的新的列表 right
    right_li = merge_sort(alist[mid:])
    
    #合并操作，将拆分后的两个列表合并成一个大的列表
    #定义左右两个指针，均初始化指向第一个元素
    left_pointer,right_pointer = 0,0
    #定义空列表 用来存放合并后的值
    result =[]
    
    while left_pointer <len(left_li) and right_pointer < len(right_li):
        #如果左边的元素较小，就将左边元素添加到空列表，并且自增一个 指向下一个元素进行判断
        if left_li[left_pointer] < right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result

if __name__ == '__main__':
    li = [67,34,26,17,83,92,49,50]
    print(li)
    sorted_li = merge_sort(li)
    print(sorted_li)