在线编程——排序算法总结

        找实习，阿里一面遇到手写快排，写出来感觉没错（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 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);
	//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);
}

       
现在回答，为什么在阿里笔试过程中，自己写出来的快排，感觉没错，但是运行结果不对。主要原因：

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))    # 输出排序结果