【大话数据结构】几种排序算法

这篇笔记主要是写写这些常见的排序算法。

冒泡排序

思想：两两比较相邻记录的关键字，反序则交换，直到没有反序为止。

#include <stdio.h>

/*交换int型数组L中下标i和j的值*/
void swap(int *L, int i, int j)
{
	int temp = L[i];
	L[i] = L[j];
	L[j] = temp;
}

void BubbleSort(int *L)
{
	int i, j;
	int len = sizeof(L) / sizeof(int);
	for (i = 0; i < len; i++)
	{				     /*i前面是排好序的*/
		for (j = len-1; j > i; j--)  /*从后向前比,小的在前,大的在后*/
		{
			if (L[j] < L[j-1])
			{
				swap(L, j, j-1);
			}
		}
	}
}

分析：最好的情况比较n-1次，时间复杂度O(n)；最坏的情况比较n(n-1)/2次，时间复杂度O(n²)。

选择排序

思想：每趟在n-i+1次比较里，选择关键字最小的记录与第i个记录交换。

void SelectionSort(int *L)
{
	int i, j, min;
	int len = sizeof(L)/sizeof(int);
	for (i = 0; i < len; i++)
	{
		min = i;
		for (j = i + 1; j < len; j++)  /*i+1前面是排好序的*/
		{
			if (L[j] <  L[min])
			{
				min = j;
			}
		}
		if (i != min)
			swap(L, i, min);
	}
}

分析：比较次数，最好最坏都是n(n-1)/2次；交换次数，最好0次，最坏n-1次，综合起来时间复杂度是O(n²)。性能比冒泡好一点。

插入排序

思想：将一个记录插入到已经排好序的有序表中，表记录数加1。

void InsertiontSort(int *L)
{
	int i, j;
	int len = sizeof(L)/sizeof(int);
	for (i = 0; i < len-1; i++)
	{
		int temp = L[i+1];
		for (j = i; j >= 0; j--)  /*i+1前面就是排好序的*/
		{
			if (temp < L[j])
				L[j+1] = L[j];  /*后移*/
		}
		L[j] = temp;  /*插入到正确的位置*/
	}
}

分析：如果记录顺序是随机的，平均比较和移动的次数为n²/4，时间复杂度是O(n²)。性能比冒泡和选择要好一点。

希尔排序

思想：（也称缩小增量排序）给出一个增量increment，让相隔增量的记录跳跃式的移动，这增加了效率。最后的increment必须为1。

void ShellSort(int *L)
{
	int i, j,increment;
	int len = sizeof(L) / sizeof(int);
	for (increment = len / 2; increment >= 1; increment = increment / 2)  /*定增量，并不断减小*/
	{
		for (i = increment; i < len; i++)
		{
			if (L[i] < L[i - increment])
				swap(L, L[i], L[i - increment]);
		}
	} 
}

分析：确定增量的取值也是一个问题，大量实验证明，其平均时间复杂度O(n^3/2)。希尔排序的出现突破了慢速排序（O(n²)）的时代，更为高效的算法陆续出现。

堆排序

思想：堆是一种特殊的完全二叉树，它只有两种：每个结点大于等于它子结点的是大顶堆，小于等于它子结点的是小顶堆。堆排序就是通过构造堆来排序。将待排序数组构成一个大顶堆，把堆顶的根结点（最大值）移走，也就是和堆数组末尾交换，最大值就到了数组最后，再将剩下n-1个数重新构造成一个堆，找到n个元素中第二大值，重复执行。

关键：1如何将原始无序数组构建成一个堆

           2输出堆顶元素后，如何调整剩余元素成为新堆

void swap(int *L, int i, int j)
{
	int temp = L[i];
	L[i] = L[j];
	L[j] = temp;
}
void HeapSort(int *L)
{
	int i;
	int len = sizeof(L) / sizeof(int);
	for (i = len / 2; i > 0; i--)  //完全二叉树调成堆，并不需要len次，只需要交换反了的结点
		HeapAdjust(L, i, len);
	for (i = len-1; i > 0; i--)
	{
		swap(L, 0, i);             //堆顶结点和序列最后一个元素交换
		HeapAdjust(L, 0, i - 1);   //将L[0...i-1]重新调整为大顶堆
	}
}
void HeapAdjust(int *L, int i, int j)
{
	int temp, k;
	temp = L[i];
	for (k = 2 * i; k <= j; k *= 2)
	{
		if (k < j && L[k] < L[k + 1])
			++j;					//k为关键字中较大记录的下标
		if (temp >= L[k])
			break;
		L[i] = L[k];
		i = k;
	}
	L[i] = temp;
}

