Python 排序算法

一、冒泡排序

　　#最优时间复杂度：O(n) 最坏时间复杂度：O(n**2),稳定性：稳定

　　def bubble_sort(list):
　　　　n = len(list)-1
　　　　#控制循环次数
　　　　for j in range(n):
　　　　　　flag = 0
　　　　　　#控制每次循环行进到的位置
　　　　　　for i in range(n-j):
　　　　　　　　if list[i] > list[i+1]:
　　　　　　　　　　list[i],list[i+1] = list[i+1],list[i]
　　　　　　　　　　flag = 1
　　　　　　if flag == 0:
　　　　　　　　return

　　list = [4,2,6,8,3,216,4721,31,546,675]
　　bubble_sort(list)
　　print(list)

二、选择排序

　　#最优时间复杂度：O(n**2),最坏时间复杂度：O(n**2),稳定性：不稳定

　　def chooseSort(list):
　　　　n = len(list)
　　　　for i in range(n-1):
　　　　　　min = i
　　　　　　for j in range(i+1,n):
　　　　　　　　if list[j] < list[min]:
　　　　　　　　　　min = j
　　　　　　if min != i:
　　　　　　　　list[i],list[min] = list[min],list[i]

三、插入排序

　　#最优时间复杂度：O(n) ,最坏时间复杂度：O(n**2),稳定性：稳定

　　def insertSort(list):
　　　　n = len(list)
　　　　for j in range(1,n):
　　　　　　i = j
　　　　　　while i >0:
　　　　　　　　if list[i] < list[i-1]:
　　　　　　　　　　list[i],list[i-1] = list[i-1],list[i]
　　　　　　　　　　i -= 1
　　　　　　　　else:
　　　　　　　　　　break

四、希尔排序

　　#最优时间复杂度：根据步长序列的不同而不同，最坏时间复杂度：O(n**2)，稳定想：不稳定

　　def shellSort(list):
　　　　n = len(list)
　　　　gap = n // 2

　　　　while gap > 0:
　　　　　　for j in range(gap,n):
　　　　　　　　i = j
　　　　　　　　while i > 0:
　　　　　　　　　　if list[i] < list[i-gap]:
　　　　　　　　　　　　list[i],list[i-gap] = list[i-gap],list[i]
　　　　　　　　　　　　i -= gap
　　　　　　　　　　else:
　　　　　　　　　　　　break
　　　　　　gap //= 2

五、快速排序（重要）

　　#最优时间复杂度：O(nlogn)，最坏时间复杂度：O(n**2)，稳定性：不稳定

　　def quick_sort(list,start,over):
　　　　if start >= over:
　　　　　　return
　　　　mid_value = list[start]
　　　　low = start
　　　　high = over

　　　　while low < high:
　　　　　　while low < high and list[high] >= mid_value:
　　　　　　　　high -= 1
　　　　　　list[low] = list[high]

　　　　　　while low < high and list[low] < mid_value:
　　　　　　　　low += 1
　　　　　　list[high] = list[low]

　　　　list[low] = mid_value

　　　　quick_sort(list,start,low-1)
　　　　quick_sort(list,low+1,over)

 

 

六、归并排序

　　#最优时间复杂度：O(nlogn)，最坏时间复杂度：O(nlogn)，稳定性：稳定

　　def merge_sort(list):
　　　　n = len(list)
　　　　if n <= 1:
　　　　　　return list
　　　　#拆分
　　　　mid = n // 2
　　　　left_li = merge_sort(list[:mid])
　　　　right_li = merge_sort(list[mid:])

　　　　#合并
　　　　left_pointer,right_pointer = 0,0
　　　　result = []
　　　　while left_pointer < len(left_li) and right_pointer < len(right_li):
　　　　　　if left_li[left_pointer] <= right_li[right_pointer]:
　　　　　　　　result.append(left_li[left_pointer])
　　　　　　　　left_pointer += 1
　　　　　　else:
　　　　　　　　result.append(right_li[right_pointer])
　　　　　　　　right_pointer += 1
　　　　result += left_li[left_pointer:]
　　　　result += right_li[right_pointer:]
　　　　return result

 

转载于:https://www.cnblogs.com/dalun101/p/9369931.html