快速排序

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:         return     def 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 i     arr=[1,4,7,1,5,5,3,85,34,75,23,75,2,0]   print("initial array:\n",arr) QuickSort(arr,0,len(arr)-1) print("result array:\n",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()
=================================

以下代码更容易理解:
# 实现快排
def quicksort(nums):
    if len(nums) <= 1:
        return nums
 
    # 左边数组
    left = []
    # 右边数组
    right = []
    # 基准数
    base = nums.pop()
 
    # 对原数组进行划分
    for x in nums:
        if x < base:
            left.append(x)
        else:
            right.append(x)
 
    # 递归调用
    return quicksort(left) + [base] + quicksort(right)
 
if __name__ == '__main__':
    nums = [6,1,2,7,9,3,4,5,10,8]
    print quicksort(nums) 
---------------------  
作者：正牌小白牙  
来源：CSDN  
原文：https://blog.csdn.net/weixin_41678663/article/details/81813759  
版权声明：本文为博主原创文章，转载请附上博文链接！

---

总结：

1.桶排序的优点就是特别快，真的是特别快！特别快！特别块！

2.缺点就是特别耗资源，如果数据取值的范围是0---10¹⁰, 就要申请一个大小为10¹⁰的数组，想想这得多耗内存空间。阔怕！

3.我上面写的程序也只是一个演示性的，漏洞挺多，目前只能排序大于零的整数。