Python之排序算法
冒泡排序
冒泡排序（bubble sort）只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作
下面使用Python对一组数据18，22，11，56，32，57，34，78，从小到大进行排序。
#冒泡排序
def bubble_sort(alist):
n = len(alist)
for j in range(n -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 = [18,22,11,56,32,57,34,78]
bubble_sort(alist)
print(alist)
#时间复杂度
#最优时间复杂度：O(n) (表示遍历一次结束，没有任何需要交换的元素，排序结束)
#最坏时间复杂度：O(n^2)
#稳定性：稳定
运行结果如下：
选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n 个元素的表进行排序总共进行至多 n-1 次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。
下面使用Python对一组数据18，22，11，56，32，57，34，78，从小到大进行排序。
#选择排序
def selection_sort(alist):
n = len(alist)
for i in range(n-1):
min_index = i
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=[18,22,11,56,32,57,34,78]
selection_sort(alist)
print(alist)
#时间复杂度：
#最优时间复杂度：O(2n)
#最坏时间复杂度：O(2n)
#稳定性(考虑升序每次选择的最大的情况)
运行结果：
插入排序
插入排序（英语：InsertionSort）是一种简单直观的排序算法。它的工作原理是通过构 建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
下面使用Python对一组数据18，22，11，56，32，57，34，78，从小到大进行排序。
#插入算法
def insert_sort(alist):
n=len(alist)
for j in range(1,n):
i = j
while i>0:
if alist[i]<alist[i-1]:
alist[i],alist[i-1]=alist[i-1],alist[i]
else:
break
i-=1
if __name__ == '__main__':
alist=[18,22,11,56,32,57,34,78]
print('原数组：')
print(alist)
print('排序后：')
insert_sort(alist)
print(alist)
#时间复杂度
#最优时间复杂度:O(n) (升序排序，序列已经处于升序状态)
#最坏时间复杂度：O(2n)
#稳定性：稳定
运行结果：
快速排序
快速排序（英语：Quicksort），又称为交换排序，通过一趟排序将要排序的数据分割为 独立的两部分。假设要排序的列表是 A[0]……A[N-1]，首先任意选取一个数据（通常选用列表的第一个数）作为基准数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序
#快速排序
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]
#退出循环后，low 与 high 重合，此时所指位置为基准元素的正确位置
#将基准元素放到该位置
alist[low] = mid
#对基准元素的左边的子序列进行快速排序
quick_sort(alist,start,low-1)
#对基准元素的右边的子序列进行快速排序
quick_sort(alist,low+1,end)
alist =[18,22,11,56,32,57,34,78]
quick_sort(alist,0,len(alist)-1)
print(alist)
#时间复杂度
#最优时间复杂度：O（nlogn）
#最坏时间复杂度：O（2n）
#稳定性：不稳定
运行结果如下：
归并排序
归并排序的思想就是先递归分解数组，再合并数组。
将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
下面使用Python对一组数据18，22，11，56，32，57，34，78，从小到大进行排序。
#归并排序
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):
'''合并操作，将两个有序数组eft[]和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 = [18,22,11,56,32,57,34,78]
sorted_alist = merge_sort(alist)
print(sorted_alist)
#时间复杂度
#最优时间复杂度：O(nlogn)
#最坏时间复杂度：O(nlogn)
#稳定性：稳定
运行结果：
学习笔记之python
尚硅谷视频