【算法】六大排序 插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序_简单排序,简单插入排序,堆排序,快速排序

本章的所有代码可以访问这里

---

一、排序的概念及其运用

1.1排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求能在内外存之间移动数据的排序。

1.2 常见的排序算法

二、常见排序算法的实现

1、直接插入排序

• 基本思想
  直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

<实际中我们玩扑克牌时，就用了插入排序的思想>

• 步骤
  假设我们进行升序排序
  

1. 我们首先认为我们第一个数据是有序的。

2. 取一个数据data，将已排序的元素序列从后往前遍历

3. 如果遍历过程中发现已排序的元素序列中的某个数据Data1大于要排序的data那我们就将数据Data1向后移动一个单位，然后继续向前遍历。如果已排序的元素序列中的某个数据Data2小于data，那我们就将数据data放到Data2的后面，然后就不需要向前遍历了,因为已排序的元素序列经过上面的2-3步骤后新来的数据data也被放到了正确的位置。
   
   

4. 所以我们对许多数据进行排序就被转化为上面2-3步骤的循环了。

动图演示

• 代码实现

//直接插入排序
void InsertSort(int* a,int n)
{
	//排序 
	for (int i = 0; i + 1 < n; i++)
	{
		//end是有序数列的最后一个位置的下标
		int end = i;
		int tmp = a[end + 1];
		//end >= 0 防止在--end时数组越界
		while (end >= 0 && tmp < a[end])
		{
			a[end +1] = a[end];
			--end;
		}
		a[end+1] = tmp;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高（因为数据越接近于有序，向后挪动的次数就越小）
2. 最坏情况下为$O(n^2)$，此时待排序列为逆序，或者说接近逆序
   最好情况下为$O(n)$，此时待排序列为升序，或者说接近升序
3. 空间复杂度：$O(1)$，它是一种稳定的排序算法
4. 稳定性：稳定

2、希尔排序

希尔排序法的步骤是：
先选定一个小于N(N为数组的个数)的整数gap，把所有数据分成gap个组，所有距离为gap的数据分在同一组内，并对每一组的元素进行直接插入排序。然后取新的gap（新的gap要小于上一个gap），重复上述分组和排序的工作。当到达gap=1时，所有数据在同一组内排好顺序。

希尔排序法的思想是：
希尔排序先将待排序列通过gap分组进行预排序（gap>1时都是预排序），使待排序列接近有序，然后再对该序列进行一次插入排序（gap=1时其实就是插入排序），此时插入排序的时间复杂度接近于O(N)

代码实现

//希尔排序   正常一组一组排序
void ShellSort(int* a,int n)
{
	//定义第一次gap的值  
	int gap = n;
	//多次预排序，gap=1时是直接排序
	while (gap > 1)
	{
		//减小gap的值直到1
		gap = gap / 3 + 1;
		//多趟排序
		for (int j = 0; j < gap; j++)
		{
			//单趟排序  i是当前有序序列最后一个位置的下标
			for (int i = j; i + gap < n; i += gap)
			{
				int end = i;
				//记录一下待插入的数据
				int tmp = a[end + gap];
				//end >= 0 防止在end -=gap 时数组越界
				while (end >= 0 && tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				a[end + gap] = tmp;
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

• 希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间都不固定。
4. 时间复杂度平均：$O(N^{1.3})$
5. 空间复杂度：$O(1)$
6. 稳定性：不稳定

3、选择排序

基本思想：
每一次从待排序的数据元素中选出最小和最大的一个元素，存放在序列的起始位置和末尾位置，然后起始位置向后移动一个单位，末尾位置向前移动一个单位，直到全部待排序的数据元素排完 。

步骤：
遍历一遍整个数组，选出最大值和最小值，第一次将最小值放到a[0]最大值a[n-1],第二次将最小值放到a[1]最大值a[n-2]，直到下标$m>=n-m-1$结束程序。

动态演示
（下图演示的是一次只选一个最小值的算法，我们一次选出最大和最小，比图中的更高效一些）

代码实现

//选择排序
void SelectSort(int* a, int n)
{
	//多趟排序
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		//先假设 a[0] 位置既是最小值又是最大值
		//mini是最小值的下标，maxi是最大位置的下标
		int mini = begin, maxi = begin;
		//单趟遍历，选出最大值于最小值
		for (int i = begin; i <=end; ++i)
		{
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
			else if (a[i] < a[mini])
			{
				mini = i;
			}
		}
		Swap(&a[begin], &a[mini]);
		if (begin == maxi)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

直接选择排序的特性总结：

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

4、堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

堆排序详情请看这里

堆排序的特性总结：

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

5、冒泡排序

基本思想：
两两进行比较，左边大于右边就进行交换，走完一趟就排序好一个数。

代码实现

//冒泡排序
int BubbleSort(int*a,int n)
{
	for (int j = 0; j < n; j++)
	{
		//end是排序数组的最后一个需要排序元素的下标
		int end = n - 1 - j;
		//定义一个交换标志
		int exchange = 0;
		for (int i = 0; i < end; i++)
		{
			if (a[i] > a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
				exchange = 1;
			}
		}
		// 一趟冒泡过程中，没有发生交换，说明已经有序了，不需要再处理
		if (exchange == 0)
		{
			break;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

冒泡排序的特性总结：

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定

6、快速排序

基本思路：
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

6.1霍尔法

步骤：

1. 首先选出一个key值作为基准值，通常选择待排序列的最左边的值作为key值。
2. 定义两个下标，left与right,其中left指向待排序列的最左边值的下标，right指向待排序列最右边的下标。
3. 如果我们选择了最左边作为key值，我们就要让right位置判断a[right] < key如果成立，那就让right暂时停下来；如果不成立，就让right- -,直到找到一个位置a[right] < key ,找到后，right就暂时停下来。（需要注意的是：若选择最左边的数据作为key，则需要right先走；若选择最右边的数据作为key，则需要begin先走）。
4. right停下来之后，我们就要让左边的left的位置判断 a[left] > key 如果成立，就将a[left]与a[right]进行交换 ，如果不成立我们就将left++,直到找到一个位置a[left] > key ,找到后就与a[right]进行交换。
5. 然后重复3-4,直到 left=right 时，我们将key与a[ left ] ( 此时a[left]=a[right] )进行交换，此时key就到了正确的位置，key将数组分成了两部分，此时key的左边都比key小，key的右边都比key大，一次单趟排序完成，一次单趟排序搞定了一个数据。
6. 我们再对上一次的key的左右边的数组再进行上面的步骤，直到每个被分割的小区间都有序了，整个数组的排序就完成了。（最后当左右序列只有一个数据，或是左右序列不存在时，其实小区间就已经有序了）

动态演示

代码实现

//快速排序   hoare法   

void QuickSort(int* a, int begin, int end)
{
	//当区间只有一个值时，或区间不存在时退出递归
	if (begin >= end)
	{
		return;
	}
	//left是闭区间最最左边的下标，right是最右边位置的下标
	int left = begin, right = end;
	//选择最左边作为key值
	int keyi = left;
	//一趟排序
	while (left < right)
	{
		//右边先走，找到a[right]<key的位置
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		//左边后走，找到a[left]>key的位置
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		//交换左右两边的值,如果left == right了，也没有必要交换了。
		if (left != right)
		{
			Swap(&a[left], &a[right]);
		}
	}
	//交换左右两边的值,如果keyi == left了，也没有必要交换了。
	if (keyi != left)
	{
		Swap(&a[keyi], &a[left]);
	}
	keyi = left;
	//此时区间被分割为[begin,keyi-1] keyi [keyi+1,end]
	//注意传递的是begin,不是0,中间递归时不一定是从0开始的区间，0是一个常量，begin是一个变量。
	QuickSort(a, begin, keyi-1);
	QuickSort(a, keyi+1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

6.2挖坑法

步骤：

1. 先将待排序列的最左边的值定为key,用一个临时变量保存key的值同时该位置的下标定为第一个坑位hole。
2. 右边right寻找比key小的值，找到后放进坑位中，同时将坑位的位置更新为right。
3. 左边left寻找比key大的值，找到后放进坑位中，同时将坑位的位置更新为left。
4. 重复2-3步骤直到left==right，然后将key放到相遇位置，a[left]=key(或a[right]=key)
5. 此时单趟排序就排序好了，key的左边的值比key小，key右边的值比key大，key到了正确的位置，区间被分为两份，一次单趟排序好一个数。
6. 再对分割后的区间，进行多次上述的单趟排序，整个数组就有序了！
   

//快速排序  挖坑法
void QuickSort(int* a, int begin, int end)
{
	//当区间只有一个值时，或区间不存在时退出递归
	if (begin >= end)
	{
		return;
	}
	int left = begin, right = end;
	int keyi = left;
	//刚开始时keyi的位置作为坑位
	int hole = keyi;

	int key = a[keyi];
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			--right;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			++left;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	keyi = hole;
	
	//此时区间被分割为[begin,keyi-1] keyi [keyi+1,end]
	//注意传递的是begin,不是0,中间递归时不一定是从0开始的区间，0是一个常量，begin是一个变量。
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

6.3前后指针法

步骤：

1. 初始时，我们选定待排序的数据最左边作为key，定义prev也在待排序的数据最左边，定义cur在待排序的数据最左边+1。
2. cur向前找比key小的值，找到后停下来，然后++prev，交换prev位置和cur位置的值，当prev与cur拉开差距时，prev与cur之间夹的值都是大于等于key的值。
3. 最后cur刚好越界时，数组遍历完毕，交换a[prev]与key,此时key到了正确的位置，区间被分为两份，一次单趟排序好一个数。
4. 再对分割后的区间，进行多次上述的单趟排序，整个数组就有序了！

//快速排序  前后指针法
void QuickSort(int* a, int begin, int end)
{
	//当区间只有一个值时，或区间不存在时退出递归
	if (begin >= end)
	{
		return;
	}
	int prev = begin , cur = begin + 1;
	int keyi = begin;
	while (prev <= cur && cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;
	//此时区间被分割为[begin,keyi-1] keyi [keyi+1,end]
	//注意传递的是begin,不是0,中间递归时不一定是从0开始的区间，0是一个常量，begin是一个变量。
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

快速排序的特性总结：

1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
   
3. 空间复杂度：O(logN)
4. 稳定性：不稳定

7、快速排序非递归

快速排序的非递归实现要依赖栈，我们对快速排序进行递归时传递的关键数据是区间的下标，只有拿到了区间的下标我们才能进行正确的排序。
因此我们应该用利用栈的特性将区间的下标存放起来。

代码实现：

//单趟排序
int Partion3(int* a ,int begin ,int end)
{
	int prev = begin , cur = begin + 1;
	int keyi = begin;
	while (prev <= cur && cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;
	return keyi;
}
//快速排序的非递归实现
void QuickSortNonR(int* a ,int begin ,int end)
{
	Stack st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);

	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);

		//一趟排序
		int keyi = Partion3(a, left, right);

		//此时区间被划分为[left,keyi-1]keyi[keyi+1,right]
		if (keyi + 1 < right)
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
		if (left < keyi - 1)
		{
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
	}
	StackDestroy(&st);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50