《数据结构与算法分析》排序算法总结

前言：

      排序算法在本科的时候就学习过冒泡法，也没有想过如何去计算算法的复杂度，现在想想之前所用的排序算法实在是太小儿科了。当时课本上最先进的2路插入排序也是O(n^2)的复杂度，当时还觉得特别麻烦。就是想的太多，做的太少。

在这里所列出来的排序算法都是内部排序算法，并且不包括

我的github：

我实现的代码全部贴在我的github中，欢迎大家去参观。

https://github.com/YinWenAtBIT

插入排序：

思想：

从小到大：

插入第P个数字，假设前面第0至第P-1个数已经是按照从小到大排序。

那么只要找到第P个数字在前P-1个数字中的位置即可。

 实现的方式是从P-1个数字的最后一个数字开始寻找，如果P小于最后一个数字，则最后一个数字往后挪一位。

直到找到P的位置，再讲P放入空出来的位置上。

复杂度与稳定性

       由于嵌套循环的每一个都要发生N次迭代，因此时间复杂度为O(N^2)。最好的情况下，如果输入数据已经是预排序的，那么每一次循环只需要一次对比，那么复杂度是O(N)。插入排序是稳定的排序。

编码实现：

/*插入排序*/
void InsertionSort(ElementType A[], int N)
{
	int i,j;
	ElementType temp;

	for(i=1; i<N; i++)
	{
		temp = A[i];

		for(j=i; j>0; j--)
		{
			if(temp <A[j-1])
				A[j] = A[j-1];
			else
				break;
		}
		A[j] = temp;
	}
}

希尔排序：

思想：

从小到大：

希尔排序的原理与插入排序基本相同，不同之处在于希尔排序使用的比较间隔不同与插入排序，插入排序只使用1作为比较间隔。

希尔排序的比较间隔从大到小，最后为1。

希尔排序的比较间隔有许多的设置方法，发明人使用的为1，2，4，8这样两倍的间隔。现在最好的间隔为Sedgewick提出的增量序列1,5,9,41,109这样的序列。在这里我的实现就使用的这样的序列。

复杂度与稳定性

      使用希尔排序最坏情况为O(N^2)，Sedgewick的增量序列的下界为O(N^(4/3))，平均时间为O(N^(7/6))。希尔排序不是稳定的排序。

编码实现：

/*希尔排序*/
void ShellSort(ElementType A[], int N)
{
	/*Sedgewick序列*/
	int Sedgewick[5] = {109, 41, 19, 5, 1};
	
	int i, j;
	int Index, Increament;
	ElementType temp;

	for(Index=0; Index<5; Index++)
		if(Sedgewick[Index] < N)
			break;
	if(Index == 5)
		return;

	for(; Index<5; Index++)
	{
		Increament = Sedgewick[Index];
		for(i=Increament; i<N; i++)
		{
			temp = A[i];
			for(j = i; j>Increament-1; j--)
			{
				if(temp < A[j-Increament])
					A[j] = A[j-Increament];
				else
					break;
			}
			A[j] = temp;
		}
	}
}

堆排序：

思想：

从小到大：

将数据构建成二叉堆，然后依次删除最小值，就可以得到排序的结果。缺点是需要使用额外的空间。

复杂度与稳定性

      构建堆花费时间O(N)，每次删除使用O(LogN)时间。一共N次，所以时间复杂度为O(N LogN)。堆排序也是不稳定排序。

编码实现：

/*堆排序，直接调用了之前编写的二叉堆代码*/
void HeapSort(ElementType A[], int N)
{
	int i;
	PriorityQueue H = BuildHeap(A, N);
	for(i=0; i<N; i++)
		A[i] = DeleteMin(H);

	Destroy(H);
}

归并排序：

思想：

从小到大：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在新的数列里放入这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

 

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

复杂度与稳定性

      它的最坏情况下时间复杂度为O(N LogN)，属于速度很快的排序了，但是缺点是也需要一个同样大小的辅助数组。归并排序是稳定的排序算法。

编码实现：

在这里我把归并排序分成了3个部分，启动部分建立一个辅助的数组，然后启动排序的真正部分Msort，并且提取出了Merge函数。

/*归并排序*/
void Merge(ElementType A[], ElementType TmpArray[], int Lpos, int Rpos, int RightEnd)
{
	int i, LeftEnd, Num, TmpPos;
	LeftEnd = Rpos -1;
	Num = RightEnd - Lpos +1;
	TmpPos = Lpos;

	while(Lpos <= LeftEnd && Rpos <= RightEnd)
	{
		if(A[Lpos] < A[Rpos])
			TmpArray[TmpPos++] = A[Lpos++];
		else
			TmpArray[TmpPos++] = A[Rpos++];
	}

	/*复制剩下的数据*/
	while(Lpos <= LeftEnd)
		TmpArray[TmpPos++] = A[Lpos++];

	while(Rpos <= RightEnd)
		TmpArray[TmpPos++] = A[Rpos++];

	/*拷贝回原来的数组*/
	for(i =0; i<Num; i++, RightEnd--)
	{
		A[RightEnd] = TmpArray[RightEnd];
	}
}



