Python实现八大排序算法(转载)+ 桶排序(原创)
来源:互联网 发布:智慧树网络课程答案doc 编辑:程序博客网 时间:2024/06/05 18:19
- 插入排序
- 核心思想
- 代码实现
- 希尔排序
- 核心思想
- 代码实现
- 冒泡排序
- 核心思想
- 代码实现
- 快速排序
- 核心思想
- 代码实现
- 直接选择排序
- 核心思想
- 代码实现
- 堆排序
- 核心思想
- 代码实现
- 归并排序
- 核心思想
- 代码实现
- 基数排序
- 核心思想
- 代码实现
- 桶排序
- 核心思想
- 代码实现
- 测试结果
- 总结
- 插入排序
排序算法,重要性不言而喻。现摘录一篇,转载至此,以供学习鉴赏。
插入排序
核心思想
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为 O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插 入的位置),而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后,再将这个最后元素插入到已排好序的第一部分中。
代码实现
def insert_sort(lists): # 插入排序 count = len(lists) for i in range(1, count): key = lists[i] j = i - 1 while j >= 0: if lists[j] > key: lists[j + 1] = lists[j] lists[j] = key j -= 1 return lists
希尔排序
核心思想
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于 1959年提出而得名。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分 成一组,算法便终止。
代码实现
def shell_sort(lists): # 希尔排序 count = len(lists) step = 2 group = count / step while group > 0: for i in range(0, group): j = i + group while j < count: k = j - group key = lists[j] while k >= 0: if lists[k] > key: lists[k + group] = lists[k] lists[k] = key k -= group j += group group /= step return lists
冒泡排序
核心思想
它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
代码实现
def bubble_sort(lists): # 冒泡排序 count = len(lists) for i in range(0, count): for j in range(i + 1, count): if lists[i] > lists[j]: lists[i], lists[j] = lists[j], lists[i] return lists
快速排序
核心思想
通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
代码实现
def quick_sort(lists, left, right): # 快速排序 if left >= right: return lists key = lists[left] low = left high = right while left < right: while left < right and lists[right] >= key: right -= 1 lists[left] = lists[right] while left < right and lists[left] <= key: left += 1 lists[right] = lists[left] lists[right] = key quick_sort(lists, low, left - 1) quick_sort(lists, left + 1, high) return lists
直接选择排序
核心思想
基本思想:第1趟,在待排序记录r1 ~ r[n]中选出最小的记录,将它与r1交换;第2趟,在待排序记录r2 ~ r[n]中选出最小的记录,将它与r2交换;以此类推,第i趟在待排序记录r[i] ~ r[n]中选出最小的记录,将它与r[i]交换,使有序序列不断增长直到全部排序完毕。
代码实现
def select_sort(lists): # 选择排序 count = len(lists) for i in range(0, count): min = i for j in range(i + 1, count): if lists[min] > lists[j]: min = j lists[min], lists[i] = lists[i], lists[min] return lists
堆排序
核心思想
堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元 素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即A[PARENT[i]] >= A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。
代码实现
# 调整堆 def adjust_heap(lists, i, size): lchild = 2 * i + 1 rchild = 2 * i + 2 max = i if i < size / 2: if lchild < size and lists[lchild] > lists[max]: max = lchild if rchild < size and lists[rchild] > lists[max]: max = rchild if max != i: lists[max], lists[i] = lists[i], lists[max] adjust_heap(lists, max, size) # 创建堆 def build_heap(lists, size): for i in range(0, (size/2))[::-1]: adjust_heap(lists, i, size) # 堆排序 def heap_sort(lists): size = len(lists) build_heap(lists, size) for i in range(0, size)[::-1]: lists[0], lists[i] = lists[i], lists[0] adjust_heap(lists, 0, i)
归并排序
核心思想
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一 个有序表,称为二路归并。
归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否 则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复 制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现,先把待排序区间[s,t]以中点二分,接着把左边子区间排序,再把右边子区间排序, 最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
代码实现
def merge(left, right): i, j = 0, 0 result = [] while i < len(left) and j < len(right): if left[i] <= right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result += left[i:] result += right[j:] return result def merge_sort(lists): # 归并排序 if len(lists) <= 1: return lists num = len(lists) / 2 left = merge_sort(lists[:num]) right = merge_sort(lists[num:]) return merge(left, right)
基数排序
核心思想
基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数,在某些时候,基数排序法的效率高于其它的稳定性排序法。
代码实现
import math def radix_sort(lists, radix=10): k = int(math.ceil(math.log(max(lists), radix))) bucket = [[] for i in range(radix)] for i in range(1, k+1): for j in lists: bucket[j/(radix**(i-1)) % (radix**i)].append(j) del lists[:] for z in bucket: lists += z del z[:] return lists
以上便是转载别人的常用的排序算法,当然了关于排序算法的实现还有很多,这里我在写一个关于“桶排序”的小例子吧。
桶排序
核心思想
为了节省空间和时间,我们需要指定要排序的数据中最小以及最大的数字的值,来方便桶排序算法的运算。
代码实现
# coding:utf-8import sysreload(sys)sys.setdefaultencoding('utf8')# __author__ = '郭 璞'# __date__ = '2016/9/6'# __Desc__ = 桶排序算法,代码实现def sort(arr): result = [] for index in range(0,len(arr)): result.append(0) for index in range(len(arr)): counter = result[arr[index]]+1 result[arr[index]]=counter return resultif __name__ == '__main__': arr = [1,3,5,7,9,2,9,4,6,8,0,1,1,3,2,2,2,2] arr = sort(arr) for item in range(len(arr)): if arr[item]!=0: step = arr[item] while step>0: print item, step-=1
测试结果
D:\Software\Python2\python.exe E:/Code/Python/DataStructor/temp/BarrelSort.py0 1 1 1 2 2 2 2 2 3 3 4 5 6 7 8 9 9Process finished with exit code 0
总结
以上共介绍了大牛完成的经典的八大排序算法,以及自己实现的一个简单的关于桶排序的小案例。
- Python实现八大排序算法(转载)+ 桶排序(原创)
- 八大排序算法(转载)
- 八大排序算法(python)
- Python实现八大排序算法
- 八大排序算法PYTHON实现
- 八大排序算法(Python实现)
- [转载]八大排序算法
- (转载)八大排序算法
- 八大排序算法(八)桶排序
- Python实现经典排序算法(转载)
- 八大排序算法(Java实现)
- 八大排序算法总结(Java实现)
- 八大排序算法(java实现)
- 八大排序算法(java实现)
- python八大排序算法
- 八大排序算法-Python
- 八大排序算法 python
- 【排序】用Python实现八大排序算法--堆排序
- 用 GStreamer 简化 Linux 多媒体开发
- 架构漫谈(三):如何做好架构之识别问题
- Android多媒体学习六:利用Service实现背景音乐的播放
- URAL 1095 Nikifor 3 (注意读题)
- 手机号码实名认证
- Python实现八大排序算法(转载)+ 桶排序(原创)
- Java多线程 -- JUC包源码分析8 -- 对happen before的深刻理解
- 如何在Visual Sutdio中编写JAVA工程?
- SQL等分组计算 mysql类型转换 2016.09.02回顾
- 如何把vs2003转化成vs2005
- iOS中定时器有三种
- Linux Top 命令解析
- 使用RoboCopy 命令
- How Tomcat works之第十一章之ApplicationFilterChain