分析：能提高效率是因为充分利用了二叉树深度是 ⌊log₂n⌋+1 的性质。构建堆的时间复杂度O(n)，重建堆的时间复杂度是O(nlogn)，所以总的时间复杂度是O(nlogn)。

归并排序

思想：将一个无序的数组，两两合并排序后再合并，最终得到有序数组。

#include <stdio.h>
#include <stdlib.h>

void MergeSort(int *L, int p, int r)  //用归并的方式把数组不断二分
{
	int q;
	if (p < r)
	{
		q = (int)((p + r) / 2);
		MergeSort(L, p, q);
		MergeSort(L, q + 1, r);
		Merge(L, p, q, r);
	}
}

void Merge(int *L, int p, int q, int r) //合并函数
{
	int i, j, k;
	int n1 = q - p + 1;
	int n2 = r - q + 1;
	int *left = (int *)malloc(sizeof(int)*n1);
	int *right = (int *)malloc(sizeof(int)*n2);
	for (i = 0; i < n1; i++)  //对左数组赋值  
		left[i] = L[p + i];
	for (j = 0; j < n2; j++)  //对右数组赋值  
		right[j] = L[q + 1 + j];

	i = j = 0;
	k = p;					 //k从L的起点开始
	while (i < n1 && j < n2) //将左右数组的元素两两比较，并合并到L 
	{
		if (left[i] <= right[j])
			L[k++] = left[i++];
		else
			L[k++] = right[j++];
	}
	for (; i < n1; i++) //如果左数组有元素剩余，则将剩余元素合并到L
		L[k++] = left[i];
	for (; j < n2; j++) //如果右数组有元素剩余，则将剩余元素合并到L
		L[k++] = right[j];
}

分析：结构类似于颠倒的完全二叉树，整个归并排序需要进行 ⌈log₂n⌉ 次，则总的时间复杂度是O(nlogn)；但因为过程中需要与原数组同大小的空间存放递归结果，并且要递归深度是 log₂n 的栈空间，则空间复杂度是O(n+logn)。它是一种比较占内存、但效率高且稳定的排序算法。

快速排序

思想：选取一个关键字（开始一般key=SqList[0]），找到它在数组中的位置，也就是从两端向中间扫描数组，通过交换把<key的放前面，>key的放后面；一次遍历终了相当于把整个数组partition成两部分（被key分开，未必平均分），递归每部分。

#include<iostream>

void QuickSort(int *A, int p, int r){
	int x = A[p];
	int i = p;
	int j = r;
	if (p < r){
		while (i < j)
		{
			for (; A[j] >= x && j > i; j--){}
			for (; A[i] <= x && i < j; i++){}
			if (i < j)
			{
				int temp = A[i];
				A[i] = A[j];
				A[j] = temp;
			}
			else{
				int temp = A[j];
				A[j] = x;
				A[p] = temp;
			}
		}
		QuickSort(A, p, j - 1);
		QuickSort(A, j + 1, r);
	}
}

还有一种比较优美的写法，

void QuickSort(int A[], int left, int right){
	if (left >= right)
		return;
	int i = left;
	int j = right;
	int key = A[left];
	while (i < j){
		while (i < j && key <= A[j])
			j--;
		A[i] = A[j];
		while (i < j && key >= A[i])
			i++;
		A[j] = A[i];
	}
	A[i] = key;
	QuickSort(A, left, i - 1);
	QuickSort(A, i + 1, right);
}

分析：平均时间复杂度是O(nlogn)，少数最差情况虽然也能达到O(n²)；因为递归使用栈空间，平均情况的空间复杂度是O(logn)。因为关键字的比较和交换是跳跃的，所以它是种不稳定的方法。