十大经典算法 Python实现
十大经典排序算法（python实现）（原创）
使用场景：
1，空间复杂度 越低越好、n值较大：
堆排序 O(nlog2n) O(1)
2，无空间复杂度要求、n值较大：
桶排序 O(n+k) O(n+k)
经典排序算法图解：
经典排序算法的复杂度：
大类一（比较排序法）：
1、冒泡排序（Bubble Sort）【前后比较-交换】
python代码实现：
1 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]
2 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
3
4 while 1:
5 state = 0 # 假设本次循环没有改变
6 for i in range(len(d0) - 1):
7 if d0[i] > d0[i + 1]:
8 d0[i], d0[i + 1] = d0[i + 1], d0[i]
9 state = 1 # 有数值交换，那么状态值置1
10 if not state: # 如果没有数值交换，那么就跳出
11 break
12
13 print(d0)
14 print(d0_out)
2、选择排序（Selection Sort）【选择最小的数据放在前面】
python代码实现：
1 def select_sort(data):
2 d1 = []
3 while len(data):
4 min = [0, data[0]]
5 for i in range(len(data)):
6 if min[1] > data[i]:
7 min = [i, data[i]]
8 del data[min[0]] # 找到剩余部分的最小值，并且从原数组中删除
9 d1.append(min[1]) # 在新数组中添加
10 return d1
11
12 if __name__ == "__main__":
13 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
14 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
15 d1 = select_sort(d0)
16 print(d1)
17 print(d0_out)
3、插入排序（Insertion Sort）【逐个插入到前面的有序数中】
直接插入排序-python实现：
1 def direct_insertion_sort(d): # 直接插入排序，因为要用到后面的希尔排序，所以转成function
2 d1 = [d[0]]
3 for i in d[1:]:
4 state = 1
5 for j in range(len(d1) - 1, -1, -1):
6 if i >= d1[j]:
7 d1.insert(j + 1, i) # 将元素插入数组
8 state = 0
9 break
10 if state:
11 d1.insert(0, i)
12 return d1
13
14
15 if __name__ == "__main__":
16 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
17 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
18 d1 = direct_insertion_sort(d0)
19 print(d1)
20 print(d0_out)
折半插入排序-python实现：
1 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
2 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
3
4 d1 = [d0[0]]
5 del d0[0]
6
7 for i in d0:
8 index_now = [0, len(d1)]
9 while 1:
10 index = index_now[0] + int((index_now[1] - index_now[0]) / 2)
11 if i == d1[index]:
12 d1.insert(index+1,i)
13 break
14 elif index in index_now: # 如果更新的index值在index_now中存在（也有可能是边界），那么就表明无法继续更新
15 d1.insert(index+1,i)
16 break
17 elif i > d1[index]:
18 index_now[0] = index
19 elif i < d1[index]:
20 index_now[1] = index
21
22 print(d1)
23 print(d0_out)
4、希尔排序（Shell Sort）【从大范围到小范围进行比较-交换】类似冒泡和插入的联合
python代码实现：
1 def direct_insertion_sort(d): # 直接插入排序，因为要用到后面的希尔排序，所以转成function
2 d1 = [d[0]]
3 for i in d[1:]:
4 state = 1
5 for j in range(len(d1) - 1, -1, -1):
6 if i >= d1[j]:
7 d1.insert(j + 1, i) # 将元素插入数组
8 state = 0
9 break
10 if state:
11 d1.insert(0, i)
12 return d1
13
14
15 def shell_sort(d): # d 为乱序数组，l为初始增量,其中l<len(d),取为len(d)/2比较好操作。最后还是直接省略length输入
16 length = int(len(d) / 2) # 10
17 num = int(len(d) / length) # 2
18 while 1:
19
20 for i in range(length):
21 d_mid = []
22 for j in range(num):
23 d_mid.append(d[i + j * length])
24 d_mid = direct_insertion_sort(d_mid)
25 for j in range(num):
26 d[i + j * length] = d_mid[j]
27 # print(d)
28 length = int(length / 2)
29 if length == 0:
30 return d
31 break
32 # print('length:',length)
33 num = int(len(d) / length)
34
35
36 if __name__ == "__main__":
37 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
38 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
39 d1 = shell_sort(d0)
40 print(d1)
41 print(d0_out)
5、归并排序（Merge Sort）【分治法-2-4-8插入排序】
python代码实现（这个地方是由大往小进行递归）：
1 # 归并排序，还有些问题。其中有些细节需要重新理解
2 # 也是递归问题
3 def merge_sort(data): # 分治发的典型应用，大问题拆分成小问题，逐个击破，之后将结果合并
4 half_index = int(len(data) / 2) # 将数组拆分
5
6 d0 = data[:half_index]
7 d1 = data[half_index:]
8
9 if len(d0) > 1:
10 d0 = merge_sort(d0)
11
12 if len(d1) > 1:
13 d1 = merge_sort(d1)
14
15 index = 0
16 for i in range(len(d1)):
17 state = 1
18 for j in range(index, len(d0)):
19 if d1[i] < d0[j]:
20 state = 0
21 index = j + 1
22 d0.insert(j, d1[i])
23 break
24 if state == 1: # 如果大于d0这个队列的所有值，那么直接extend所有数据
25 d0.extend(d1[i:])
26 break
27 return d0
28
29
30 if __name__ == "__main__":
31 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
32 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
33 d1 = merge_sort(d0)
34 print(d1)
35 print(d0_out)
python代码实现（由小扩展到大的子序列）：
1
2 def list_sort(d0, d1): # 基元组往大扩展
3 index = 0
4 for i in range(len(d1)): # 遍历d1数组
5 state = 1
6 for j in range(index, len(d0)): # 遍历d0数组
7 if d0[j] > d1[i]:
8 state = 0
9 index = j + 1
10 d0.insert(j, d1[i])
11 break
12 if state == 1: # 如果大于d0这个队列的所有值，那么直接extend所有数据
13 d0.extend(d1[i:])
14 break
15 return d0
16
17
18 def merge_sort(data):
19 d0 = [[x] for x in data]
20 while len(d0) != 1: # 循环条件
21 length = len(d0)
22 half = int(length/2) # 除2的整数部分
23 quo = length%2 # 除2的商
24 d0_mid = []
25 for i in range(half):
26 d0_mid.append(list_sort(d0[i*2], d0[i*2+1]))
27 if quo:
28 d0_mid.append(d0[-1])
29 d0 = d0_mid
30
31 return d0[0]
32
33
34
35 if __name__ == "__main__":
36 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
37 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
38 d1 = merge_sort(d0)
39 print(d1)
40 print(d0_out)
6、快速排序（Quick Sort）【选取一个基准值，小数在左大数在在右】
python代码实现：
1 # import sys
2 # sys.setrecursionlimit(1000000)
3
4 def quick_sort(data):
5 d = [[], [], []]
6 d_pivot = data[-1] # 因为是乱序数组，所以第几个都是可以的，理论上是一样的
7 for i in data:
8 if i < d_pivot: # 小于基准值的放在前
9 d[0].append(i)
10 elif i > d_pivot: # 大于基准值的放在后
11 d[2].append(i)
12 else: # 等于基准值的放在中间
13 d[1].append(i)
14
15 # print(d[0], d[1], d[2])
16 if len(d[0]) > 1: # 大于基准值的子数组，递归
17 d[0] = quick_sort(d[0])
18
19 if len(d[2]) > 1: # 小于基准值的子数组，递归
20 d[2] = quick_sort(d[2])
21
22 d[0].extend(d[1])
23 d[0].extend(d[2])
24 return d[0]
25
26
27 if __name__ == "__main__":
28 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] # 原始乱序
29 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序
30 d1 = quick_sort(d0)
31 print(d1)
32 print(d0_out)
7、堆排序（Heap Sort）【利用最大堆和最小堆的特性】
python代码实现：
1 d0 = [99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 28, 1, 92]
2
3
4 def sort_max(data): # 直接冒泡一下吧,小到大
5 for i in range(len(data) - 1):
6 for j in range(len(data) - 1):
7 if data[j] > data[j + 1]:
8 data[j], data[j + 1] = data[j + 1], data[j]
9 return data
10
11 def heap_min(data,type):
12 index = 0
13 if not type:
14 for i in range(len(data[1:])):
15 if data[index] > data[i+1]:
16 index = i+1
17 data[0],data[index] = data[index],data[0]
18 return data
19 else:
20 for i in range(len(data[1:])):
21 if data[index] < data[i+1]:
22 index = i+1
23 data[0],data[index] = data[index],data[0]
24 return data
25
26
27 # d0 = [3,2,1,10,3]
28 # print(heap_min(d0,1))
29 # print(heap_min(d0,0))
30
31 import numpy as np
32
33
34 def heap_adj(data, type): # data 原始堆，type=1最大堆，type=0最小堆
35 length = len(data)
36 floor = int(np.log2(length))
37 for i in range(floor, 0, -1): # 3（7 6 5 4）-2（3 2）-1（1）
38 for j in range(2 ** floor - 1, 2 ** (floor - i) - 1, -1):
39 # print(i,j) # j-1 为当前父节点
40 d_mid = [data[j - 1]] # j = 7,j-1 =6 index
41 if j * 2 <= length: # 14
42 d_mid.append(data[j * 2 - 1])
43 if j * 2 + 1 <= length:
44 d_mid.append(data[j * 2])
45
46 d_mid = heap_min(d_mid, type)
47
48 if len(d_mid) == 2:
49 data[j - 1], data[j * 2 - 1] = d_mid[0], d_mid[1]
50 elif len(d_mid) == 3:
51 data[j - 1], data[j * 2 - 1], data[j * 2] = d_mid[0], d_mid[1], d_mid[2]
52 return data
53
54 d1 = []
55 for i in range(len(d0)):
56 data = heap_adj(d0, 0)
57 d1.append(d0[0])
58 del d0[0]
59
60
61 print(d1)
大类二（非比较排序法）：
8、计数排序（Counting Sort）【字典计数-还原】
python代码实现：
1 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]
2 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64]
3
4 d_max = 0
5 d_min = 0
6 for i in d0:
7 if d_max<i:
8 d_max = i
9 if d_min>i:
10 d_min = i
11
12 d1 = {}
13 for i in d0:
14 if i in d1.keys():
15 d1[i] += 1
16 else:
17 d1[i] = 1
18
19 d2 = []
20 for i in range(d_min,d_max+1):
21 if i in d1.keys():
22 for j in range(d1[i]):
23 d2.append(i)
24
25 print(d2)
9、桶排序（Bucket Sort）【链表】
python代码实现：
1 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]
2
3 d1 = [[] for x in range(10)]
4 for i in d0:
5 d1[int(i/10)].append(i)
6
7 # print(d1)
8
9
10 for i in range(len(d1)):
11 if d1[i] != []:
12 d2 = [[] for x in range(10)]
13 for j in d1[i]:
14 d2[j%10].append(j)
15 d1[i] = d2
16
17 # print(d1)
18
19 d3 = []
20 for i in d1:
21 if i:
22 for j in i:
23 if j:
24 for k in j:
25 if k:
26 d3.append(k)
27 print(d3)
10、基数排序（Radix Sort）
python代码实现：
1 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]
2
3 d1 = [[] for x in range(10)]
4
5 # 第一次 最小位次排序
6 for i in d0:
7 d1[i % 10].append(i)
8
9 print(d1)
10
11 d0_1 = []
12 for i in d1:
13 if i:
14 for j in i:
15 d0_1.append(j)
16 print(d0_1)
17
18 # 第二次 次低位排序
19 d2 = [[] for x in range(10)]
20 for i in d0_1:
21 d2[int(i/10)].append(i)
22 print(d2)
23
24 d0_2 = []
25 for i in d2:
26 if i:
27 for j in i:
28 d0_2.append(j)
29 print(d0_2)
出自 https://www.cnblogs.com/Mufasa/p/10527387.html
十大经典算法 Python实现的更多相关文章
- JS的十大经典算法排序
引子 有句话怎么说来着: 雷锋推倒雷峰塔,Java implements JavaScript. 当年,想凭借抱Java大腿火一把而不惜把自己名字给改了的JavaScript(原名LiveScript ...
- 数据挖掘十大经典算法(5) 最大期望(EM)算法
在统计计算中,最大期望(EM,Expectation–Maximization)算法是在概率(probabilistic)模型中寻找参数最大似然估计的算法,其中概率模型依赖于无法观测的隐藏变量(Lat ...
- ICDM评选：数据挖掘十大经典算法
原文地址:http://blog.csdn.net/aladdina/article/details/4141177 国际权威的学术组织the IEEE International Conferenc ...
- 数据挖掘领域十大经典算法之—C4.5算法（超详细附代码）
https://blog.csdn.net/fuqiuai/article/details/79456971 相关文章: 数据挖掘领域十大经典算法之—K-Means算法(超详细附代码) ...
- JS的十大经典算法
冒泡排序(Bubble Sort) 冒泡排序须知: 作为最简单的排序算法之一,冒泡排序给我的感觉就像Abandon在单词书里出现的感觉一样,每次都在第一页第一位,所以最熟悉...冒泡排序还有一种优化算 ...
- 数据挖掘十大经典算法[0]-K-Means算法
K-Means算法的输入N,K和一个size为N的向量组vector.输出K个两两互不相交的向量组.其本质是将给定的向量组划分成K个类别,使得同类别的向量相似度比较大,而不同类别的向量之间的相似度较小 ...
- 数据挖掘十大经典算法(9) 朴素贝叶斯分类器 Naive Bayes
贝叶斯分类器 贝叶斯分类器的分类原理是通过某对象的先验概率,利用贝叶斯公式计算出其后验概率,即该对象属于某一类的概率,选择具有最大后验概率的类作为该对象所属的类.眼下研究较多的贝叶斯分类器主要有四种, ...
- 数据挖掘十大经典算法--CART: 分类与回归树
一.决策树的类型 在数据挖掘中,决策树主要有两种类型: 分类树 的输出是样本的类标. 回归树 的输出是一个实数 (比如房子的价格,病人呆在医院的时间等). 术语分类和回归树 (CART) 包括了上述 ...
- 数据挖掘领域十大经典算法之—SVM算法（超详细附代码）
https://blog.csdn.net/fuqiuai/article/details/79483057
随机推荐
- 重启hdfs集群的时候，报大量的gc问题。
问题现象: 2019-03-11 12:30:52,174 INFO org.apache.hadoop.util.JvmPauseMonitor: Detected pause in JVM or ...
- Java--常用API介绍
Scanner类--键盘输入,室友起来三个步骤: 第一,导包:import java.util.Scanner 第二,创建:Scanner sc = new Scanner(System.in) 第三 ...
- zsh: no matches found
具体原因: 因为zsh缺省情况下始终自己解释这个 *.h,而不会传递给 find 来解释. 解决办法: 在~/.zshrc中加入: setopt no_nomatch, 然后进行source .zsh ...
- php过滤表情符号
<?php $clean_text = ""; // Match Emoticons $regexEmoticons = '/[\x{1F600}-\x{1F64F}]/u' ...
- Mac地址转换成long长整型
Mac地址转换成long长整型 using System;using System.Collections.Generic;using System.IO;using System.Text;usin ...
- JAVA SparkSQL初始和创建DataFrame的几种方式
建议参考SparkSQL官方文档:http://spark.apache.org/docs/latest/sql-programming-guide.html 一.前述 1.SparkSQ ...
- 使用python显示当前系统中的所有进程并关闭某一进程
环境: Windows 10操作系统 python idle 原理: 调用windows系统自带的命令task,该命令使用方式: 第一步.调用cmd命令行,显示当前系统中所有进程: Win+R-> ...
- OpenJudge数据结构与算法-计算点的距离并排序
/*================================================================== 距离排序 总时间限制: 1000ms 内存限制: 65536k ...
- iptables+ipset自动封闭和解封频繁访问web服务的恶意IP
转载于互联网 iptables直接针对ip进行封禁,在ip数量不大的时候是没什么问题的,但当有大量ip的时候性能会严重下降,iptables是O(N)的性能.而ipset就像一个集合,把需要封 ...
- Django之数据库对象关系映射
Django ORM基本配置 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去 ...