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)