Python实现八大排序算法

原创 2016年08月30日 14:17:08

插入排序

描述

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为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]:                temp = lists[j]                lists[j] = lists[i]                lists[i] = temp
   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趟,在待排序记录r[1] ~ r[n]中选出最小的记录,将它与r[1]交换;第2趟,在待排序记录r[2] ~ r[n]中选出最小的记录,将它与r[2]交换;以此类推,第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        temp = lists[min]        lists[min] = lists[i]        lists[i] = temp
   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
版权声明:本文为博主原创文章,未经博主允许不得转载。

八大排序算法(Python实现)

一 冒泡排序 算法描述: 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成 算法思路 1.比...
  • KingsleyTong
  • KingsleyTong
  • 2017年08月26日 11:05
  • 150

八大排序算法PYTHON实现

本文用Python实现了插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序、基数排序。 1、插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而...
  • qq_39597358
  • qq_39597358
  • 2017年08月09日 17:27
  • 80

八大排序算法总结以及python实现

一、概述         排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。    ...
  • u013719780
  • u013719780
  • 2015年10月17日 09:43
  • 5971

【算法】-8大排序算法总结-Python

8大排序算法总结-Python
  • aliceyangxi1987
  • aliceyangxi1987
  • 2016年03月16日 14:52
  • 1125

用Python实现八大排序算法--插入排序

一、概述 八大排序算法分别为: 插入排序,希尔排序,冒泡排序,快速排序,直接选择排序,堆排序,归并排序,基数排序等二、插入排序 1. 概念:插入排序的基本操作就是将一个数据插入到已经排好序的有序...
  • chibangyuxun
  • chibangyuxun
  • 2016年11月01日 16:19
  • 361

用Python实现八大排序算法--堆排序

一、堆排序概述1.堆是一种数据结构 可以将堆看作一棵完全二叉树,这棵二叉树满足,任何一个非叶节点的值都不大于(或不小于)其左右孩子节点的值。 2.堆的存储 一般用数组来表示堆,若根节点存在于序号...
  • chibangyuxun
  • chibangyuxun
  • 2016年11月03日 09:30
  • 1348

用Python实现八大排序算法--归并排序

一、归并排序概述1.归并排序将待排序序列R[0…n-1]看成是n个长度为1的有序序列,将相邻的有序表成对归并,得到n/2个长度为2的有序表;将这些有序序列再次归并,得到n/4个长度为4的有序序列;如此...
  • chibangyuxun
  • chibangyuxun
  • 2016年11月02日 21:02
  • 577

八大排序算法的python实现

# -*- coding: utf-8 -*- # 冒泡排序 def bubble_sort(nums): i = 1 exchanged = True while i < ...
  • Lazz_ann
  • Lazz_ann
  • 2017年10月07日 22:12
  • 82

用Python实现八大排序算法--快速排序

一、概述最近在用Python学习经典的8大排序算法,以巩固基础知识,同时强化自己的Python技能。下面对快速排序做一个简要介绍。快速排序:设要排序的数组是A[0]……A[N-1],首先任意选取一个数...
  • chibangyuxun
  • chibangyuxun
  • 2016年11月02日 11:05
  • 589

python实现的八大排序算法part2

使用python实现八大排序算法中的剩余四个:快速排序、堆排序、归并排序、基数排序 桶排序/基数排序...
  • Lockey23
  • Lockey23
  • 2017年09月01日 15:34
  • 201
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Python实现八大排序算法
举报原因:
原因补充:

(最多只允许输入30个字)