排序算法：快速排序，冒泡排序，插入排序，选择排序

排序算法分类：交换（冒泡，快排），插入（简单插入，希尔排序），选择（简单选择，堆排序），归并（二路归并排序），线性时间非比较类（计数排序，桶排序，基数排序）
快速排序：平均时间复杂度 O(nlogn), 最坏n2，最好n 不稳定。 冒泡排序：平均时间复杂度O（n2），最坏n2，最好nlog2n， 稳定
选择排序：时间复杂度都 O(N2) 不稳定 插入排序：时间复杂度 O(n2) 不稳定

十种常见排序算法可以分为两大类：
非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序

冒泡排序：通过比较的方式，从大到小排序的话，两个比较，把最大的一个放在最后一个，循环迭代
def BubbleSort(lst):
n=len(lst)
if n<=1:
return lst
for i in range (0,n):
for j in range(0,n-i-1):
if lst[j]>lst[j+1]:
(lst[j],lst[j+1])=(lst[j+1],lst[j])
return lst
x=input(“请输入待排序数列：\n”)
y=x.split()
arr=[]
for i in y:
arr.append(int(i))
arr=BubbleSort(arr)
print(arr)
print(“数列按序排列如下：”)
for i in arr:
print(i,end=’ ')

快速排序：找一个基准值，让左边的都小于他，右边的都大于它。循环迭代完成这个过程
def quick_sort(data):
if len(data) >= 2: # 递归入口及出口
mid = data[len(data) // 2] # 选取基准值，也可以选取第一个或最后一个元素
left, right = [], [] # 定义基准值左右两侧的列表
data.remove(mid) # 从原始数组中移除基准值
for num in data:
if num >= mid:
right.append(num)
else:
left.append(num)
return quick_sort(left) + [mid] + quick_sort(right)
else:
return data

array = [2, 3, 5, 7, 1, 4, 6, 15, 5, 2, 7, 9, 10, 15, 9, 17, 12]
print(’=======’)
print(quick_sort(array))

插入排序：分成两部分，第一部分刚开始为第一个数，第二部分为剩下的所有的数。每次循环，从第二部分当中找出一个放到第一个当中，第一部分永远有序，第二部分直到迭代为0结束

def InsertSort(lst):
n=len(lst)
if n<=1:
return lst
for i in range(1,n):
j=i
target=lst[i] #每次循环的一个待插入的数
while j>0 and target<lst[j-1]: #比较、后移，给target腾位置
lst[j]=lst[j-1]
j=j-1
lst[j]=target #把target插到空位
return lst

x=input(“请输入待排序数列：\n”)
y=x.split()
arr=[]
for i in y:
arr.append(int(i))
arr=InsertSort(arr)
#print(arr)
print(“数列按序排列如下：”)
for i in arr:
print(i,end=’ ')

希尔排序：是插入排序的一个优化，采取分而治之的方法。先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序

def ShellSort(lst):
def shellinsert(arr,d):
n=len(arr)
for i in range(d,n):
j=i-d
temp=arr[i] #记录要出入的数
while(j>=0 and arr[j]>temp): #从后向前，找打比其小的数的位置
arr[j+d]=arr[j] #向后挪动
j-=d
if j!=i-d:
arr[j+d]=temp
n=len(lst)
if n<=1:
return lst
d=n//2
while d>=1:
shellinsert(lst,d)
d=d//2
return lst

x=input(“请输入待排序数列：\n”)
y=x.split()
arr=[]
for i in y:
arr.append(int(i))
arr=ShellSort(arr)
#print(arr)
print(“数列按序排列如下：”)
for i in arr:
print(i,end=’ ')

选择排序：数据操作n-1轮，每轮找出一个最大（小）值
def SelectSort(lst):
n=len(lst)
if n<=1:
return lst
for i in range(0,n-1):
minIndex=i
for j in range(i+1,n): #比较一遍，记录索引不交换
if lst[j]<lst[minIndex]:
minIndex=j
if minIndex!=i: #按索引交换
(lst[minIndex],lst[i])=(lst[i],lst[minIndex])
return lst

x=input(“请输入待排序数列：\n”)
y=x.split()
arr=[]
for i in y:
arr.append(int(i))
arr=SelectSort(arr)
#print(arr)
print(“数列按序排列如下：”)
for i in arr:
print(i,end=’ ')
归并方法：拿到一个长数组，将其不停的分为左边和右边两份，然后以此递归分下去。然后再将她们按照两个有序数组的样子合并起来
归并算法： http://www.cnblogs.com/piperck/p/6030122.html
排序算法的中心思想：https://blog.csdn.net/MBuger/article/details/67643185
日推《你瞒我瞒》陈泊宇
十大排序算法特别全 https://blog.csdn.net/weixin_41571493/article/details/81875088