几种经典排序方法在python中的实现

类别排序方法:

'''

插入排序的基本操作是将一个数据插入到有序数据中，从而得到一个编号加一的新的有序数据。该算法适合对少量数据进行排序，时间复杂度为O (n 2)。是一种稳定的排序方法。

插入算法将要排序的数组分成两部分:

第一部分包含这个数组的所有元素，除了最后一个元素(让数组多一个空间来插入)

第二部分只包含这个元素(即要插入的元素)。

第一部分排序后，将最后一个元素插入排序后的第一部分。

'''

def insert_sort(列表):

#插入排序

count = len(列表)

对于范围内的I(1，计数):

key =列表[i]

j = i - 1

而j & gt= 0:

if列表[j]& gt；关键:

列表[j + 1] =列表[j]

列表[j] =键

j -= 1

返回列表

'''

外壳排序是插入排序的一种。也称为缩减增量排序，它是直接插入排序算法的更高效和改进版本。希尔排序是一种不稳定的排序算法。这种方法是由dl提出后命名的。壳牌在1959。

Hill排序是将记录按照目标的一定增量进行分组，使用直接插入排序算法对每组进行排序；随着增量逐渐减小，每个组包含的关键词越来越多。当增量减少到1时，整个文件正好分成一组，算法终止。

'''

def shell_sort(列表):

#希尔排序

count = len(列表)

步骤= 2

组=计数/步

while group & gt0:

对于范围内的I(0，组):

j = i +组

而j & lt计数:

k = j -群

key =列表[j]

而k & gt= 0:

if列表[k]& gt；关键:

列表[k +组] =列表[k]

列表[k] =键

k -=组

j +=组

group /= step

返回列表

'''

冒泡排序已经反复访问了要排序的序列，一次比较两个元素，如果它们的顺序错了就交换。访问系列的工作一直重复，直到不需要交换为止，也就是说系列已经排序了。

'''

定义冒泡_排序(列表):

#冒泡排序

count = len(列表)

对于范围内的I(0，计数):

对于范围内的j(I+1，计数):

if列表[I]& gt；列表[j]:

temp = lists[j]

列表[j] =列表[i]

列表[i] =临时

返回列表

'''

快速排序

通过一次排序将待排序的数据分成两个独立的部分，其中一部分的所有数据都小于另一部分，然后按照这种方法对这两部分数据进行快速排序，整个排序过程可以递归进行，从而实现整个数据成为一个有序序列。

'''

def quick_sort(列表，左，右):

#快速排序

如果离开& gt=右:

返回列表

key =列表[左]

低=左

高=右

同时离开& lt右:

同时离开& lt权限和列表[权限]& gt；=键:

右-= 1

列表[左] =列表[右]

同时离开& lt右和列表[左]& lt；=键:

left += 1

列表[右] =列表[左]

列表[右] =键

quick_sort(列表，低位，左- 1)

quick_sort(列表，左+ 1，高)

返回列表

'''

直接选择排序

传递1，从要排序的记录中选择最小的记录，与r[1]交换；

第二遍，从待排序的记录r[2] ~ r[n]中选择最小的记录，与r[2]交换；

以此类推，在第I遍待排序的记录r[i] ~ r[n]中选择最小的记录，与r[i]交换，使有序序列不断增长，直到所有记录排序完毕。

'''

定义select_sort(列表):

#选择排序

count = len(列表)

对于范围内的I(0，计数):

最小值= i

对于范围内的j(I+1，计数):

if列表[min]& gt；列表[j]:

最小值= j

temp =列表[分钟]

列表[min] =列表[i]

列表[i] =临时

返回列表

'''

Heapsort是指利用堆树(heap)的数据结构设计的一种排序算法，是一种选择性排序。

您可以使用数组的特征来快速定位指定索引的元素。堆分为大根堆和小根堆，是一棵完整的二叉树。大根堆的要求是每个节点的值不大于其父节点的值，即a[parent[I]]>；= A[i].

在非降序排列的数组中，需要根堆，因为根据根堆的要求，最大值必须在堆的顶部。

'''

#调整堆

def adjust_heap(列表，I，大小):

lchild = 2 * i + 1

rchild = 2 * i + 2

最大值= i

如果我& lt尺寸/ 2:

如果lchild & lt大小和列表[lchild]>列表[最大]:

max = lchild

如果rchild & lt大小和列表[rchild]& gt；列表[最大]:

max = rchild

如果max！=我:

列表[最大值]，列表[i] =列表[i]，列表[最大值]

adjust_heap(列表，最大值，大小)

#创建堆

def build_heap(列表，大小):

对于范围内的I(0，(大小/2))[::-1]:

adjust_heap(列表，I，大小)

#堆排序

定义堆排序(列表):

size = len(列表)

build_heap(列表，大小)

对于范围(0，大小)[::-1]中的I:

列表[0]，列表[i] =列表[i]，列表[0]

adjust_heap(lists，0，I)

'''

归并排序是一种基于归并操作的有效排序算法，是分而治之的一个非常典型的应用。合并有序子序列以获得完全有序的序列；也就是说，首先对每个子序列进行排序，然后对子序列段进行排序。如果两个有序表合并成一个有序表，称为双向合并。

合并过程如下:

比较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]。

'''

定义合并(左、右):

I，j = 0，0

结果= []

而我& ltlen(左)和j & lt伦(右):

如果离开[I]& lt；= right[j]:

result.append(left[i])

i += 1

否则:

result.append(右[j])

j += 1

result += left[i:]

result += right[j:]

回送结果

定义合并排序(列表):

#合并排序

if len(列表)& lt= 1:

返回列表

num = len(列表)/ 2

left = merge_sort(列表[:数量])

right = merge_sort(lists[num:])

返回合并(左，右)

'''

基数排序属于“分布排序”，也称为“桶排序”或bin排序。顾名思义，它通过键值的一些信息，将待排序的元素分布到一些“桶”中，从而实现排序功能。基数排序属于稳定排序。

它的时间复杂度为O (nlog(r)m)，其中r是采用的基数，m是堆号。在某些情况下，基数排序法的效率高于其他稳定排序法。

'''

导入数学

def radix_sort(列表，radix=10):

k = int(math . ceil(math . log(max(lists)，radix)))

bucket = [[] for i in range(radix)]

对于范围内的I(1，k+1):

对于列表中的j:

bucket[j/(radix * *(I-1))%(radix * * I)]。追加(j)

删除列表[:]

对于铲斗中的z:

列表+= z

del z[:]

返回列表

由CRazyDOgen

资料来源:CSDN

原文:/jipang 6225/文章/详情/79975312