8个常用排序算法之 python实现

来源：互联网发布：内部链接优化注意问题编辑：程序博客网时间：2024/06/04 05:17

1、冒泡

#!/usr/bin/env

# coding:utf-8

# 排序算法之冒泡排序（1. 稳定排序）

# 2. 时间复杂度为 o(n, n^2)
# 3. 基本思想是：

# 两两比较相邻元素，如果反序则交换，直到没有反序的记录为止
# 4. 适用：n较小

class Solution:
def bubble(self, alist):
#
L = len(alist)
for i in range(L):
for j in range(i+1, L):
if alist[i] > alist[j]:
alist[i], alist[j] = alist[j], alist[i]
return alist
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.bubble(alist)

2、选择排序

#!/usr/bin/env

# coding:utf-8

# 直接选择排序（递减增量排序算法）（1. 不稳定排序）
# 2. 时间复杂度为O(n^2).

# 3. 基本思想是：

# 首先在所有记录中选出序码最小的记录，把它与第1个记录交换，

# 然后在其余的记录内选出排序码最小的记录，与第2个记录交换......依次类推，直到所有记录排完为止
# 4. 适用：n较小

class Solution:
# 直接选择排序
def Select_Sort(self, alist):
# 选择排序
count = len(alist)
for i in range(0, count):
min = i
for j in range(i + 1, count):
if alist[min] > alist[j]:
min = j
alist[min], alist[i] = alist[i], alist[min]
return alist
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.Select_Sort(alist)

3、希尔排序

#!/usr/bin/env

# coding:utf-8

# 希尔(Shell)排序（递减增量排序算法）（1. 不稳定排序）
# 2. 希尔排序的执行时间依赖于增量序列，其平均时间复杂度为O(n^(3/2)),下界为n*log2n.

# 3. 基本思想是：

# 先取一个小于n的整数d1作为第一个增量把文件的全部记录分成d1个组。

# 所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；

# 然后，取得第二个增量d2<d1重复上述的分组和排序，直至所取的增量di=1，即所有记录放在同一组中进行直接 # 插入排序为止。

# 该方法实质上是一种分组插入方法。
# 4. 适用：n较小

# 一般取d1=n/2，di+1=di/2。如果结果为偶数，则加1，保证di为奇数。

class Solution:
# 插入排序
def Shell(self, alist):
# 设定步长
step = len(alist)/2
while step > 0:
for i in range(step, len(alist)):
# 类似插入排序, 当前值与指定步长之前的值比较, 符合条件则交换位置
while i >= step and alist[i-step] > alist[i]:
alist[i], alist[i-step] = alist[i-step], alist[i]
i -= step
step = step/2
return alist
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.Shell(alist)

4、直接插入

#！usr/bin/env

# coding:utf-8

# 排序算法之直接插入（1. 稳定排序）
# 2. 时间复杂度为(n, n^2)

# 3. 基本思想是：
# 每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

# 优点：（1）稳定排序

# （2）所需辅助空间为1

# （3）基本有序时性能比冒泡和选择要好
# 4. 适用：n较小，基本有序，结果稳定

class Solution:
# 插入排序
def insert(self, alist):
# 循环查找
for index in range(1, len(alist)):
cur = alist[index]
position = index
# 查找交换
while position > 0 and alist[position - 1] > cur:
alist[position] = alist[position - 1]
position -= 1
alist[position] = cur
return alist
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.insert(alist)

5、快排

#!/usr/bin/env

# coding:utf-8

# 排序算法之快速排序（1. 不稳定排序）
# 2. 时间复杂度为 0(nlogn, n^2)、空间复杂度最好o(logn), 最坏为o(n)，平均o(logn)

# 3. 快速排序采用了一种分治的策略，通常称其为分治法，

# 其基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这
# 些子问题的解组合为原问题的解。

# 快速排序的具体过程如下：

# 第一步，在待排序的n个记录中任取一个记录，以该记录的排序码为准，将所有记录分成两组，

# 第1组各记录的排序码都小于等于该排序码，第2组各记录的排序码都大于该排序码，并把该记录排在这
# 两组中间。

# 第二步，采用同样的方法，对左边的组和右边的组进行排序，直到所有记录都排到相应的位置为止。
# 4. 适用：n较大，注意递归的溢出