void Msort(ElementType A[], ElementType TmpArray[], int Left, int Right)
{
	int Center;
	if(Left < Right)
	{
		Center = (Left+Right)/2;
		Msort(A, TmpArray, Left, Center);
		Msort(A, TmpArray, Center+1, Right);
		Merge(A, TmpArray, Left, Center+1, Right);
	}
}



void MergeSort(ElementType A[], int N)
{
	ElementType * TmpArray = (ElementType *)malloc(N*sizeof(ElementType));
	if(TmpArray == NULL)
	{
		fprintf(stderr, "not enough memory\n");
		exit(1);
	}

	Msort(A, TmpArray, 0, N-1);
	free(TmpArray);
}

快速排序：

思想：

从小到大：

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

 该方法的基本思想是：

 1．先从数列中取出一个数作为基准数。

 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

 3．再对左右区间重复第二步，直到各区间只有一个数（这一步可以提前停止，在只有3-5个数的时候使用插入排序更快）。

虽然算法描述起来挺简单的，但是里面有许许多多的细节，要解决这些坑，还是得花不少的功夫。

1.选择哪一个数作为基准

书上提供的方法我觉得基本上时最优了。为了避免遇上已经排序的序列，选择第一个数是肯定不可取的（这样导致所有的数据都分在一边，另一边没有数，时间复杂度变成O(N^2)）。然后直接选择中间的数？这样同样难免遇上最大值或者最小值。由于在选择哪一个数作为基准并不花费太多的功夫，并且可以大大改善算法时间的稳定性，所以在这里可以选择复杂一点的做法。

书上提供的做法是，提取第一个，最后一个，已经正中间的数，让它们从小到大排列，然后选择中间的数作为基准。然后，把中间的基准数和倒数第二个数交换，这样做的目的是为了第二步的方便。接下来的叙述就会说明这一点。

2.如何交换：

交换的方式为：

使用两个指针，一个指向数组开始处，另一个指向末尾，然后两个指针开始运动，指向开头的指针在遇到比基准大的数时停下来。指向末尾的指针在遇到比基准小的数停下来，然后交换所指的数，重复这个过程，直到最初指向末尾的指针跑到了指向开始指针的前面为止。这样就完成了将数据划分两部分的工作。最后再把基准（倒数第二个数）与指向开头指针所指的数交换（这个数大于基准，它前面的数都小于基准）。这样基准就处于中间。然后可以对左右两部分再进行快排。这里把基准放在末尾的原因是，作为指向开头指针的提醒处，避免开头指针一直滑动以至于超过数组界限。（这里对于等于基准的数，两个指针都停下来）。

复杂度与稳定性

      它的最坏情况下时间复杂度为O(N^2)，但是优化了选择基准的方式，一般难以遇上。平均速度为O(N LogN)属于速度很快的排序了，并且不需要额外的空间。快速排序是不稳定的排序算法。

编码实现：

在这里我把快速排序分成了4个部分，启动部分启动快排，然后选择基准部分提取出来作为单独的函数，交换作为单独的函数。以及最为核心的滑动交换，并且对子数组进行快排作为一部分。

/*快速排序*/

void Swap(ElementType *A, ElementType *B)
{
	ElementType temp;
	temp = *A;
	*A = *B;
	*B = temp;
}

ElementType Median3(ElementType A[], int Left, int Right)
{
	int Center = (Left + Right) / 2;

	/*从左到右，从小到大排列*/
	if(A[Left] > A[Center])
		Swap(&A[Left], &A[Center]);
	if(A[Left] > A[Right])
		Swap(&A[Left], &A[Right]);
	if(A[Center] > A[Right])
		Swap(&A[Center], &A[Right]);

	Swap(&A[Center], &A[Right-1]);
	return A[Right-1];
}

#define Cutoff (3)

void Qsort(ElementType A[], int Left, int Right)
{
	int i,j;
	ElementType Pivot;
	
	Pivot = Median3(A, Left, Right);

	if(Left + Cutoff <Right)
	{
		i = Left;
		j = Right-1;
		while(1)
		{
			while(A[++i] < Pivot);
			while(A[--j] > Pivot);
			if(i < j)
				Swap(&A[i], &A[j]);
			else
				break;
		}
		/*将枢纽元放回中间,此时枢纽元左边的数据都比它小
		右边的数据都比它大，再对左右数据排序即可*/
		Swap(&A[i], &A[Right-1]);

		Qsort(A, Left, i-1);
		Qsort(A, i+1, Right);
	}
	else
		/*少于3个数据就直接使用插入排序更快*/
		InsertionSort(A+Left, Right-Left+1);
}

void QuickSort(ElementType A[], int N)
{
	Qsort(A, 0, N-1);
}

总结：

排序算法我是提前学习了，隔了两个星期之后才来亲手实现。最基本的排序算法，插入，希尔，以及堆排序，由于方法简单，没有再参考课本就写了出来。归并排序稍微复习了一下原理以及伪代码，也写了出来。最后的快排真是一点都写不出来了。因为它的思想虽然简单，实现上的细节确实不容易，只能在重新学习一遍之后，才写出了快排到算法。

核心还是要理解这些算法，只有在理解了算法之后，才能做到自己想什么时候写出来就能写出来。而不是简单的默写。