1.分治思想快速排序
https://www.cnblogs.com/feichangnice/p/5334195.html
算法导论上的快速排序采用分治算法，步骤如下：
1.选取一个数字作为基准，可选取末位数字
2.将数列第一位开始，依次与此数字比较，如果小于此数，将小数交换到左边，最后达到小于基准数的在左边，大于基准数的在右边，分为两个数组
3.分别对两个数组重复上述步骤
其中一次排序步骤如下：
伪码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
QuickSort(A,p,r) if p<r then q = Partition(A,p,r) QucikSort(A,p,q-1) QucikSort(A,q+1,r)Partition(A,p,r) x=A[r] i=p-1 for j from p to r-1 if A[j]<=x then i=i+1 exchange A[i],A[j] exchange A[i+1],A[r] return i+1 |
Python实现代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
def QuickSort(arr,firstIndex,lastIndex): if firstIndex<lastIndex: divIndex=Partition(arr,firstIndex,lastIndex) QuickSort(arr,firstIndex,divIndex) QuickSort(arr,divIndex+1,lastIndex) else: returndef Partition(arr,firstIndex,lastIndex): i=firstIndex-1 for j in range(firstIndex,lastIndex): if arr[j]<=arr[lastIndex]: i=i+1 arr[i],arr[j]=arr[j],arr[i] arr[i+1],arr[lastIndex]=arr[lastIndex],arr[i+1] return iarr=[1,4,7,1,5,5,3,85,34,75,23,75,2,0]print("initial array:
",arr)QuickSort(arr,0,len(arr)-1)print("result array:
",arr) |
运行结果如下：
initial array:
[1, 4, 7, 1, 5, 5, 3, 85, 34, 75, 23, 75, 2, 0]
result array:
[0, 1, 1, 2, 3, 4, 5, 5, 7, 23, 34, 75, 75, 85]
性能分析以后做
=============
2.冒泡排序
实现思路 ： 使用双重for循环，内层变量为i， 外层为j，在内层循环中不断的比较相邻的两个值（i, i+1）的大小，如果i+1的值大于i的值，交换两者位置，每循环一次，外层的j增加1，等到j等于n-1的时候，结束循环
第一次看不懂很正常，不要灰心，下面是使用代码的实现
arr = [7, 4, 3, 67, 34, 1, 8]
def bubble_sort(arr):
n = len(arr)
for j in range(0, n - 1):
for i in range(0, n - 1 - j):
if arr[i] > arr[i + 1]:
arr[i], arr[i + 1] = arr[i + 1], arr[i]
bubble_sort(arr)
print(arr) # [1, 3, 4, 7, 8, 34, 67]
---------------------
作者：东都花神
来源：CSDN
原文：https://blog.csdn.net/qq_33988065/article/details/79636021
版权声明：本文为博主原创文章，转载请附上博文链接！
=================================
3.桶排序
https://www.cnblogs.com/king-ding/p/bucketsort.html
问题提出：
将以下数据：
6, 8, 2, 3, 4, 0, 9, 1, 5，1
按从小到达排列。
桶排序原理：
桶排序也叫计数排序，简单来说，就是将数据集里面所有元素按顺序列举出来，然后统计元素出现的次数。最后按顺序输出数据集里面的元素。
排序过程如下：
一、初始化桶的大小
把数据集里面每一个元素当作一个桶，由上面问题看出，原始数据范围在0--9之间，因此我就需要有10个桶，如下图
第一行为初始化计数为0，第二行为各个元素。
二、计数
接下来读入第一原始数据为6,则在下标为6的桶中增加1,如下图：
再读入下一个原始数据为8,则在下标为8的桶中增加1,如下图：
以此类推，最后遍历完所有原始数据时，10个桶的计数如下图：
三、输出数据
在完成原始数据的遍历计数后，接下来遍历各个桶，输出数据：
元素0计数为1,则输出0,
元素1计数为2,则输出1 1,
元素2计数为1,则输出2,
元素3计数为1,则输出3,
元素4计数为1,则输出4,
元素5计数为1,则输出5,
元素6计数为1,则输出6,
元素7计数为0,则不输出元素,
元素8计数为1,则输出8,
元素9计数为1,则输出9,
最后结果输出为：0, 1, 1, 2, 3, 4, 5, 6, 8, 9
代码实现
由上述原理可以看出，桶排序需要以下三个步骤：
1.申请一个包含所有元素的数组，并初始化。
2.遍历原始数据，并计数。
3.遍历计数完成后的各个数组元素，输出数据。
以下是python代码的实现：
1 #!/usr/bin/env python
2 #-*- coding:utf8 -*-
3
4 class BucketSort(object):
5 ‘‘‘
6 self.datas: 要排序的数据列表
7 self.bucketSize: 水桶的大小(数据集的范围，如bucketSize=10,
8 则表示数据集的范围为0-9)
9 self.result: 保存排序后的结果
10 self.bucket: 代表水桶，指数据集内的所有元素
11 _sort(): 排序函数
12 show(): 输出结果的函数
13
14 用法：
15 BucketSort(datas, size) 或者BucketSort(datas)，size的默认值为100
16
17 BucketSort(datas)._sort() 这样就是开始排序
18 BucketSort(datas).show() 这样就可以把排序后的结果输出
19 ‘‘‘
20 def __init__(self, datas, size=100):
21 self.datas = datas
22 self.bucketSize = size
23 self.result = [0 for i in range(len(datas))]
24 self.bucket = [0 for i in range(self.bucketSize)]
25
26 def _sort(self):
27 # 读入各个元素，并在对应的位置统计，当bucket里的元素不为0
28 # 就保存到result里面
29 for num in self.datas:
30 self.bucket[num] += 1
31 j = 0
32 for i in range(self.bucketSize):
33 while(self.bucket[i]):
34 self.result[j] = i
35 self.bucket[i] -= 1
36 j += 1
37
38 def show(self):
39 print "Resutl is:",
40 for i in self.result:
41 print i,
42 print ‘‘
43
44
45 if __name__ == ‘__main__‘:
46 try:
47 size = raw_input("Please input size(default=100):")
48 if size:
49 size = int(size)
50 datas = raw_input(‘Please input some number:‘)
51 datas = datas.split()
52 datas = [int(datas[i]) for i in range(len(datas))]
53 except Exception:
54 pass
55 if size:
56 bks = BucketSort(datas, size)
57 else:
58 bks = BucketSort(datas)
59 bks._sort()
60 bks.show()
总结：
1.桶排序的优点就是特别快，真的是特别快！特别快！特别块！
2.缺点就是特别耗资源，如果数据取值的范围是0---1010, 就要申请一个大小为1010的数组，想想这得多耗内存空间。阔怕！
3.我上面写的程序也只是一个演示性的，漏洞挺多，目前只能排序大于零的整数。