11种排序算法 python实现（冒泡、选择、插入、快速、堆、希尔、归并、计数、二分法、桶、基数）

11种排序算法 python实现

冒泡，选择，插入，快速，堆，希尔，归并，二分法（基于比较的）
计数， 桶，基数（基于非比较的）

• 排序算法时间复杂度

算法	最好情况	最坏情况	平均情况	空间复杂度	稳定性
冒泡	n^2	n^2	n^2	1	稳定 （小于或者大于的才会交换，等于 不交换））
选择	n^2	n^2	n^2	1	不稳定
插入	n	n^2		1	稳定
快速			nlgn	递归实现 基准 （以第一个元素为基准）	不稳定
堆				建立堆，调整 调整 n 次	不稳定
希尔				分组插入排序 增量 减半直到增量为1	不稳定
归并				平均分成左右两部分、排序、再合并 递归调用	稳定
计数	n+k，k为数组中最大的数
桶
基数
二分插入

• 排序算法稳定性
• 

1. 冒泡排序

冒泡排序的基本思想是通过与相邻元素的比较和交换，每次将最大元素放到数组尾部。整个过程类似于水中气泡的上升。
比较次数：为n-1,n-2,…, 1
时间复杂度 n^2

 def sort_1(tinput):   ## 冒泡排序
        length =len(tinput)
        if length<=0:
            return None
        if length ==1:
            return tinput
        
        for i in range(length):
            for j in range(length-i-1):  #每次将最大的放最后
                if tinput[j]>tinput[j+1]:  #将大的交换到后边
                    tinput[j],tinput[j+1]=tinput[j+1],tinput[j]
                else:
                    pass
        return tinput

2.选择排序

选择排序的基本思想也是比较和交换，但选择排序是通过对整体的选择。每次找出剩余数组中最小的元素与第一个元素交换。
时间复杂度为 n^2,与冒泡排序相比，交换次数减少。

def sort_2(self,tinput):  #选择排序
        length =len(tinput)
        if length<=0:
            return None
        if length ==1:
            return tinput
        for i in range(length):   #找出最小元素的下标
            min_index =i
            for j in range(i+1,length):
                if tinput[j]<tinput[min_index]:
                    min_index =j
                else:
                    pass
            tinput[i],tinput[min_index] =tinput[min_index],tinput[i]
        return tinput

3.插入排序

通过比较找到合适的位置，然后插入元素，从后往前比
将数组分为有序，无序两部分，每次将无序中的一个元素插入有序部分中。
最好情况，比较 n-1次
最坏情况1，2，……，n-1 .

  def sort_3(tinput): #插入排序
        length =len(tinput)
        if length<=0:
            return None
        if length ==1:
            return tinput
        relist = [tinput[0]]  #一个元素有序   
        for i in range(1,length):
            for j in range(len(relist