八种排序算法原理及实现

一：冒泡排序

 

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序算法的运作如下：（从后往前）

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

复杂度O(n^2)

void Bubblesort(int *a, int n)
{
	int i, j, k;
	for (i = 1;i < n;i++)
	{
		for (j = 1;j <= n - i;j++)
		{
			if (a[j] > a[j + 1])
				k = a[j], a[j] = a[j + 1], a[j + 1] = k;
		}
	}
}

二：选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 

复杂度O(n^2)

void Selectionsort(int *a, int n)
{
	int i, j, k;
	for (i = 1;i <= n;i++)
	{
		for (j = i + 1;j <= n;j++)
		{
			if (a[i] > a[j])
				k = a[i], a[i] = a[j], a[j] = k;
		}
	}
}

三：插入排序—直接插入排序

直接插入排序（Straight Insertion Sort）是一种最简单的排序方法，其基本操作是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。

 

每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。

第一趟比较前两个数，然后把第二个数按大小插入到有序表中； 第二趟把第三个数据与前两个数从后向前扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。

直接插入排序是由两层嵌套循环组成的。外层循环标识并决定待比较的数值。内层循环为待比较数值确定其最终位置。直接插入排序是将待比较的数值与它的前一个数值进行比较，所以外层循环是从第二个数值开始的。当前一数值比待比较数值大的情况下继续循环比较，直到找到比待比较数值小的并将待比较数值置入其后一位置，结束该次循环。

void insertsort(int *a, int n)
{
	for (int i = 0;i < n;i++)
	{
		int j = i - 1, tmp = a[i];
		while (j >= 0 && tmp < a[j])
			a[j + 1] = a[j], j--;
		a[j + 1] = tmp;
	}
}

四：插入排序—希尔排序

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序属于插入类排序,是将整个有序序列分割成若干小的子序列分别进行插入排序。

排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止。

 

void shellsort(int *a, int n)
{
	int i, j, k, id, gap;
	for (gap = n / 2;gap;gap /= 2)
	{
		for (i = gap;i <= n;i++)
		{
			for (j = i - gap;j >= 0 && a[j] > a[j + gap];j -= gap)
				k = a[j], a[j] = a[j + gap], a[j + gap] = k;
		}
	}
}

五：归并排序

 

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并过程为：比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

复杂度：O(nlogn)

void mergesort(int *a, int *b,int l,int r)
{
	int mid = (l + r) / 2;
	int i = l, j = mid + 1, n = mid, m = r, cnt = 0;
	if (l != r)
	{
		mergesort(a, b, l, mid);
		mergesort(a, b, mid + 1, r);
	}
	while (i <= n&&j <= m)
	{
		if (a[i] < a[j])
			b[++cnt] = a[i++];
		else
			b[++cnt] = a[j++];
	}
	while (i <= n) b[++cnt] = a[i++];
	while (j <= m) b[++cnt] = a[j++];
	for (i = 1;i <= cnt;i++)
		a[l + i - 1] = b[i];
}

六：计数排序

计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。[1-2]  当然这是一种牺牲空间换取时间的做法，而且当O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是O(n*log(n)), 如归并排序，堆排序）

 

假设输入的线性表L的长度为n，L=L1,L2,..,Ln；线性表的元素属于有限偏序集S，|S|=k且k=O(n)，S={S1,S2,..Sk}；则计数排序可以描述如下：

1、扫描整个集合S，对每一个Si∈S，找到在线性表L中小于等于Si的元素的个数T(Si)；

2、扫描整个线性表L，对L中的每一个元素Li，将Li放在输出线性表的第T(Li)个位置上，并将T(Li)减1。

 

void cntsort(int *a, int n, int *s,int *Rank)
{
	int i, j;
	for (i = 1;i <= n;i++)
		s[a[i]]++;
	for (i = 1;i <= 100;i++) 
		s[i] += s[i - 1];
	for (i = n;i >= 1;i--)
		Rank[s[a[i]]--] = a[i];
	for (i = 1;i <= n;i++)
		printf("%d ", Rank[i]);
	printf("\n");
}

七：快速排序

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

复杂度：O(nlogn)

void quicksort(int *a, int l, int r)
{
	int i = l, j = r, k = a[l];
	if (l < r)
	{
		while (i < j)
		{
			while (i < j&&a[j] >= k)
				j--;
			if (i < j) a[i++] = a[j];
			while (i < j&&a[i] <= k)
				i++;
			if (i < j) a[j--] = a[i];
		}
		a[i] = k;
		quicksort(a, l, i - 1);
		quicksort(a, i + 1, r);
	}
}

八：堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

 

大根堆排序算法的基本操作：

①建堆，建堆是不断调整堆的过程，从len/2处开始调整，一直到第一个节点，此处len是堆中元素的个数。建堆的过程是线性的过程，从len/2到0处一直调用调整堆的过程，相当于o(h1)+o(h2)…+o(hlen/2) 其中h表示节点的深度，len/2表示节点的个数，这是一个求和的过程，结果是线性的O(n)。

②调整堆：调整堆在构建堆的过程中会用到，而且在堆排序过程中也会用到。利用的思想是比较节点i和它的孩子节点left(i),right(i)，选出三者最大(或者最小)者，如果最大（小）值不是节点i而是它的一个孩子节点，那边交互节点i和该节点，然后再调用调整堆过程，这是一个递归的过程。调整堆的过程时间复杂度与堆的深度有关系，是lgn的操作，因为是沿着深度方向进行调整的。

③堆排序：堆排序是利用上面的两个过程来进行的。首先是根据元素构建堆。然后将堆的根节点取出(一般是与最后一个节点进行交换)，将前面len-1个节点继续进行堆调整的过程，然后再将根节点取出，这样一直到所有节点都取出。堆排序过程的时间复杂度是O(nlgn)。因为建堆的时间复杂度是O(n)（调用一次）；调整堆的时间复杂度是lgn，调用了n-1次，所以堆排序的时间复杂度是O(nlgn)[2]

完整代码

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxm = 100005;
int a[maxm];
void max_heap(int a[], int x, int n)
{
	int id = x, L = x * 2, R = x * 2 + 1;
	if (L <= n&&a[L] > a[id]) id = L;
	if (R <= n&&a[R] > a[id]) id = R;
	if (id != x)
	{
		swap(a[id], a[x]);
		max_heap(a, id, n);
	}
}
void build_maxheap(int a[], int n)
{
	for (int i = n / 2;i >= 1;i--)
		max_heap(a, i, n);
}
void heapsort(int a[], int n)
{
	int len = n, i;
	build_maxheap(a, len);
	for (i = n;i >= 2;i--)
	{
		swap(a[1], a[i]);
		len--;
		max_heap(a, 1, len);
	}
}
int main()
{
	int n, i, j;
	scanf("%d", &n);
	for (i = 1;i <= n;i++)
		scanf("%d", &a[i]);
	heapsort(a, n);
	for (i = 1;i <= n;i++)
		printf("%d ", a[i]);
	printf("\n");
	return 0;
}