python 常用排序算法
转载：https://blog.csdn.net/John_xyz/article/details/78796510
转载：https://www.cnblogs.com/wuxinyan/p/8615127.html
常用的排序算法：冒泡排序，插入排序，归并排序, 快速排序、基数排序、堆排序，直接选择排序。
常用的查找算法：顺序查找，二分查找，哈希表查找和二叉树查找
其中我们应该重点掌握二分查找、归并排序和快速排序，保证能随时正确、完整地写出它们的代码。同时对其他的查找和排序必须能准确说出它们的特点、对其平均时间复杂度、最差时间复杂度、额外空间消耗和稳定性烂熟于胸.
排序算法的稳定性：假设在待排序的记录序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变。即在原序列中r[i]=r[j] r[i]=r[j]r[i]=r[j]， 且r[i] r[i]r[i]在r[j] r[j]r[j]之前，而在排序后的序列中，r[i] r[i]r[i]仍在r[j] r[j]r[j]之前,则称这种排序算法是稳定的；否则是不稳定的
算法性能总览
备注：在pascal中比较容易理解，容易计算的方法是：看看有几重for循环，只有一重则时间复杂度为O(n)，二重则为O(n^2)，依此类推，如果有二分则为O(logn)，二分例如快速幂、二分查找，如果一个for循环套一个二分，那么时间复杂度则为O(nlogn)。
冒泡排序
算法描述：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
#coding=UTF-8
'''
冒泡排序(Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元n n{\displaystyle n}个项目需要O(n 2 ) O(n2)O( {\displaystyle n^{2}}) 的比较次数，且可以原地排序。尽管这个算法是最简单了解和实现的排序算法之一，但它对于包含大量的元素的数列排序是很没有效率的
算法描述：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
---------------------
作者：Johnson0722
来源：CSDN
原文：https://blog.csdn.net/John_xyz/article/details/78796510
版权声明：本文为博主原创文章，转载请附上博文链接！
'''
def bubble_sort(list):
for i in range(len(list)):
for j in range(i+1,len(list)):
if list[i]>list[j]:
list[i],list[j]=list[j],list[i]
return list
def bubbleSort(arr):
for i in range(1, len(arr)):
for j in range(0, len(arr)-i):
if arr[j] > arr[j+1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
list=[4,6,2,8,3,7]
print bubble_sort(list)
list=[6,5,9,8,7,6]
print bubbleSort(list)
插入排序
#coding=UTF-8
'''
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到 O(1) O(1){\displaystyle O(1)} 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间
算法描述
从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5
---------------------
作者：Johnson0722
来源：CSDN
原文：https://blog.csdn.net/John_xyz/article/details/78796510
版权声明：本文为博主原创文章，转载请附上博文链接！
'''
def insert_sort(list):
for i in range(len(list)):
preindex = i-1
current = list[i]
while preindex >= 0 and list[preindex]>current:
list[preindex+1] = list[preindex]
preindex-=1
list[preindex+1] = current
return list
def insert_sort2(ilist):
for i in range(len(ilist)):
for j in range(i):
if ilist[i] < ilist[j]:
ilist.insert(j, ilist.pop(i))
break
return ilist
list=[4,6,2,8,3,7]
print insert_sort(list)
list=[6,5,9,8,7,6]
print insert_sort(list)
归并排序
#coding=UTF-8
'''
归并排序（mergesort），是创建在归并操作上的一种有效的排序算法，效率为 O(nlogn) O(nlogn){\displaystyle O(n\log n)}。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行
算法描述
迭代法
1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾
递归法
1. 将序列每相邻两个数字进行归并操作，形成 ceil(n/2) ceil(n/2){\displaystyle ceil(n/2)} 个序列，排序后每个序列包含两/一个元素
2. 若此时序列数不是1个则将上述序列再次归并，形成 ceil(n/4) ceil(n/4){\displaystyle ceil(n/4)} 个序列，每个序列包含四/三个元素
3. 重复步骤2，直到所有元素排序完毕，即序列数为1
---------------------
作者：Johnson0722
来源：CSDN
原文：https://blog.csdn.net/John_xyz/article/details/78796510
版权声明：本文为博主原创文章，转载请附上博文链接！
'''
def mergeSort(arr):
import math
if(len(arr)<2):
return arr
#middle = math.floor(len(arr)/2)
middle = len(arr)/2
left, right = arr[0:middle], arr[middle:]
return merge(mergeSort(left), mergeSort(right))
def merge(left,right):
result = []
while left and right:
if left[0] <= right[0]:
result.append(left.pop(0));
else:
result.append(right.pop(0));
while left:
result.append(left.pop(0));
while right:
result.append(right.pop(0));
return result
list=[4,6,2,8,3,7]
print mergeSort(list)
list=[6,5,9,8,7,6]
print mergeSort(list)
快速排序
快速排序（Quicksort），在平均状况下，排序 n n{\displaystyle n} 个项目要 O(nlogn) O(nlogn){\displaystyle O(n\log n)}）次比较。在最坏状况下则需要 O(n 2 ) O(n2){\displaystyle O(n^{2})}次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 O(nlogn) O(nlogn){\displaystyle O(n\log n)} 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出
算法描述：
快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）
1. 从数列中挑出一个元素，称为”基准”（pivot）
2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序
#coding=UTF-8 ''' 快速排序（Quicksort），在平均状况下，排序 n n{\displaystyle n} 个项目要 O(nlogn) O(nlogn){\displaystyle O(n\log n)}）次比较。在最坏状况下则需要 O(n 2 ) O(n2){\displaystyle O(n^{2})}次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 O(nlogn) O(nlogn){\displaystyle O(n\log n)} 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出 算法描述： 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists） 1. 从数列中挑出一个元素，称为”基准”（pivot） 2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作 3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序 --------------------- 作者：Johnson0722 来源：CSDN 原文：https://blog.csdn.net/John_xyz/article/details/78796510 版权声明：本文为博主原创文章，转载请附上博文链接！ ''' def quick_sort(list): if list==[]: return [] else: qfirst=list[0] qless = quick_sort([l for l in list[1:] if l < qfirst]) qmore = quick_sort([m for m in list[1:] if m > qfirst]) return qless+[qfirst]+qmore def quick_sort2(array, l, r): if l < r: q = partition(array, l, r) quick_sort2(array, l, q - 1) quick_sort2(array, q + 1, r) def partition(array, l, r): x = array[r] i = l - 1 for j in range(l, r): if array[j] <= x: i += 1 array[i], array[j] = array[j], array[i] array[i + 1], array[r] = array[r], array[i+1] return i + 1 list=[4,6,2,8,3,7] print quick_sort2(list,0,5)
5、归并排序
#coding=UTF-8 ''' 归并排序（mergesort），是创建在归并操作上的一种有效的排序算法，效率为 O(nlogn) O(nlogn){\displaystyle O(n\log n)}。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行 算法描述 迭代法 1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置 3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 4. 重复步骤3直到某一指针到达序列尾 5. 将另一序列剩下的所有元素直接复制到合并序列尾 递归法 1. 将序列每相邻两个数字进行归并操作，形成 ceil(n/2) ceil(n/2){\displaystyle ceil(n/2)} 个序列，排序后每个序列包含两/一个元素 2. 若此时序列数不是1个则将上述序列再次归并，形成 ceil(n/4) ceil(n/4){\displaystyle ceil(n/4)} 个序列，每个序列包含四/三个元素 3. 重复步骤2，直到所有元素排序完毕，即序列数为1 --------------------- 作者：Johnson0722 来源：CSDN 原文：https://blog.csdn.net/John_xyz/article/details/78796510 版权声明：本文为博主原创文章，转载请附上博文链接！ ''' def mergeSort(arr): import math if(len(arr)<2): return arr #middle = math.floor(len(arr)/2) middle = len(arr)/2 left, right = arr[0:middle], arr[middle:] return merge(mergeSort(left), mergeSort(right)) def merge(left,right): result = [] while left and right: if left[0] <= right[0]: result.append(left.pop(0)); else: result.append(right.pop(0)); while left: result.append(left.pop(0)); while right: result.append(right.pop(0)); return result list=[4,6,2,8,3,7] print mergeSort(list) list=[6,5,9,8,7,6] print mergeSort(list)
