在线编程——排序算法总结
【转载】原文链接：https://geekzw.blog.csdn.net/article/details/80419920
找实习，阿里一面遇到手写快排，写出来感觉没错（VS2013能通过），但在阿里的测试平台上运行未通过。细思极恐，赶紧总结一波。有幸看到SteveWang的两篇博客：排序算法总结（1）与排序算法总结（2）以及基数排序、计数排序与桶排序，总结的相当详细，我这里算是重新拜读一遍，结合自己的理解写下来。
一、排序算法分类，稳定性分析，时间复杂度与空间复杂度总结表
我们通常所说的排序算法往往指的是内部排序算法，即数据记录在内存中进行排序。而外部排序是指大文件的排序，即待排序的记录存储在外存储器上，在排序过程中需要进行多次的内、外存之间的交换。
（一）内部排序算法大体可分为两大类：
1、比较排序，平均时间复杂度范围：O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。
然而，参考博客：https://blog.csdn.net/zlele0326/article/details/51281578，比较排序算法可以继续分为下面几类：
（1）插入排序：直接插入排序，二分法插入排序，希尔排序；
（2）选择排序：简单选择排序，堆排序；
（3）交换排序：冒泡排序，快速排序；
（4）归并排序；
2、非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。详见地址：戳我。
（二）稳定性分析
排序算法稳定性的简单形式化定义为：如果Ai = Aj，排序前Ai在Aj之前，排序后Ai还在Aj之前，则称这种排序算法是稳定的。通俗地讲就是保证排序前后两个相等的数的相对顺序不变。
对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；而对于稳定的排序算法，必须对算法进行分析从而得到稳定的特性。需要注意的是，排序算法是否为稳定的是由具体算法决定的，不稳定的算法在某种条件下可以变为稳定的算法，而稳定的算法在某种条件下也可以变为不稳定的算法。
例如，对于冒泡排序，原本是稳定的排序算法，如果将记录交换的条件改成A[i] >= A[i + 1]，则两个相等的记录就会交换位置，从而变成不稳定的排序算法。
其次，说一下排序算法稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，前一个键排序的结果可以为后一个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位排序后元素的顺序在高位也相同时是不会改变的。
（三）排序算法总结表
尽管记了很多次几个排序算法的时间复杂度与空间复杂度，日子一长又忘了，心累，各种排序的稳定性，时间复杂度、空间复杂度、稳定性总结如下图（参考：https://blog.csdn.net/foreverling/article/details/43798223）：
图1
图2
网上现主要有两个版本的排序表格，如上图1，图2（来自《大话数据结构》）所示。可以看到两张图中希尔排序的时间复杂度不同，以及快速排序的空间复杂度不同，那究竟是什么？
（1）希尔排序时间复杂度分析：（摘自百度百科），希尔排序算法是直接插入排序算法的一种改进，减少了其复制的次数，速度要快很多。希尔排序的时间复杂度与增量序列的选取有关，例如希尔增量时间复杂度为O(n^2)，而Hibbard增量的希尔排序时间复杂度为O(n^3/2)，希尔排序时间复杂度的下界是n*log2n。希尔排序没有快速排序算法快 O(n(logn))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择，但是比O( n^2 )复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏的情况下执行的效率会非常差。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快，再改成快速排序这样更高级的排序算法. 希尔排序算法的性能与所选取的分组长度序列有很大关系。只对特定的待排序记录序列，可以准确地估算关键词的比较次数和对象移动次数。想要弄清关键词比较次数和记录移动次数与增量选择之间的关系，并给出完整的数学分析，至今仍然是数学难题。
（2）快速排序空间复杂度分析：详见博客（https://blog.csdn.net/yuzhihui_no1/article/details/44198701），首先就地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据，即快速排序的空间复杂度为：O(logn) ~O( n ) 。
最优的情况下空间复杂度为：O(logn) ；每一次都平分数组的情况
最差的情况下空间复杂度为：O( n ) ；退化为冒泡排序的情况
二、比较排序
1、直接插入排序
插入排序是一种简单直观的排序算法。它的工作原理非常类似于我们抓扑克牌
对于未排序数据(右手抓到的牌)，在已排序序列(左手已经排好序的手牌)中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
具体算法描述如下：
(1) 从第一个元素开始，该元素可以认为已经被排序；
(2) 取出下一个元素，在已经排序的元素序列中从后向前扫描；
(3) 如果该元素（已排序）大于新元素，将该元素移到下一位置；
(4) 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
(5) 将新元素插入到该位置后；
(6) 重复步骤2~5；
C++代码为：
-
#include
<iostream>
-
#include
<vector>
-
using namespace std;
-
-
// 分类 ------------- 内部比较排序
-
// 数据结构 ---------- 向量
-
// 最差时间复杂度 ---- 最坏情况为输入序列是降序排列的,此时时间复杂度O(n^2)
-
// 最优时间复杂度 ---- 最好情况为输入序列是升序排列的,此时时间复杂度O(n)
-
// 平均时间复杂度 ---- O(n^2)
-
// 所需辅助空间 ------ O(1)
-
// 稳定性 ------------ 稳定
-
-
vector
<int> InsertionSort(vector
<int> A)
-
{
-
for (int i = 1; i
< A.size(); i++) // 类似抓扑克牌排序
-
{
-
int get = A[i]; // 右手抓到一张扑克牌
-
int j = i - 1; // 拿在左手上的牌总是排序好的
-
while (j >= 0 && A[j] > get) // 将抓到的牌与手牌从右向左进行比较
-
{
-
A[j + 1] = A[j]; // 如果该手牌比抓到的牌大，就将其右移
-
j--;
-
}
-
A[j + 1] = get; // 直到该手牌比抓到的牌小(或二者相等)，将抓到的牌插入到该手牌右边(相等元素的相对次序未变，所以插入排序是稳定的)
-
}
-
return A;
-
}
-
-
int main()
-
{
-
//输入不定长的待排序列
-
vector
<int> vec;
-
int temp;
-
char t;
-
cout
<< "输入待排序列为：";
-
do{
-
cin >> temp;
-
vec.push_back(temp);
-
} while ((t=cin.get())!='\n');
-
/
-
int n = vec.size();//待排序列的长度 ，若输入为数组A，则int n = sizeof(A) / sizeof(int);
-
cout
<< "排序前的结果为：";
-
for (int i = 0; i < n; i++)
-
{
-
cout << vec[i] << " ";
-
}
-
cout << endl;
-
/
-
vector<int> res = InsertionSort(vec); //调用直接插入排序算法
-
cout
<< "排序后的结果为：";
-
for (int i = 0; i < n; i++)
-
{
-
cout << res[i] << " ";
-
}
-
cout << endl;
-
system("pause");
-
return 0;
-
}
运行结果：
插入排序过程：动态图来自http://www.cnblogs.com/eniac12/p/5329396.html#3972917
插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，比如量级小于千，那么插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）。
python代码如下：
-
def InsertSort(myList):
-
length = len(myList)
-
for i in range(1,length):
-
# 设置当前值前一个元素的标识
-
j = i - 1
-
-
#如果当前值小于前一个元素,则将当前值作为一个临时变量存储,将前一个元素后移一位
-
if(myList[i]
< myList[j]):
-
temp =
myList[i]
-
myList[
i] =
myList[j]
-
-
# 继续往前寻找,如果有比临时变量大的数字,则后移一位,直到找到比临时变量小的元素或者达到列表第一个元素
-
j =
j-1
-
while
j>=0 and myList[j] > temp:
-
myList[j+1] = myList[j]
-
j = j-1
-
-
# 将临时变量赋值给合适位置
-
myList[j+1] = temp
-
-
if __name__=="__main__":
-
arr = [int(i) for i in input().split()] # 输入待排序列
-
InsertSort(arr) # 插入排序
-
print(" ".join(str(i) for i in arr)) # 输出排序结果
运行结果：
2、快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个元素要O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治策略把一个序列分为两个子序列。步骤为：
（1）从序列中挑出一个元素，作为"基准"(pivot).
（2）把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
（3）对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。
C++代码：
-
#include <iostream>
-
#include <vector>
-
#include <exception>
-
using
namespace
std;
-
// 分类 ------------ 内部比较排序
-
// 数据结构 --------- 向量
-
// 最差时间复杂度 ---- 每次选取的基准都是最大（或最小）的元素，导致每次只划分出了一个分区，需要进行n-1次划分才能结束递归，时间复杂度为O(n^2)
-
// 最优时间复杂度 ---- 每次选取的基准都是中位数，这样每次都均匀的划分出两个分区，只需要logn次划分就能结束递归，时间复杂度为O(nlogn)
-
// 平均时间复杂度 ---- O(nlogn)
-
// 所需辅助空间 ------ 主要是递归造成的栈空间的使用(用来保存left和right等局部变量)，取决于递归树的深度，一般为O(logn)，最差为O(n)
-
// 稳定性 ---------- 不稳定
-
-
void Swap(vector<int>& data, int i, int j)
-
{
-
int temp = data[i];
-
data[i] = data[j];
-
data[j] = temp;
-
}
-
-
int RandomInRange(int min, int max) //在min~max中随机生成一个值
-
{
-
int random = rand() % (max - min +
1) + min;
-
return random;
-
}
-
-
int Partition(vector<int>& data, int start, int end) //Partition函数
-
{
-
if (data.size() <=
0 || start <
0 || end >= data.size())
-
throw
new
std::exception(
"Invalid Parameters");
-
-
//int index = RandomInRange(start, end); //可以不调用RandomInRange函数
-
//Swap(data, index, end);
-
-
int small = start -
1;
-
for (
int index = start; index < end; ++index)
-
{
-
if (data[index] < data[end])
-
{
-
++small;
-
if (small != index)
-
Swap(data, index, small);
-
}
-
}
-
++small;
-
Swap(data, small, end);
-
return small;
-
}
-
-
//递归快速排序
-
void QuickSort(vector<int>& data, int start, int end)
-
{
-
if (start >= end)
-
return;
-
int index = Partition(data, start, end);
//基准的索引
-
QuickSort(data, start, index -
1);
-
QuickSort(data, index +
1, end);
-
}
-
-
int main()
-
{
-
//输入不定长的待排序列
-
vector<
int> vec;
-
int temp;
-
char t;
-
cout <<
"输入待排序列为：";
-
do{
-
cin >> temp;
-
vec.push_back(temp);
-
}
while ((t =
cin.get()) !=
'\n');
-
/
-
int n = vec.size();
//待排序列的长度 ，若输入为数组A，则int n = sizeof(A) / sizeof(int);
-
-
cout <<
"排序前的结果为：";
-
for (
int i =
0; i < n; i++)
-
{
-
cout << vec[i] <<
" ";
-
}
-
cout <<
endl;
-
/
-
QuickSort(vec,
0, n -
1);
//调用快速排序算法
-
/
-
cout <<
"排序后的结果为：";
-
for (
int i =
0; i < n; i++)
-
{
-
cout << vec[i] <<
" ";
-
}
-
cout <<
endl;
-
system(
"pause");
-
return
0;
-
}
运行结果：
快速排序过程展示：
快速排序是不稳定的排序算法，不稳定发生在基准元素与A[small+1]交换的时刻。
比如序列：{ 1, 3, 4, 2, 8, 9, 8, 7, 5 }，基准元素是5，一次划分操作后5要和第一个8进行交换，从而改变了两个元素8的相对次序。
Java系统提供的Arrays.sort函数。对于基础类型，底层使用快速排序。对于非基础类型，底层使用归并排序。请问是为什么？
答：这是考虑到排序算法的稳定性。对于基础类型，相同值是无差别的，排序前后相同值的相对位置并不重要，所以选择更为高效的快速排序，尽管它是不稳定的排序算法；而对于非基础类型，排序前后相等实例的相对位置不宜改变，所以选择稳定的归并排序。
需要强调的是，很多公司的面试官喜欢在面试环节要求应聘者写出快速排序的代码，剑指offer上一个比较好的方法，保存了数组的两个位置index向前遍历数组，small用于保存交换的小于轴值的数，找到一个前移一步，即上面的函数：
现在回答，为什么在阿里笔试过程中，自己写出来的快排，感觉没错，但是运行结果不对。主要原因：void QuickSort(vector<int>& data, int start, int end) //快速排序
int Partition(vector<int>& data, int start, int end) //Partition函数
写成了
void QuickSort(vector<int> data, int start, int end) //快速排序
int Partition(vector<int> data, int start, int end) //Partition函数
运行结果：
本质原因为：vector的传参方式理解不透彻，详见https://www.cnblogs.com/xiaoxi666/p/6843211.html。
为了在面试过程中快速写出代码，如果允许写python代码，则为：
-
# 快速排序
-
def quick_sort(array, l, r):
-
if l
< r:
-
q =
partition(array,
l,
r)
-
quick_sort(
array,
l,
q
-
1)
-
quick_sort(
array,
q +
1,
r)
-
-
def
partition(
array,
l,
r)
:
-
x =
array[r]
-
i =
l
-
1
-
for
j
in
range(
l,
r)
:
-
if
array[
j] <=
x:
-
i +=
1
-
array[
i],
array[
j] =
array[j],
array[
i]
-
array[
i +
1],
array[
r] =
array[r],
array[
i +
1]
-
return
i +
1
-
-
if
__name__==
"__main__"
:
-
arr =
[int(i)
for
i
in
input()
.split()] # 输入待排序列
-
quick_sort(
arr,
0,
len(
arr)
-1) # 快速排序
-
print(" "
.join(
str(
i)
for
i
in
arr)) # 输出排序结果
738
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
