一.冒泡排序法
冒泡排序法是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序算法的运作如下：
- 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
代码如下：
# coding:utf-8 def bubble_sort(a_list): # 冒泡排序的次数 n = len(a_list) for i in range(n-1): count = 0 # 游标 for j in range(n-i-1): if a_list[j] > a_list[j+1]: a_list[j],a_list[j+1] = a_list[j+1], a_list[j] count += 1 # 中间的某次已经排序好了，直接跳出循环 if count == 0: break print(a_list) if __name__ == "__main__": a = [13,45,675,123,7,32,89,312,45432] print(a) bubble_sort(a)
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无 聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改 变，所以冒泡排序是一种稳定排序算法。
算法的时间复杂度：
- 最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）
- 最坏时间复杂度：O(n2)
- 稳定性：稳定
二.选择排序法
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。
选择排序过程：- 代码如下：
# coding:utf-8 def selection_sort(a_list): n = len(a_list) # 需进行比较的循环次数 for i in range(n-1): # 建立最小索引 min_index = i for j in range(i+1,n): # 找到最小数值并交换 if a_list[min_index] > a_list[j]: min_index = j a_list[i], a_list[min_index] = a_list[min_index] , a_list[i] print(a_list) if __name__ == "__main__": a = [13,45,675,123,7,32,89,312,45,45432] print(a) selection_sort(a)
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个 元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么 交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
- 最优时间复杂度：O(n2)
- 最坏时间复杂度：O(n2)
- 稳定性：不稳定（考虑升序每次选择最大的情况）
三.插入排序法
插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
插入排序过程：
代码如下：
# coding:utf-8 def insert_sort(a_list): n = len(a_list) # 从右边无序序列取出多少个元素执行这样的过程 for j in range(1,n): i = j # 内层循环，从右侧无需序列取出元素，插入前面序列正确位置 while i > 0: if a_list[i] < a_list[i-1]: a_list[i], a_list[i-1] = a_list[i-1] , a_list[i] i -= 1 # 拿出的元素大于等于，跳出循环 else: break print(a_list) if __name__ == "__main__": a = [13,45,675,123,7,32,89,312,45,45432] print(a) insert_sort(a)
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开 始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相 等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳 定的。
- 最优时间复杂度：O(n) （升序排列，序列已经处于升序状态）
- 最坏时间复杂度：O(n2)
- 稳定性：稳定
四.希尔排序法
希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。
排序过程分析：
参考代码：
# coding:utf-8 def shell_sort(a_list): n = len(a_list) # 对gap取整 gap = n//2 # gap==1为普通的插入排序 while gap >= 1: # 从右边无序序列取出多少个元素执行这样的过程 for j in range(gap,n): i = j # 内层循环，从右侧无需序列取出元素，插入前面序列正确位置 while i > 0: if a_list[i] < a_list[i-gap]: a_list[i], a_list[i-gap] = a_list[i-gap] , a_list[i] i -= gap # 拿出的元素大于等于左端最大数，执行 else: break # 缩短gap步长 gap = gap // 2 print(a_list) if __name__ == "__main__": a = [13,45,675,123,7,32,89,312,45,45432] print(a) shell_sort(a)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元 素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
- 最优时间复杂度：根据步长序列的不同而不同
- 最坏时间复杂度：O(n2)
- 稳定想：不稳定
五.归并排序法：
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。
将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
归并排序过程：
参考代码：
# coding:utf-8
def merge_sort(a_list):
n = len(a_list)
if n <=1:
# 返回分割好的列表
return a_list
mid = n//2
# 归并后形成有序的新列表
left_list = merge_sort(a_list[:mid])
right_list = merge_sort(a_list[mid:])
left_pointer, right_pointer = 0, 0
# 用于接收排序后的新列表
result=[]
while left_pointer < len(left_list) and right_pointer < len(right_list):
if left_list[left_pointer] <= right_list[right_pointer]:
result.append(left_list[left_pointer])
left_pointer += 1
else:
result.append(right_list[right_pointer])
right_pointer += 1
# 一端列表先走到头，进行追加，切片超出索引范围返回值为空
result += left_list[left_pointer:]
result += right_list[right_pointer:]
# 直接对原列表进行操作，返回排序号的列表
return result
if __name__ == "__main__":
a = [13,45,675,123,7,32,89,312,45,45432,33]
print(a)
sorted_list = merge_sort(a)
print(sorted_list)
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有 序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定 性。那么，在短的有序序列合并的过程中，稳定是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结 果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。
- 最优时间复杂度：O(nlogn)
- 最坏时间复杂度：O(nlogn)
- 稳定性：稳定
六.快速排序法：
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
步骤为：
- 从数列中挑出一个元素，称为"基准"（pivot）。
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
参考代码：
# coding:utf-8 def quick_sort(a_list,start,end): '''快速排序法''' if start >= end: return # 起始值设为中间值 mid_value = a_list[start] low = start high = end while low != high: # 移动high游标向左 while low < high and a_list[high] >= mid_value: high -= 1 a_list[low] = a_list[high] # 移动low游标向右 while low < high and a_list[low] < mid_value: low += 1 a_list[high] = a_list[low] # 循环退出时 low == high a_list[high] = mid_value # 嵌套调用，传输原有的列表 # low左端 quick_sort(a_list,start,high-1) # low右端 quick_sort(a_list,high+1,end) if __name__ == "__main__": a = [13,45,675,123,7,32,89,312,45,45432] print(a) quick_sort(a,0,len(a)-1) print(a)
- 最优时间复杂度：O(nlogn)
- 最坏时间复杂度：O(n2)
- 稳定性：不稳定
从一开始快速排序平均需要花费O(n log n)时间的描述并不明显。但是不难观察到的是分区运算，数组的元素都会在每次循环中走访过一次，使用O(n)的时间。在使用结合（concatenation）的版本中，这项运算也是O(n)。
在最好的情况，每次我们运行一次分区，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)。但是在同一层次结构的两个程序调用中，不会处理到原来数列的相同部分；因此，程序调用的每一层次结构总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一层次结构仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。
七.二分查找：
二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
递归版：
# coding:utf-8
def binary_search(a_list,item):
'''递归二分法查找'''
n = len(a_list)
if n > 0:
mid = n//2
if a_list[mid] == item:
return True
elif item < a_list[mid]:
return binary_search(a_list[:mid],item)
else:
return binary_search(a_list[mid+1:],item)
return False
if __name__ == "__main__":
a = [17,23,35,45,59,61,75,82,91]
print(binary_search(a,59))
非递归版：
# coding:utf-8
def binary_search(a_list,item):
'''归并排序法'''
n = len(a_list)
start= 0
end = n-1
while start <= end:
mid = (start + end) // 2
if a_list[mid] == item:
return True
elif a_list[mid] < item:
start = mid +1
else:
end = mid -1
return False
if __name__ == "__main__":
a = [17,23,35,45,59,61,75,82,91]
print(binary_search(a,45))
- 时间复杂度
- 最优时间复杂度：O(1)
- 最坏时间复杂度：O(logn)