冒泡排序
"""
分析
1. 算法是一種與語言無關的東西，更確切地說就算解決問題的思路，就是一個通用的思想的問題
2. 冒泡算法作為最簡單的一種排序算法，我們的關注點不應該是代碼本身，而應該是思想
3. 冒泡排序思想的側重點有兩點：走一趟干到底選出最大的放到右邊；走幾趟能夠把整個序列都排序完畢
4. 當走一趟干到底的時候考慮的是j的取值, 而不是j+1, 這樣能清晰地知道range的范圍應該是什么
5. is_ordered 標志位：如果有序列表就不再排序，直接退出
6. 兩個for循環的考慮順序：先考慮內層循環的意義，再考慮外層循環的意義
"""
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）是一種簡單的排序算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
冒泡排序算法的運作如下：
比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。
針對所有的元素重復以上的步驟，除了最后一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
選擇排序
"""
分析：
1. 代碼本身不重要，算法思想才是重中之重
2. 選擇排序從概念上把列表分為前后兩部分，前一部分假設是有序的(借助一些操作它就是有序的，這也是一種思想)，后一部分是亂序的
3. 每次從亂序的當中選擇出一個最小值放到前面一部分的最后一個位置，這里體現了選擇的概念
4. 穩定性：考慮這樣一種情況，把列表分為前后兩部分，后一部分是有序的，每次從前面一部分選出一個最大值放到后面一部分的第一個位置，
假設第一個元素是99，是最大的，中間還有一個元素99，因為后面的99不比前面的大，所以前面的99放到最后，這樣就不穩定了
5. 最優時間復雜度：即使已經是有序，還是得拿着前面的元素和后面的一個一個地進行比較，所以復雜度是O(n2)
6. 最壞時間復雜度: 內層循環是和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）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。
插入排序
"""
1. 插入排序：同樣是把列表分為兩部分，前面一部分有序，后面一部分無序，每次從后面選擇第一個元素插入到前面有序序列中
2. 對一個變量進行加減操作的判斷一般使用while循環
3. 優化：因為前一部分已經是從小到大排列的了, 所以如果從后面選出的最小元素大於前面的元素，那么就一定比前面的前面還要大，這時候就不需要進行比較了
4. 最優算法復雜度：假設列表已經是從小到大排序好, 那么while循環進入一次就退出，總共進入n-1次，所以算法復雜度是O(n)
5. 最壞算法復雜度：假設列表是完全無序，或者說是從大到小排列的，那么內層循環是n-1 n-2 n-3 ...,和n是有關的，所以復雜度是O(n2)
6. 穩定性：因為比較是這樣進行的：拿無序的第一個元素和前面的比較，比如說前面最大66，后面有一個66，因為后面的66不比前面的66大，所以位置不改變，
所以插入排序是穩定的
"""
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）是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。插入排序在實現上，在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。
希爾排序
"""
希爾排序是通過步長把原來的序列分為好幾部分，每一個部分采用插入排序，然后調整步長，重復這個過程
最壞時間復雜度考慮gap取1，這就是完全的插入排除
"""
def shell_sort(alist):
n = len(alist)
gap = n // 2
# gap 必須能取到1
while gap > 0:
# 插入算法，與普通的插入算法的區別就是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），通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
步驟為：
從數列中挑出一個元素，稱為"基准"（pivot），
重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准值大的擺在基准的后面（相同的數可以到任一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。
遞歸地（recursive）把小於基准值元素的子數列和大於基准值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
"""
1. 快速排序是一種常用的排序算法，本質是找到每一個元素在原列表的真實位置
2. 因為需要排序的是原列表，如果quick_sort(alist[0:low]) 這種方式排序的是新列表，和原列表脫離了關系，所以采用多傳參數的方式，傳的參數是列表位置
3. 最壞時間復雜度：考慮最壞的情況，每次找到的元素位置就是在最左邊，那時間復雜度是O(n2)
4. 最優時間復雜度：考慮最好的情況，每次找到的元素在最中間，每次low和high移動之和是n,總共移動多少次？
每次都是對半分割 2*2*.. = N 個數字，次數是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就是循環移動
# 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)
歸並排序
歸並排序是采用分治法的一個非常典型的應用。歸並排序的思想就是先遞歸分解數組，再合並數組。
將數組分解最小之后，然后合並兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可。
"""
1. 歸並排序采用遞歸，可以用這個排序算法好好體會一下遞歸的流程思想.其中遞歸編程思想和執行思想是有區別的，編程思想是不考慮底下的層，只着眼於
當前層，最后考慮細枝末節。執行思想是嵌套
2. 最優時間復雜度和最壞時間復雜度是一樣的：每一層的歸並用來兩個指針，相加的和是 n ,每次對半分，總共分了logn次(和快速排序一樣)，時間復雜度是O(nlogn)
"""
def merge_sort(alist):
n = len(alist)
if n <= 1:
return alist
# 分為兩部分,對每部分進行排序
mid = n // 2
# 假設這已經是排序好的了
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
