经典排序算法 — C# 版（上）

提起排序，与我们的息息相关，平时开发的代码少不了排序。

经典的排序算法又非常多，我们怎么评价一个排序算法的好坏呢？

其实可以这样想，要细致的比较排序算法好坏,那我们就从多方面尽可能详细的对比

 

一、效率方面

1、排序算法的执行效率：最好、最坏、平均

2、 我们之前舍弃的时间复杂度的系数、常量、低阶，在这里需要拿回来

3、排序，免不了比较和移动

 

二、内存消耗方面

没错就是 算法的空间复杂度，不过对于排序的空间复杂度来说，又赋予了新的名词 — 原地排序。

顾名思义是 原地排序的肯定是消耗内存少，反之需要往外走几步那就需要临时申请内存了。

原地排序 = O(1)

 

三、算法稳定性

字面意义就是不论怎么摆弄，这个算法稳定，不会对顺序有影响。

上面这句话应该加上一个定语：对于拥有相同值的元素的前后顺序不会发生改变。

举个例子：有两个对象，其中的金额字段一样，按照金额排序，经过算法一顿折腾后，相同金额的对象先后顺序不能发生改变。

 

讲完评估排序算法的优劣的几个方面，那就直接看看我们平时常见的几个经典算法：

1、冒泡排序

图例演示

> C#

//排序 — 冒泡排序
private static void BubbleSort(int[] source)
{
if (source.Length <= 1)
return;

bool isChanged = false;
for (int i = 0; i < source.Length; i++)
{
for (int j = 0; j < source.Length - i - 1; j++)
{
var left = source[j];
var right = source[j + 1];
Console.WriteLine("【比较】");
if (left <= right)
continue;

source[j] = right;
source[j + 1] = left;
isChanged = true;
Console.WriteLine("{交换}");
}
if (!isChanged)
break;
}
Printf(source);
}

 

Q：冒泡排序的时间算法复杂度

A：最坏时间复杂度 — O(n^2)：循环 n*n次

　  最好时间复杂度 — O(n)    ：循环 n次即可

　  平均时间复杂度 — O(?)

           这里我们使用概率来分析平均复杂度，情况比较复杂。

　　　我们使用一种新的概念来分析平均复杂度，这个就是 有序度。

           有序度：看作是向量，左<= 右

　　    逆序度：正好相反，左 >= 右

　　　满有序度 = n*(n-1) / 2

　　　逆序度 = 满有序度 - 有序度

 

对于 n 个数据来说，最坏情况时间复杂度的有序度是0，要交换 n*(n-1)/2次才能正确输出。

对于最好情况复杂度的有序度是n*(n-1)/2，需要交换0次就能达到完全有序。

最坏 n*(n-1)/2次，最好0次，取个中间值来表示中间情况，也可以看作是平均情况 n*(n-1) /4

所以平均下来 要做 n*(n-1) / 4 次才能有序，因为冒泡排序的时间复杂度的上限是 O(n^2)

所以平均情况时间复杂度为 O(n^2)

虽然这样推论平均个情况并不严格，但是比起概率推论来说，这样简单且有效。

 

Q：冒泡排序是不是原地排序

A：是，临时变量为了交换数据，常量级别的临时空间申请，所以空间复杂度为O(1)

 

Q：冒泡排序是不是稳定排序

A：是，因为没有改变相同元素的先后顺序。

 

 2、插入排序

假定，我们将排序串分为两个区：已排序区，未排序区

一个元素要找到正确的的位置进行插入，那么需要去已排序区域找到自己的位置后，

将这个位置的元素们向后移动，空出位置，然后新元素入坑。

从以上这个思路来看，插入排序也是涉及到了元素的比较和移动。

给我们一个无序数组，哪块是已排序区？哪里是未排序区？

 

比如：9, 0, 1, 5, 2, 3, 6

初始时，9 就是已排序区域；

 0开始去已排序区域挨个比较，即 i=1，0<9，9向后挪动，空出位置，0入坑；

1开始去 [ 0，9 ] 已排序区域比较，1 < 9，9向后移动腾位置，1入坑，1 > 0 无需操作；

依次重复以上操作，即可达成有序。

 

图例演示

 

> C#

//排序 — 插入排序
private static void InsertionSort(int[] source)
{
if (source == null || source.Length <= 0)
return;

for (int i = 1; i < source.Length; i++)
{// 未排序区
var sorting = source[i];
int j = i - 1;

for (; j >= 0; j--)
{// 已排序区

// 比较
if (sorting >= source[j])
{
break;
}

// 后移
source[j + 1] = source[j];
                 }

// 入坑
source[j + 1] = sorting;
             }
Printf(source);
}

 

Q：插入排序的时间算法复杂度

A：最坏时间复杂度 — O(n^2)：完全倒序，循环n次，比较n次

　  最好时间复杂度 — O(n)：完全有序，循环n次跳出

　  平均时间复杂度 — O(n^2)：循环 n次数据，在一个数组中插入数据的平均情况时间复杂度为O(n)，所以是 O(n^2)

 

Q：插入排序是不是原地排序

A：是，没有临时变量申请，所以空间复杂度为O(1)

 

Q：插入排序是不是稳定排序

A：是， if (sorting >= source[j]) 这个判断保证了相同元素的先后顺序不变，

　　       去掉等于号也可以发生改变。可以实现稳定排序所以说是稳定排序

 

开始我们也说了，这么多排序算法，我们要对比一下，择优选择。

排序	最好情况	最坏情况	平均情况	是否稳定	是否原地
冒泡	O(n)	O(n^2)	O(n^2)	是	是
插入	O(n)	O(n^2)	O(n^2)	是	是

 

 

 

 

那么问题来了平均都是 O(n^2)，为什么倾向于使用插入排序呢？

这两种排序我们将常量都放进来会发现，冒泡使用的常量数比排序多，所以在数据量上来后  常量*n 会有很大的差距。

我们的编程语言中的排序算法很多都会倾向于插入排序算法。

 

3、选择排序

其实操作类似于插入排序，只不过是换了换操作方式。

所以也分为 已排序区和未排序区，操作方式是在未排序区间找到最小的，然后放到已排序区间最后。

图例：

 

> C#

private static void SelectionSort(int[] source)
{
if (source.Length <= 1)
return;

for (int i = 0; i < source.Length - 1; i++)
{// 已排序
var minIndex = i;

for (int j = i+1; j < source.Length; j++)
{//未排序

if (source[minIndex] > source[j])
{
minIndex = j;
}
}
if (i != minIndex)
{
int tmp = source[i];
source[i] = source[minIndex];
source[minIndex] = tmp;
}
}

Printf(source);
}

 

Q：选择排序的时间算法复杂度

A：最坏时间复杂度 — O(n^2)

　  最好时间复杂度 — O(n^2)

　  平均时间复杂度 — O(n^2)

 

Q：选择排序是不是原地排序

A：是，没有临时变量申请，所以空间复杂度为O(1)

 

Q：选择排序是不是稳定排序

A：不是

 

4、对比 随机生成1000个元素的 int 数组

分别执行时间如下：