【白话python八大排序】快速排序，冒泡排序，归并排序,基数排序，希尔排序的过程、时间复杂度、空间复杂度
堆排序过程、时间复杂度及空间复杂度？
写出你所知道的排序算法及时空复杂度，稳定性？
快速排序
算法在数组中选择一个称为主元(pivot)的元素，将数组分为两部分，使得 第一部分中的所有元素都小于或等于主元，而第二部分的所有元素都大于主元。对第一部分递归地应用快速排序算法，然后对第二部分递归地应用快速排序算法。
在最差情况下，划分由 n 个元素构成的数组需要进行 n 次比较和 n 次移动。因此划分所需时间为 O(n) 。最差情况下，每次主元会将数组划分为一个大的子数组和一个空数组。这个大的子数组的规模是在上次划分的子数组的规模减 1 。该算法需要 (n-1)+(n-2)+…+2+1= O(n^2) 时间。
在最佳情况下，每次主元将数组划分为规模大致相等的两部分。设 T(n) 表示使用快速排序算法对包含 n 个元素的数组排序所需的时间，因此，和归并排序的分析相似，快速排序的 T(n)= O(nlogn)。
快速排序，⼜称划分交换排序
1.通过⼀趟排序将要排序的数据分割成独⽴的两部分，
其中⼀部分的所有数据都⽐另外⼀部分的所有数据都要⼩
2.然后再按此⽅法对这两部分数据分别进⾏快速排序，整个排序过程可以递归进⾏，以此达到整个数据变成有序序列。
步骤为：
- 从数列中挑出⼀个元素，称为"基准"（pivot）
- 重新排序数列，所有元素⽐基准值⼩的摆放在基准前⾯，所有元素⽐基准值⼤的摆在基准的后⾯（相同的数可以到任⼀边）。
- 在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 递归地（recursive）把⼩于基准值元素的⼦数列和⼤于基准值元素的⼦
数列排序。
递归的最底部情形，是数列的⼤⼩是零或⼀，也就是永远都已经被排序好了。虽然⼀直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它⾄少会把⼀个元素摆到它最后的位置去。
def quick_sort(list1, start, end):
# 递归的退出条件
if start >= end:
return
# 设置起始元素为要寻找位置的基准元素
mid = list1[start]
# left为序列左边的由左向右移动的游标
left = start
# right为序列右边的由右向左移动的游标
right = end
while left < right:
# 如果left和right未重合，right指向的元素不比基准元素小，
# 则right向左移动
while left < right and list1[right] >= mid:
right -= 1
# 将right指向的元素放到left的位置上
list1[left] = list1[right]
# 如果left于right未重合，left指向的元素比基准元素小
# 则left向右移动
while left < right and list1[left] < mid:
left += 1
# 将left指向的元素放到right的位置上
list1[right] = list1[left]
# 退出循环后，left与right重合，此时所指位置为基准元素的正确位置
# 将基准元素放到该位置
list1[left] = mid
# 对基准元素左边的子序列进行快速排序
quick_sort(list1, start, left-1)
# 对基准元素右边的子序列进行快速排序
quick_sort(list1, left+1, end)
li = [23, 94, 2, 21, 56, 6]
quick_sort(li, 0, len(li)-1)
print(li)
冒泡排序
是⼀种简单的排序算法。
它重复地遍历要排序的数列，⼀次⽐较两个元素，如果他们的顺序错误就把他们交换过来。
遍历数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的
顶端
冒泡排序算法的运作如下：
1.⽐较相邻的元素。如果第⼀个⽐第⼆个⼤（升序），就交换他们两个。
2.对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对。这步做完后，最后的元素会是最⼤的数。
3.针对所有的元素重复以上的步骤，除了最后⼀个。
4.持续每次对越来越少的元素重复上⾯的步骤，直到没有任何⼀对数字需要⽐较
代码实现：
def bubble_sort(list1):
n = len(list1)
# j 控制每次遍历需要比较的次数
for j in range(n-1):
count = 0
# 通过i 表示每次需要比较的数字
for i in range(0, n-1-j):
if list1[i] > list1[i + 1]:
list1[i], list1[i + 1] = list1[i + 1], list1[i]
count += 1
if 0 == count:
break
li = [23, 94, 2, 21, 56, 6]
bubble_sort(li)
print(li)
归并排序python实现
归并排序在于把序列拆分再合并起来，使用分治法来实现，这就意味这要构造递归算法
首先是一个例子
原序先通过一半一半的拆分，然后：
然后再一步一步的向上合并，在合并的过程中完成了排序，合并排序算法如下
def merge(s1,s2,s):
"""将两个列表是s1，s2按顺序融合为一个列表s,s为原列表"""
# j和i就相当于两个指向的位置，i指s1，j指s2
i = j = 0
while i+j<len(s):
# j==len(s2)时说明s2走完了，或者s1没走完并且s1中该位置是最小的
if j==len(s2) or (i<len(s1) and s1[i]<s2[j]):
s[i+j] = s1[i]
i += 1
else:
s[i+j] = s2[j]
j += 1
这是以列表为例，道理其实很简单，因为两个序列是排好序的，所以都从左往右，互相比较选择较小的那个数放入最后的序列，s是原序列，所以在一开始会有与len(s)的比较
完整算法
算法中通过递归并调用merge函数完成排序
def merge(s1,s2,s):
"""将两个列表是s1，s2按顺序融合为一个列表s,s为原列表"""
# j和i就相当于两个指向的位置，i指s1，j指s2
i = j = 0
while i+j<len(s):
# j==len(s2)时说明s2走完了，或者s1没走完并且s1中该位置是最小的
if j==len(s2) or (i<len(s1) and s1[i]<s2[j]):
s[i+j] = s1[i]
i += 1
else:
s[i+j] = s2[j]
j += 1
def merge_sort(s):
"""归并排序"""
n = len(s)
# 剩一个或没有直接返回，不用排序
if n < 2:
return
# 拆分
mid = n // 2
s1 = s[0:mid]
s2 = s[mid:n]
# 子序列递归调用排序
merge_sort(s1)
merge_sort(s2)
# 合并
merge(s1,s2,s)
if __name__ == '__main__':
s = [1,7,3,5,4]
merge_sort(s)
print(s)
时间复杂度
这个图显然是二叉树的形式，所以若集合有n个元素，那高度就为log(n)
但其实在每一层做比较的时候，都是一个一个的向序列中放小的元素，每一层都是要放n次
所以时间复杂度为nlog(n)
基数排序python实现
基数排序python实现
基数排序
基数排序（英语：Radix sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
所以基数排序的原理就是，先排元素的最后一位，再排倒数第二位，直到所有位数都排完。这里并不能先排第一位，那样最后依然是无序。
举个例子：
第一次排最低位，上边的序列变成了下面的样子
从这个图中也能看出，排序是基于桶排序实现的。
然后就像排最低位一样，然后再排倒数第二位，再排倒数第三位。注意向桶中放元素的时候一定要按顺序放。
具体代码
这里将列表进行基数排序，默认列表中的元素都是正整数
def radix_sort(s):
"""基数排序"""
i = 0 # 记录当前正在排拿一位，最低位为1
max_num = max(s) # 最大值
j = len(str(max_num)) # 记录最大值的位数
while i < j:
bucket_list =[[] for _ in range(10)] #初始化桶数组
for x in s:
bucket_list[int(x / (10**i)) % 10].append(x) # 找到位置放入桶数组
print(bucket_list)
s.clear()
for x in bucket_list: # 放回原序列
for y in x:
s.append(y)
i += 1
if __name__ == '__main__':
a = [334,5,67,345,7,345345,99,4,23,78,45,1,3453,23424]
radix_sort(a)
print(a)
希尔排序算法描述
简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。
希尔排序首先选择一个元素选择步长将数组划分为若干小组，对各个小组分别进行排序，然后不断将步长缩小，不断分组和排序，直到后的步长为1，对所有的元素进行排序，此时，经过前期的排序工作，能够减少全体元素插入排序的对比次数，大大降低了排序的时间复杂度。
我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量。
以一个实际的例子说明希尔排序的执行过程：
将数组{13,7,3,8,12,510,2}从小到大进行排序。
第一次分组排序：选择步长8/2=4，图下方的数组表示分组情况
第二次排序：选择步长4/2=2；
第三次分组排序：选择步长2/2=1；
二、算法分析
不需要大量的辅助空间，和归并排序一样容易实现。希尔排序是基于插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的时间复杂度与增量序列的选取有关，例如希尔增量时间复杂度为O(n²)，而Hibbard增量的希尔排序的时间复杂度为O()，希尔排序时间复杂度的下界是n*log2n。希尔排序没有快速排序算法快 O(n(logn))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。但是比O()复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏的情况下执行的效率会非常差。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快，再改成快速排序这样更高级的排序算法. 本质上讲，希尔排序算法是直接插入排序算法的一种改进，减少了其复制的次数，速度要快很多。 原因是，当n值很大时数据项每一趟排序需要移动的个数很少，但数据项的距离很长。当n值减小时每一趟需要移动的数据增多，此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比插入排序高很多。Shell算法的性能与所选取的分组长度序列有很大关系。只对特定的待排序记录序列，可以准确地估算关键词的比较次数和对象移动次数。
时间复杂度：
在最优的情况下，时间复杂度为：O（n ^ (1.3) ） （元素已经排序好顺序）
在最差的情况下，时间复杂度为：O（n ^ 2）；
空间复杂度：
O(1)
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
a=[3,4,1,5,2,9,7,8,6,10,11]
print("排序前："+str(a))
alen=int(len(a))
def shellsort(a):
n=alen
while(n>0):
n=n//2
for i in range(n):
for j in range(i,alen,n):
temp=a[j]
if(temp<a[j-n]):
while((temp<a[j-n]) and j>0):
a[j]=a[j-n]
j=j-n
a[j]=temp
shellsort(a)
print("排序后："+str(a))