class Solution:
def quick_sort(self, alist,low, high):
# 对序列alist[low,...high]z做快速排序
if low < high:
pivot = self.Partition(alist, low, high)
self.quick_sort(alist, low, pivot-1)
self.quick_sort(alist, pivot+1, high)
return alist
def Partition(self, alist, low, high):
# 取子表第一个记录作为枢轴记录
pivot_key = alist[low]
# 从表的两端交替向中间扫描
while low < high:
# 将比枢轴小的元素交换到底端
while low < high and alist[high] >= pivot_key:
high -= 1
alist[low], alist[high] = alist[high], alist[low]
# 将比枢轴大的元素交换到顶端
while low < high and alist[low] <= pivot_key:
low += 1
alist[low], alist[high] = alist[high], alist[low]
return low
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.quick_sort(alist, 0, len(alist)-1)

6、基数排序（桶排序）

#!/usr/bin/env

# coding:utf-8

# 排序算法之基数排序,又称桶排序(1. 稳定排序)
# 2. 时间复杂度为 0(nlog(r)m), 其中r为所采取的基数，而m为堆数
# 3. 基本思想是：

# 设单关键字的每个分量的取值范围均是C0<=Kj<=Crd-1(0<=j<=rd),

# 可能的取值个数rd称为基数．基数的选择和关键字的分解因关键字的类型而异．

# 　　(1).若关键字是十进制整数，则按个、十等位进行分解，基数rd=10,C0=0,C9=9,d为最长整数的位数．

# 　　(2).若关键字是小写的英文字符串，则rd=26,C0='a',C25='z',d为最长字符串的长度．

# 　　基数排序的基本思想是：从低位到高位依次对待排序的关键码进行分配和收集，经过d趟分配和收集，就可以
# 得到一个有序序列．
# 4. 适用：数据明显有几个关键字或者几个属性组成

import math
class Solution:
# 插入排序
def bulket_sort(self, alist, radix):
k = int(math.ceil(math.log(max(alist), radix)))
bucket = [[] for i in range(radix)]
for i in range(1, k + 1):
for j in alist:
bucket[j / (radix ** (i - 1)) % (radix ** i)].append(j)
del alist[:]
for z in bucket:
alist += z
del z[:]
return alist
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.bulket_sort(alist, len(alist)+1)

7、堆排序

#!/usr/bin/env

# coding:utf-8

# 选择排序算法之堆排序（1. 不稳定）
# 2. 时间复杂度为 o(nlogn)、空间复杂度只有一个用来交换的暂存单元

# 堆排序的最坏时间复杂度为O(nlog2n), 堆排序的平均性能较接近于最坏性能，对原始序列的排序状态不敏感

# 3. 基本思路是：

# 堆排序的关键步骤有两个：
# 一是如何建立初始堆；

# 二是当堆的根结点与堆的最后一个结点交换后，

# 如何对少了一个结点后的结点序列做调整，使之重新成为堆。
# 4. 适用：n较大时，内存不充足

class Solution:
# 堆排序
def adjust_heap(self, 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]
self.adjust_heap(lists, max, size)
def build_heap(self, lists, size):
for i in range(0, (size / 2))[::-1]:
self.adjust_heap(lists, i, size)
def heap_sort(self, lists):
size = len(lists)
self.build_heap(lists, size)
for i in range(0, size)[::-1]:
lists[0], lists[i] = lists[i], lists[0]
self.adjust_heap(lists, 0, i)
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.Heap_Sort(alist)

8、计数排序

#!/usr/bin/env

# coding:utf-8

# 排序算法之计数排序 (1.稳定排序)
# 2. 时间复杂度为 O(n+k)

# 3. 假设前提：n个输入元素中的每一个都是在0到k区间内的一个整数，其中k为某个整数

# 基本思想是：
# 对每一个输入元素x，确定小于x的元素个数。利用这一信息，就可以直接把x放到它

# 输出数组中的位置上了。例如：如果有17个元素小于x，则x就应该放在第18个输出位置上。

# 当有几个元素相同时，这一方案要略作修改。
# 4. 适用：出现次数排序

class Solution:
# 插入排序
def Count_sort(self, alist):
n = len(alist)
blist = [None] * n
for i in range(n):
p = 0
q = 0
for j in range(n):
if alist[j] < alist[i]:
p += 1
elif alist[j] == alist[i]:
q += 1
for k in range(p, p + q):
blist[k] = alist[i]
return blist
alist = [41, 26, 3, 17, 62, 31, 44, 55, 20]
a = Solution()
print a.Count_sort(alist)

阅读全文

0 0

8个常用排序算法 之 python实现

8个常用排序算法之 python实现