python实现排序算法_python实现各种排序算法
冒泡排序
"""
分析
1. 算法是一種與語言無關的東西，更確切地說就算解決問題的思路，就是一個通用的思想的問題
2. 冒泡算法作為最簡單的一種排序算法，我們的關注點不應該是代碼本身，而應該是思想
3. 冒泡排序思想的側(cè)重點有兩點：走一趟干到底選出最大的放到右邊；走幾趟能夠把整個序列都排序完畢
4. 當走一趟干到底的時候考慮的是j的取值, 而不是j+1, 這樣能清晰地知道range的范圍應該是什么
5. is_ordered 標志位：如果有序列表就不再排序，直接退出
6. 兩個for循環(huán)的考慮順序：先考慮內(nèi)層循環(huán)的意義，再考慮外層循環(huán)的意義
"""
def bubble_sort(alist):
n = len(alist)
# i 代表的是第幾趟，從1開始，表示第一趟
for i in range(1, n):
is_ordered = True
# j 表示走一趟
for j in range(n-i):
if alist[j] > alist[j+1]:
alist[j], alist[j+1] = alist[j+1], alist[j]
is_ordered = False
if is_ordered:
return
if __name__ == '__main__':
lis = [9, 11, 2, 2, 1, 20, 13]
bubble_sort(lis)
print(lis)
冒泡排序（英語：Bubble Sort）是一種簡單的排序算法。它重復地遍歷要排序的數(shù)列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數(shù)列的工作是重復地進行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個算法的名字由來是因為越小的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端。
冒泡排序算法的運作如下：
比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。這步做完后，最后的元素會是最大的數(shù)。
針對所有的元素重復以上的步驟，除了最后一個。
持續(xù)每次對越來越少的元素重復上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。
選擇排序
"""
分析：
1. 代碼本身不重要，算法思想才是重中之重
2. 選擇排序從概念上把列表分為前后兩部分，前一部分假設是有序的(借助一些操作它就是有序的，這也是一種思想)，后一部分是亂序的
3. 每次從亂序的當中選擇出一個最小值放到前面一部分的最后一個位置，這里體現(xiàn)了選擇的概念
4. 穩(wěn)定性：考慮這樣一種情況，把列表分為前后兩部分，后一部分是有序的，每次從前面一部分選出一個最大值放到后面一部分的第一個位置，
假設第一個元素是99，是最大的，中間還有一個元素99，因為后面的99不比前面的大，所以前面的99放到最后，這樣就不穩(wěn)定了
5. 最優(yōu)時間復雜度：即使已經(jīng)是有序，還是得拿著前面的元素和后面的一個一個地進行比較，所以復雜度是O(n2)
6. 最壞時間復雜度: 內(nèi)層循環(huán)是和n有關的，復雜度是O(n2)
"""
def select_sort(alist):
"""
選擇排序
:param alist:
:return:
"""
n = len(alist)
for j in range(n-1):
min_index = j
for i in range(j + 1, n):
if alist[min_index] > alist[i]:
min_index = i
if min_index != j:
alist[j], alist[min_index] = alist[min_index], alist[j]
選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
選擇排序的主要優(yōu)點與數(shù)據(jù)移動有關。如果某個元素位于正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序?qū)儆诜浅：玫囊环N。
插入排序
"""
1. 插入排序：同樣是把列表分為兩部分，前面一部分有序，后面一部分無序，每次從后面選擇第一個元素插入到前面有序序列中
2. 對一個變量進行加減操作的判斷一般使用while循環(huán)
3. 優(yōu)化：因為前一部分已經(jīng)是從小到大排列的了, 所以如果從后面選出的最小元素大于前面的元素，那么就一定比前面的前面還要大，這時候就不需要進行比較了
4. 最優(yōu)算法復雜度：假設列表已經(jīng)是從小到大排序好, 那么while循環(huán)進入一次就退出，總共進入n-1次，所以算法復雜度是O(n)
5. 最壞算法復雜度：假設列表是完全無序，或者說是從大到小排列的，那么內(nèi)層循環(huán)是n-1 n-2 n-3 ...,和n是有關的，所以復雜度是O(n2)
6. 穩(wěn)定性：因為比較是這樣進行的：拿無序的第一個元素和前面的比較，比如說前面最大66，后面有一個66，因為后面的66不比前面的66大，所以位置不改變，
所以插入排序是穩(wěn)定的
"""
def insert_sort(alist):
"""
選擇排序
:param alist:
:return:
"""
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]
i -= 1
else:
break
插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法。它的工作原理是通過構(gòu)建有序序列，對于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應位置并插入。插入排序在實現(xiàn)上，在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。
希爾排序
"""
希爾排序是通過步長把原來的序列分為好幾部分，每一個部分采用插入排序，然后調(diào)整步長，重復這個過程
最壞時間復雜度考慮gap取1，這就是完全的插入排除
"""
def shell_sort(alist):
n = len(alist)
gap = n // 2
# gap 必須能取到1
while gap > 0:
# 插入算法，與普通的插入算法的區(qū)別就是gap步長
for j in range(gap, n):
i = j
while i > 0:
if alist[i] < alist[i-gap]:
alist[i], alist[i-gap] = alist[i-gap], alist[i]
i -= gap
else:
break
gap //= 2
快速排序
快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort），通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分數(shù)據(jù)分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數(shù)據(jù)變成有序序列。
步驟為：
從數(shù)列中挑出一個元素，稱為"基準"（pivot），
重新排序數(shù)列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數(shù)可以到任一邊）。在這個分區(qū)結(jié)束之后，該基準就處于數(shù)列的中間位置。這個稱為分區(qū)（partition）操作。
遞歸地（recursive）把小于基準值元素的子數(shù)列和大于基準值元素的子數(shù)列排序。
遞歸的最底部情形，是數(shù)列的大小是零或一，也就是永遠都已經(jīng)被排序好了。雖然一直遞歸下去，但是這個算法總會結(jié)束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
"""
1. 快速排序是一種常用的排序算法，本質(zhì)是找到每一個元素在原列表的真實位置
2. 因為需要排序的是原列表，如果quick_sort(alist[0:low]) 這種方式排序的是新列表，和原列表脫離了關系，所以采用多傳參數(shù)的方式，傳的參數(shù)是列表位置
3. 最壞時間復雜度：考慮最壞的情況，每次找到的元素位置就是在最左邊，那時間復雜度是O(n2)
4. 最優(yōu)時間復雜度：考慮最好的情況，每次找到的元素在最中間，每次low和high移動之和是n,總共移動多少次？
每次都是對半分割 2*2*.. = N 個數(shù)字，次數(shù)是logn,所以O(nlogn)
"""
def quick_sort(alist, start, end):
"""
快速排序
:param alist:
:return:
"""
# n = len(alist)
if start >= end:
return
mid = alist[start]
low = start
high = end
while low < high:
# 這里用alist[high] >= mid 而不是alist[high]>mid是為了把所有和中間值相等的都移動到一遍，而不是移來移去
while low < high and alist[high] >= mid:
high -= 1
alist[low] = alist[high]
while low < high and alist[low] < mid:
low += 1
alist[high] = alist[low]
# while low < high:
# while low < high:
# if alist[high] < mid:
# alist[low] = alist[high]
# # 這時候應該移動low了
# break
# # 這個else就是循環(huán)移動
# else:
# high -= 1
# while low < high:
# if alist[low] > mid:
# alist[high] = alist[low]
# # 這時候應該移動high了
# break
# else:
# low += 1
alist[low] = mid
quick_sort(alist, start, low)
quick_sort(alist, low+1, end)
歸并排序
歸并排序是采用分治法的一個非常典型的應用。歸并排序的思想就是先遞歸分解數(shù)組，再合并數(shù)組。
將數(shù)組分解最小之后，然后合并兩個有序數(shù)組，基本思路是比較兩個數(shù)組的最前面的數(shù)，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直至一個數(shù)組為空，最后把另一個數(shù)組的剩余部分復制過來即可。
"""
1. 歸并排序采用遞歸，可以用這個排序算法好好體會一下遞歸的流程思想.其中遞歸編程思想和執(zhí)行思想是有區(qū)別的，編程思想是不考慮底下的層，只著眼于
當前層，最后考慮細枝末節(jié)。執(zhí)行思想是嵌套
2. 最優(yōu)時間復雜度和最壞時間復雜度是一樣的：每一層的歸并用來兩個指針，相加的和是 n ,每次對半分，總共分了logn次(和快速排序一樣)，時間復雜度是O(nlogn)
"""
def merge_sort(alist):
n = len(alist)
if n <= 1:
return alist
# 分為兩部分,對每部分進行排序
mid = n // 2
# 假設這已經(jīng)是排序好的了
left = merge_sort(alist[0:mid])
right = merge_sort(alist[mid:])
# 對排序好的進行合并
left_index = 0
right_index = 0
result = []
while left_index < len(left) and right_index < len(right):
if left[left_index] < right[right_index]:
result.append(left[left_index])
left_index += 1
else:
result.append(right[right_index])
right_index += 1
# 如果左邊先走到盡頭，則把右邊剩余所有加進來；如果右邊先走到盡頭，則把左邊剩余所有加進來
# 最終第一層的result把left 和 right 的result 都包含進來了
result += left[left_index:]
result += right[right_index:]
return result
與50位技術專家面對面20年技術見證，附贈技術全景圖總結(jié)
以上是生活随笔為你收集整理的python实现排序算法_python实现各种排序算法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java语言的编译器可以用python_
- 下一篇： python把中文转英文_Python