一、排序算法

• 冒泡排序
• 選擇排序
• 插入排序
• 希爾排序
• 快速排序
• 歸并排序
• 堆排序
• 桶排序

二、算法實現

冒泡排序
每次比較相鄰兩個元素，若不符合大小關系，則交換元素位置。讓最小的（或最大）元素在列表尾部
外循環：控制循環次數
內循環：未排序的列表部分

# coding:utf-8 ''' 冒泡排序，每次與后面一個元素比較 不符合大小關系，則交換元素位置 ''' def bubble(arr):l = len(arr)k = 1for i in range(l-1): # 控制循環次數for j in range(l-i-1):if arr[j] > arr[j+1]:arr[j],arr[j+1] = arr[j+1],arr[j]print(k,' ',arr)k += 1

選擇排序
每次遍歷數組，選出最小（或最大）的元素，與列表前面部分的元素交換位置。
跳躍交換，選擇排序不穩定

# coding:utf-8 def select_sort(arr):'''選擇排序每次遍歷數組，選出最小（或最大）的元素，與列表前面部分的元素交換位置:param arr::return:'''n = len(arr)for i in range(n-1):min_index = ifor j in range(i+1,n):if arr[min_index]>arr[j]:min_index = jarr[i],arr[min_index] = arr[min_index],arr[i]

插入排序
保證列表前面是有序的。
從列表后面部分，有一次選擇元素，插入列表前面部分

def insert_sort(arr):'''插入排序保證列表前面是有序的。從列表后面部分，有一次選擇元素，插入列表前面部分:param arr::return:'''n = len(arr)for i in range(1,n): #未排序部分while i > 0: # 與前面有序部分比較if arr[i] > arr[i-1]:i -= 1else:arr[i],arr[i-1] = arr[i-1],arr[i]

希爾排序
希爾排序是插入排序的升級版。跟據間隔，分成多個組，組內使用插入排序。縮減gap的值，知道為1.

def shell_sort(arr):n = len(arr)gap = n//2while gap > 0:for i in range(gap,n):while i > 0:if arr[i]>arr[i-gap]:i -= gapelse:arr[i],arr[i-gap]=arr[i-gap],arr[i]gap = gap // 2

快速排序
遞歸的方法，每次找出所排列表的首位元素在列表中的位置，然后以此位置，將列表分為兩個部分，繼續查找位置，交換

def quick_sort(arr,first,end):'''快速排序.不新建列表，加起始位置:param arr: 待排序的列表:param first: 待排序的列表的起始位置:param end: 待排序的列表結束位置:return:無選擇待排序數組的第一個元素pivot，確定它的位置.'''l = arr[first:end+1]if first >= end:returnpivot = arr[first]left = first# 數組頭部指針right = end# 數組尾部指針while left< right:while left < right and arr[right] >= pivot:right -= 1arr[left] = arr[right]while left < right and arr[left] <= pivot:left += 1arr[right] = arr[left]arr[left] = pivotquick_sort(arr,first,left-1)quick_sort(arr,left+1,end)

歸并排序
1） 先將數組對分對分，直至變成單個元素
2） 然后兩兩比較合并，知道變成一個有序的序列
3） 歸并排序過程比較像中根遍歷的過程。
　a. 排序arr[0,n],拆分成arr[0,n/2]和arr[n/2,n]的排序問題
　b. 先看左邊，arr[0,n/2]排序。查分成arr[0,n/4]和arr[n/4,n/2]的排序問題。假如n=4.現在arr[0,n/4]和arr[n/4,n/2]成了單個元素排序，返回列表本身。
　 c. 接下來就是合并了。合并arr[0,n/4]和arr[n/4,n/2]，就解決了arr[0,n/2]。
　d. 為了解決arr[0,n]排序，還需要處理arr[n/2,n]的排序問題。與左半部分類似
歸并排序的將排序的數組的長度對半分，它的時間復雜度是$O(nlog(n))$,但是需要額外的存儲空間，加上數據存取的時間，是否比前面的一些排序算法的素的快，值得商榷。

def merge_sort(arr):'''歸并排序先將數組對分對分，直至變成單個元素然后兩兩比較合并，知道變成一個有序的序列歸并排序過程比較像中根遍歷的過程:param arr::return:'''if len(arr) <=1 :return arrn = len(arr)mid = n //2left = merge_sort(arr[:mid])# 返回一個列表right = merge_sort(arr[mid:])result= []left_index = 0# 指向左邊的數組right_index = 0# 指向右邊的數組while left_index<len(left) and right_index < len(right):# 任一列表遍歷到尾部，跳出循環if left[left_index] <= right[right_index]:result.append(left[left_index])left_index += 1else:result.append(right[right_index])right_index += 1result += left[left_index:] #剩余部分result += right[right_index:]return result

三、不同算法間比較

排序算法的穩定性 ：原來在前面，還是在前面

排序算法最優時間復雜度最壞時間復雜度輔助空間穩定性

冒泡排序	$O(n)$	$O(n_2)$	$O(1)$	穩定
選擇排序	$O(n^2)$	$O(n_2)$	$O(1)$	不穩定
插入排序	$O(n)$	$O(n_2)$	$O(1)$	穩定
希爾排序	$O(n^{1.3})$	$O(n_2)$	$O(1)$	不穩定
快速排序	$O(nlogn)$	$O(n_2)$	$O(1)$	不穩定
歸并排序	$O(nlogn)$	$O(nlogn)$	$O(n)$	不穩定

總結

以上是生活随笔為你收集整理的算法与数据结构 -- 排序和查找（五）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。