【数据结构】C语言实现的排序算法总结

---

本文的排序算法均以升序为目标

一、插入排序

1.直接插入排序

直接插入排序可以理解为，已有一个有序序列a为[0,end] ，现将tmp=a[end+1]，现将tmp插入有序序列中使得[0,end+1]序列有序。
具体做法如下：
（1）从第一个元素开始（记为end），假设其已经有序；
（2）选择下一个元素tmp，与tmp之前的元素依次比较；
（3）若小于之前的数，插入到合适位置;
（4）tmp更新为新的a[end+1];
（5）重复以上过程；
图示过程：

代码如下（示例）：

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

最坏时间复杂度：O(N^2) 完全逆序
最好时间复杂度：O(N) 顺序
空间复杂度：O(1)

2.希尔排序（ShellSort）

希尔排序法也可称为缩小增量法，是对直接插入排序的优化。
整体思路如：
（1）先取gap进行预排序 — 结果使得数据接近有序（即小的数靠前，大的数靠后）；
（2）最后一次gap取1 — 即为插入排序；
图示如下:

代码如下（示例）：

void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		/*for (int i = 0; i < gap; ++i)
		for (int j = 0; j < n - gap; j += gap)*/
		// 综合以上两句
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

经验上gap的取值为gap = gap / 3 + 1;
+1的目的是确保最后一次排序的gap取1，也就是说最后一趟选择直接插入排序。

时间复杂度：O(N^1.3)
空间复杂度：O(1)

---

二、选择排序

1.堆排序

升序建大堆，把大的数向后移动；
降序减小堆，把小的数向后移动。
关键在于向下调整算法。
排序过程图示如下：

void AdjustDown(int* a, int n, int parent)
{
	// 注意建大根堆，选出大孩子与parent交换
	// 建小根堆，选出小孩子与parent交换
	// 假设左孩子大
	int maxchild = parent * 2 + 1;
	while (maxchild < n)
	{
		// *1* 左孩子小于右孩子，minichild++
		if (maxchild+1<n && a[maxchild] < a[maxchild + 1])
		{
			maxchild = maxchild + 1;
		}

		if (a[parent] < a[maxchild])
		{
			Swap(&a[parent], &a[maxchild]);
			parent = maxchild;
			maxchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

// O(N*logN)
void HeapSort(int* a, int n)
{
	// (1)建堆
	// 升序 -- 建大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	// (2)选数，即大数向后排
	int i = 1;
	while (i < n)
	{
		// 把堆顶(大数)换到堆尾
		Swap(&a[0], &a[n - i]);
		// 用其余n-1个数向下调准建堆，选出次大的数
		AdjustDown(a, n - i, 0);
		++i;
	}
}

时间复杂度：O(N*logN)
空间复杂度：O(1)

2.直接选择排序

直接选择排序的思路较为简单
首先假定maxi和mini的数都为begin，在遍历过程中，若a[i]<a[mini]，则更新mini=i；若a[i]>a[maxi]，则更新maxi=i;并且遍历每个数，交换a[begin]和a[mini];交换a[end]和a[maxi]。

代码实现如下：

void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin + 1; i <= end; ++i)
		{
			if (a[i] > a[maxi])
				maxi = i;
			if (a[i] < a[mini])
				mini = i;
		}

		Swap(&a[begin], &a[mini]);
		// ???????????
		if (maxi = begin)
			maxi = mini;

		Swap(&a[end], &a[maxi]);
		++begin;
		++end;
	}
}

时间复杂度：O(N^2)
空间复杂度：O(1)
直接选择排序效率不高，实际很少使用

---

三、交换排序

1.冒泡排序

局部交换，大值向后移动，小值向前移动
单趟排序：局部交换相邻两数的值
图示如下：

代码如下：
这里用exchange作为判断是否需要交换的的一个条件，一定程度上优化了冒泡排序过程

void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		int exchange = 0;
		for (int j = i; j < n - i; ++j)
		{
			if (a[j - 1] > a[j])
			{
				Swap(a[j-1], a[j]);
				exchange = 1;
			}
			if (exchange == 0)
			{
				// 如果不用交换
				// 就break出这个判断
				// 开始下一组判断
				break;
			}
		}
	}
}

时间复杂度：O(N^2)
空间复杂度：O(1)

2.快速排序

快速排序的基本思想是：任取序列中某个值为key，单趟排序后，把所有小于key的数都在key的右边，大于key的数都在key的右边。然后左右两个子序列重复这个过程，直到整个序列有序。
这个过程有三种实现方法，并有2个优化策略，接下来依次介绍：
（1）hoare 版本
该方法有两个指针left和right，分别指向队头和队尾；并选取队头元素为key值。
right指针先出发，找到比key小的数停止前进；
left找比key大的数停止，交换a[right]和a[left]。
单趟排序结束后，key左边的数均小于key，key右边的数均大于key。
需要注意的是，序列左边第一个数做key，必须right指针先出发，这样才能保证left与right相遇位置一定比key小。

单趟排序的价值：

• key已经到达其最终位置，即此数已经排好；
• 以key为分界线，分割出两个子区间 — 即转换为递归实现子问题。最终子区间有序，则整体有序。

图示如下：

代码实现：

//    (1) hoare版本
// key选在左边，则right先出发
// 最终right与left相遇位置与key交换
// 则key左边均小于key，右边均大于key
// 缺点：当每次交换后，key处于最右边，则时间/空间复杂度直线上升
int PartSort(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}

		if (left < right)
			Swap(&a[left], &a[right]);
	}

	int meeti = left;

	Swap(&a[meeti], &a[keyi]);

	return meeti;
}

---