一.冒泡排序
原理
冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作 是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。最优时间复杂度O(n)【即恰好符合顺序排列，只遍历一遍】，最差时间复杂度O（n^2）【两个循环】，稳定性好。
步骤
冒泡排序算法的运作如下：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
def bubbleSort(alist):
#冒泡排序
for i in range(0,len(alist)):
for j in range(i+1,len(alist)):
if alist[i]>alist[j]:
alist[i],alist[j]=alist[j],alist[i]
return alist
alist = [4, 2, 5, 7, 1, 6, 9, 3, 8]
print (bubbleSort(alist))
二.插入排序
def insert_sort(lists):
#插入排序
for i in range(1,len(lists)):
key = lists[i]
j = i -1
while j >=0:
if lists[j]>key:
lists[j+1] = lists[j]
lists[j]=key
j -= 1
return lists
lists = [4, 2, 5, 7, 1, 6, 9, 3, 8]
print (insert_sort(lists))
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。
是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第
二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
三.快速排序
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
def quick_sort(lists,left,right):
#快速排序
if left >= right:
return lists
key = lists [left]
low = left
high = right
while left < right:
while left < right and lists[right] >= key:
right -= 1
lists[left]= lists[right]
while left < right and lists[left] <= key:
left += 1
lists[right] = lists[left]
lists[right] = key
quick_sort(lists,low,left-1)
quick_sort(lists,left+1,high)
return lists
if __name__=="__main__":
lists = [4, 2, 5, 7, 1, 6, 9, 3, 8]
print (quick_sort(lists,0,len(lists)-1))四.归并排序
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全 有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j] 复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序 的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序 的区间[s,t]。
def merge_sort(list):
#归并排序
if len(list) <= 1:
return list
mid = int(len(list) / 2)
left = merge_sort(list[:mid])
right = merge_sort(list[mid:])
return merge(left, right)
def merge(left, right):
result = []
i, j = 0, 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
if __name__ == '__main__': list = [4, 2, 5, 7, 6, 9, 3, 8]
print(merge_sort(list))
list2 =[4, 2, 5, 7, 1, 6, 9, 3, 8]
print(merge_sort(list2))
五.直接选择排序
基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类 推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
def select_sort(lists):
# 选择排序
count = len(lists)
for i in range(0, count):
min = i
for j in range(i + 1, count):
if lists[min] > lists[j]:
min = j
lists[min], lists[i] = lists[i], lists[min]
return lists
if __name__=="__main__":
lists=[4, 2, 5, 7, 1, 6, 9, 3, 8]
print(select_sort(lists))
