常用排序算法比较与分析

常用排序算法比较与分析

一、常用排序算法简述

下面主要从排序算法的基本概念、原理出发,分别从算法的时间复杂度、空间复杂度、算法的稳定性和速度等方面进行分析比较。依据待排序的问题大小(记录数量n)的不同，排序过程中需要的存储器空间也不同，由此将排序算法分为两大类：【内排序】、【外排序】。

内排序：指排序时数据元素全部存放在计算机的随机存储器RAM中。

外排序：待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中还需要对外存进行访问的排序过程。

先了解一下常见排序算法的分类关系(见图1-1)

图1-1 常见排序算法

二、内排序相关算法

2.1 插入排序

核心思想：将一个待排序的数据元素插入到前面已经排好序的数列中的适当位置，使数据元素依然有序，直到待排序数据元素全部插入完为止。

2.1.1 直接插入排序

核心思想：将欲插入的第i个数据元素的关键码与前面已经排序好的i-1、i-2 、i-3、… 数据元素的值进行顺序比较，通过这种线性搜索的方法找到第i个数据元素的插入位置，并且原来位置的数据元素顺序后移，直到全部排好顺序。

直接插入排序中，关键词相同的数据元素将保持原有位置不变，所以该算法是稳定的，时间复杂度的最坏值为平方阶O(n2)，空间复杂度为常数阶O(l)。

Python源代码：

1. #-------------------------直接插入排序--------------------------------

2. def insert_sort(data_list):

3. #遍历数组中的所有元素，其中0号索引元素默认已排序，因此从1开始

4. for x in range(1, len(data_list)):

5. #将该元素与已排序好的前序数组依次比较，如果该元素小，则交换

6. #range(x-1,-1,-1):从x-1倒序循环到0

7. for i in range(x-1, -1, -1):

8. #判断：如果符合条件则交换

9. if data_list[i] > data_list[i+1]:

10. temp = data_list[i+1]

11. data_list[i+1] = data_list[i]

12. data_list[i] = temp

2.1.2 希尔排序

核心思想：是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序;随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序时间复杂度会比O(n2)好一些，然而，多次插入排序中，第一次插入排序是稳定的，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，所以希尔排序是不稳定的。

Python源代码：

1. #-------------------------希尔排序-------------------------------

2. def insert_shell(data_list):

3. #初始化step值，此处利用序列长度的一半为其赋值

4. group = int(len(data_list)/2)

5. #第一层循环：依次改变group值对列表进行分组

6. while group > 0:

7. #下面：利用直接插入排序的思想对分组数据进行排序

8. #range(group,len(data_list)):从group开始

9. for i in range(group, len(data_list)):

10. #range(x-group,-1,-group):从x-group开始与选定元素开始倒序比较，每个比较元素之间间隔group

11. for j in range(i-group, -1, -group):

12. #如果该组当中两个元素满足交换条件，则进行交换

13. if data_list[j] > data_list[j+group]:

14. temp = data_list[j+group]

15. data_list[j+group] = data_list[j]

16. data_list[j] = temp

17. #while循环条件折半

18. group = int(group / 2)

2.2 选择排序

核心思想：每一趟扫描时，从待排序的数据元素中选出关键码最小或最大的一个元素，顺序放在已经排好顺序序列的最后，直到全部待排序的数据元素排完为止。

2.2.1 直接选择排序

核心思想：给每个位置选择关键码最小的数据元素，即：选择最小的元素与第一个位置的元素交换，然后在剩下的元素中再选择最小的与第二个位置的元素交换，直到倒数第二个元素和最后一个元素比较为止。

根据其基本思想，每当扫描一趟时，如果当前元素比一个元素小，而且这个小元素又出现在一个和当前元素相等的元素后面，则它们的位置发生了交换，所以直接选择排序时不稳定的，其时间复杂度为平方阶O(n2)，空间复杂度为O(l)。

Python源代码：

1. #-------------------------直接选择排序-------------------------------

2. def select_sort(data_list):

3. #依次遍历序列中的每一个元素

4. for i in range(0, len(data_list)):

5. #将当前位置的元素定义此轮循环当中的最小值

6. minimum = data_list[i]

7. #将该元素与剩下的元素依次比较寻找最小元素

8. for j in range(i+1, len(data_list)):

9. if data_list[j] < minimum:

10. temp = data_list[j];

11. data_list[j] = minimum;

12. minimum = temp

13. #将比较后得到的真正的最小值赋值给当前位置

14. data_list[i] = minimum

2.2.2 堆排序

堆排序时对直接选择排序的一种有效改进。

核心思想：将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶的数据元素和序列的最后一个元素交换;接着重建堆、交换数据，依次下去，从而实现对所有的数据元素的排序。完成堆排序需要执行两个动作：建堆和堆的调整，如此反复进行。

堆排序有可能会使得两个相同值的元素位置发生互换，所以是不稳定的，其平均时间复杂度为0(nlog2n)，空间复杂度为O(l)。

Python源代码：

1. #-------------------------堆排序--------------------------------

2. #**********获取左右叶子节点**********

3. def LEFT(i):

4. return 2*i + 1

5.

6. def RIGHT(i):

7. return 2*i + 2