下图是各种排序方法的时间复杂度、空间复杂度和稳定性，大牛编程吧教你如何编程提升。
1.直接插入排序。
直接插入的基本思想是每一步将一个数插入到已排序的有序数列中。
python代码实现：
def direct_insert_sort(l):
for i in range(1,len(l)):
key = l[i]
j = i-1
while j>=0:
if key<l[j]:
l[j+1] = l[j]
l[j] = key
j -= 1
return l
a = [2,3,1,5,4,4]2.Shell排序（希尔排序）。
希尔排序是直接插入排序的改进版本希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
python代码实现：
def shell_sort(l):
c = len(l)
step = len(l)//2
while step>0:
for i in range(step):
j = i+step
while j<c:
key = l[j]
p = j-step
while p>=0:
if key<l[p]:
l[p+step] = l[p]
l[p] = key
p -= step
j += step
step = step//2
return l
a = [2,3,1,5,4,4]
print(shell_sort(a)) 3.直接选择排序。
直接选择排序是每次找到未排序元素中最小的元素放到最前面具体实现是第一趟将第一个元素与后面所有元素比较，小的放前面，第二趟得到第二个元素，这样直至排序完成。
python代码实现：
def direct_choice_sort(l):
for i in range(len(l)-1):
for j in range(i+1,len(l)):
if l[j]<l[i]:
l[i],l[j] = l[j],l[i]
return l
a = [3,1,4,5,2,2]
print(direct_choice_sort(a)) 4.堆排序。
堆排序是一种选择排序，是用堆结构来完成排序的一种算法，升序用大顶堆，降序用小顶堆；构造大顶堆：一个结点i的左右叶子结点为2i+1,2i+2,最后一个非叶子结点为len(l)//2-1,从最后一个非叶子结点起，开始调整，将大的元素放到父结点上。
python代码实现：
def heap_sort(l):
for j in range(len(l),0,-1):
#j为堆的长度，c为堆的最大非叶子结点索引
c = (j//2)-1
#从最大非叶子结点开始调整堆
for i in range(c,-1,-1):
if (2*i+1)<=(j-1) and l[2*i+1]>l[i]:
l[i],l[2*i+1] = l[2*i+1],l[i]
if (2*i+2)<=(j-1) and l[2*i+2]>l[i]:
l[i],l[2*i+2] = l[2*i+2],l[i]
#交换堆顶与最后一个结点
l[0],l[j-1] = l[j-1],l[0]
return l
a = [67,65,77,38,97,3,33,49,33]
#heap(a)
print(heap_sort(a))5.冒泡排序。
冒泡排序是从后向前每次比较相邻的2个元素大小，大的放后面，这样一次遍历第一个元素就是最小的，第二次遍历第二个元素就是剩下中最小的，这样直到排序完成。
python代码实现：
def Bubble_sort(l):
c = len(l)
for i in range(1,c):
for j in range(c-1,i-1,-1):
if l[j] < l[j-1]:
l[j],l[j-1] = l[j-1],l[j]
return l
a = [3,1,4,5,2,2]
print(Bubble_sort(a)) 6.快速排序。
快速排序的思想是每次任意取一个元素，如第一个，将剩下比它小的元素的放到它的前面，大的放到它的后面，这样这个元素就已经在最终排序完成的位置上了，然后对小的元素和大的元素继续进行快速排序，这样直至排序完成。
python代码实现：
quick_sort = lambda l:l if len(l)<=1 else quick_sort([i for i in l[1:] if i<=l[0]])+[l[0]]+quick_sort([i for i in l[1:] if i>l[0]])
a = [3,1,4,5,2,2]
print(quick_sort(a))7.归并排序。
归并排序是一个典型的基于分治的递归算法。先将原数组分成n个小数组然后两两归并。
归并过程：先比较l1,l2的第一个元素大小，如果l1大则将l2的第一个元素添加到输出数组o中，然后l2指向第二个元素继续比较，这样直至排序完成。
python代码实现：
def merge(l1,l2):
o = []
a1 = 0;a2 = 0
if l1==[]:
return l2
if l2==[]:
return l1
for i in range(len(l1)+len(l2)):
if a1 == len(l1):
for j in l2[a2:]:
o.append(j)
elif a2 == len(l2):
for j in l1[a1:]:
o.append(j)
else:
if l1[a1]>=l2[a2]:
o.append(l2[a2])
a2 += 1
else:
o.append(l1[a1])
a1 += 1
return o
def sort(l):
if len(l)<=1:
return l
c = len(l)//2
return merge(sort(l[:c]),sort(l[c:]))
a = [67,65,77,38,97,3,33,33]
print(sort(a)) 基数排序写不出来。。