1.快速排序
排序思想：
1.从数列中挑出一个元素，称为"基准"（pivot）
2.重新排序数列，所有比基准值小的元素放在基准前面，比基准大的元素放在基准后面。在这个分区结束之后，该基准就处于数列的中间位置，这就是分区操作。
3.递归地把小于基准的子数列和大于基准的子数列排序。
最优时间复杂度：O(nlogn)
最坏时间复杂度：O(n2)
稳定性：不稳定
def quick_sort(alist, start, end):
"""快速排序"""
# 递归出口
if start >= end:
return
# 设起始元素为基准元素
mid = alist[start]
# low为序列左边的由左向右移动的游标
low = start
# high为序列右边的由右向左移动的游标
high = end
while low < high:
# 如果low与high未重合，high指向的元素比基准元素大，则high向左移动
while low < high and alist[high] >= mid:
high -=1
# 将high指向的元素放到low的位置上
alist[low] = alist[high]
# 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
while low < high and alist[low] < mid:
low += 1
# 将low指向的元素放到high的位置上
alist[high] = alist[low]
# 将基准元素放到该位置
alist[low] = mid
# 对基准元素左边的子序列进行快速排序
quick_sort(alist,start,low-1)
# 对基准元素右边的子序列进行快速排序
quick_sort(alist,low+1,end)
alist = [4,2,3,7,9,1,8,5,6]
quick_sort(alist,0,len(alist)-1)
print(alist)
冒泡排序
排序思想：
1.比较相邻的元素。如果第一个比第二个大（升序），就交换他们的位置
2.对每一个相邻于是做同样的步骤，从开始第一对到结尾的最后一对，最后的元素会是最大的数
3.针对所有的元素重复以上的步骤
4.每次对元素重复上述步骤，直到没有任何一对数字需要比较
最优时间复杂度：O(n) （指遍历一次发现没有任何可以交换的元素）
最坏时间复杂度：O(n2)
稳定性：稳定
def buble_sort(alist):
"""冒泡排序"""
for j in range(len(alist)-1,0,-1):
# j 表示每次遍历需要比较的次数，是逐渐减小的
for i in range(j):
if alist[i] > alist[i+1]: # 交换位置
alist[i],alist[i+1] = alist[i+1],alist[i]
alist = [4,2,3,7,9,1,8,5,6]
buble_sort(alist)
print(alist)
选择排序
排序思想：
1.首先，在未排序系列中找到最小（大）元素，存放到排序序列的起始位置；
2.然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾；
3.以此类推，直到所有元素均排序完毕
最优时间复杂度：O(n2)
最坏时间复杂度：O(n2)
稳定性：不稳定
def selection_sort(alist):
"""选择排序"""
n = len(alist)
# 需要进行n-1次选择
for i in range(n-1):
# 记录最小位置
min_index = i
# 从i+1位置到末尾选择出最小数据
for j in range(i+1,n):
if alist[j] < alist[min_index]:
min_index = j
# 循环结束表示找到了最小值，将最小值交换到靠前的位置
if min_index != i:
alist[i],alist[min_index] = alist[min_index],alist[i]
alist = [4,2,3,7,9,1,8,5,6]
selection_sort(alist)
print(alist)
插入排序
排序思想：
构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后移位，给最新元素提供插入空间。
最优时间复杂度：O(n) （序列已经处于升序状态）
最坏时间复杂度：O(n2)
稳定性：稳定
def insert_sort(alist):
"""插入排序"""
# 从第二个位置，即下标为1的元素开始向前插入
for i in range(1,len(alist)):
# 从第i 个元素开始向前比较，如果小于前一个元素，交换位置
for j in range(i,0,-1):
if alist[j] < alist[j-1]:
alist[j],alist[j-1] = alist[j-1],alist[j]
alist = [4,2,3,7,9,1,8,5,6]
insert_sort(alist)
print(alist)
希尔排序
排序思想：
将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列。将数组转换至表示为了更好地理解这算法，算法本身还是使用数组进行排序。
最优时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O(n2)
稳定性：不稳定
def shell_sort(alist):
n = len(alist) # 列表长度
# 初始步长
gap = n // 2
while gap > 0:
# 按步长进行插入排序
for i in range(gap, n):
j = i
# 插入排序
while j >= gap and alist[j - gap] > alist[j]:
alist[j - gap], alist[j] = alist[j], alist[j - gap]
j -= gap
# 得到新的步长
gap = gap // 2
alist = [4,2,3,7,9,1,8,5,6]
shell_sort(alist)
print(alist)
归并排序
排序思想：就是先递归分解数组，再合并数组。
将数组分解最小之后，然后合并两个有序数组，基本思路：比较两个数组的最前面的数，谁小就先取谁，相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分切过来即可。
最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
稳定性：稳定
def merge_sort(alist):
if len(alist) <= 1:
return alist
# 二分解
num = len(alist)//2
left = merge_sort(alist[:num])
right = merge_sort(alist[num:])
# 合并
return merge(left,right)
def merge(left,right):
'''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
# left与right的下标指针
l,r = 0,0
result = []
while l<len(left) and r < len(right):
if left[l] <= right[r]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
result += left[l:]
result += right[r:]
return result
alist = [4,2,3,7,9,1,8,5,6]
sorted_alist = merge_sort(alist)
print(sorted_alist)
基数排序
排序思想
基数排序又称为“桶子法”。以十进制为例，基数指的是数的位，如个位，十位百位等。
将根据整数的最右边数字将其扔进相应的0~9号的篮子里，
对于相同的数字要保持其原来的相对顺序（确保排序算法的稳定性），
然后将篮子里的数如图radix_sort.jpg所示的串起来，然后再进行第二趟的收集（按照第二位的数字进行收集），
就这样不断的反复，当没有更多的位时，串起来的数字就是排好序的数字。
最优时间复杂度：O(d(n+rd))
最坏时间复杂度：O(d(r+n))
稳定性：稳定
def radix_sort(alist):
bucket, digit = [[]], 0
while len(bucket[0]) != len(alist):
bucket = [[], [], [], [], [], [], [], [], [], []] # 桶
for i in range(len(alist)): # 这里的len为9
num = (alist[i] // 10 ** digit) % 10
bucket[num].append(alist[i]) # 在对应的桶中存放对应的数
alist.clear()
for i in range(len(bucket)):
alist += bucket[i]
digit += 1
alist = [4,2,3,7,9,1,8,5,6]
radix_sort(alist)
print(alist)
堆排序
排序思想
它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。
堆分为大根堆和小根堆，是完全二叉树。
大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。
在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
稳定性：不稳定
import copy
def heap_sort(alist):
def heap_adjust(parent):
child = 2 * parent + 1
while child < len(heap):
if child + 1 < len(heap):
if heap[child + 1] > heap[child]:
child += 1
if heap[parent] >= heap[child]:
break
heap[parent], heap[child] = heap[child], heap[parent]
parent, child = child, 2 * child + 1
heap, alist = copy.copy(alist), []
for i in range(len(heap) // 2, -1, -1):
heap_adjust(i)
while len(heap) != 0:
heap[0], heap[-1] = heap[-1], heap[0]
alist.insert(0, heap.pop())
heap_adjust(0)
return alist
alist = heap_sort([4,2,3,7,9,1,8,5,6])
print(alist)
以上排序算法使用python编写，仅供学习参考。