1.排序的概念及其运用

1.1排序的概念

排序的本质就是进行筛选，生活中是离不开排序的

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
 

1.2排序运用

买东西时候销量排序,综合排序，好评等等
院校排名等等
视频推荐流，推荐算法 带货排行榜

 

1.3 常见的排序算法

---

 

2.常见排序算法的实现

2.1 插入排序

2.1.1基本思想：

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

实际中我们玩扑克牌（斗地主理牌）时，就用了插入排序的思想

用升序方式看，降序就反过来
有序：
2 6 7 9

待插入数字： 10 5 0
单趟有序：有序区间，插入一个数依然有序
 

2.1.2直接插入排序：

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

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

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
   最优：顺序有序或接近顺序有序 O(N)
   最坏：逆序
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

//直接插入排序
void InsertSort(int* a, int n)
{
	//循环就是整体排序
	//n-2就是倒数第二个位置，因为是把end+1插入在前面，所以end后没值了for循环就停止了
	//数组下标是从0开始的
	for (int i = 0; i < n - 1; ++i)
	{
		//思路：[0,end]有序，把end+1位置的值插入，依然保持有序
		int end = i;
		//定义一个tmp变量，存放你将要插入的值
		int tmp = a[end + 1];//把end后一个插入前面去

		//单趟排序
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				//如果插入的值是0，--到-1时先跳出再赋值，不然0会无法插入
				break;
			}
		}
		a[end + 1] = 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
31

注意：它排序不是直接交换的，是把end+1插入到前面的有序序列中

 

2.1.3 希尔排序( 缩小增量排序 )

希尔排序法又称缩小增量法。

希尔排序法的基本思想是：

1. 先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。
2. 然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

思路： 预排序（接近顺序有序） 分组插入预排，分成gap组（间距为gap的是一组数据），对这些gap组数据分别进行插入排序 直接插入排序（有序）

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。

2. 当gap > 1时都是预排序，目的是让数组更接近于有序。
   当gap == 1时，数组已经接近有序的了，这样就会很快。
   这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定：

//希尔排序
void ShellSort(int* a, int n)
{
	//一组全部走完再进行下一组
//	//控制多组
//	int gap = 3;
//	//gap是几就有几组数据
//	for (int j = 0; j < gap; ++j)
//	{
//		for (int i = j; i < n - gap; i += gap)
//		{
//			//单趟，与直接插入排序思想相同
//			int end = i;
//			int tmp = a[end + gap];
//
//			while (end >= 0)
//			{
//				if (tmp < a[end])
//				{
//					a[end + gap] = a[end];
//					end -= gap;
//				}
//				else
//				{
//					break;
//				}
//			}
//			a[end + gap] = tmp;
//		}
//	}
//	


	//简化
	//一个接着一个走，组与组交替着走
	int gap = n;
	//gap>1时是预排序
	//gap最后一次等于1，就是直接插入排序（保证有序）
	while (gap > 1)
	{
		gap = gap / 3 + 1;

		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

注意：
gap越大，大的数更快到后面，小的数更快到前面，但越不接近有序
gap越小，越接近有序
当gap等于1时，就是直接排序

 

2.2 选择排序

2.2.1基本思想：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

2.2.2 直接选择排序:

思路：
选定第一个数，然后使用遍历在后面的数中依次进行对比，如果有比第一个数还要小的就进行对换，如果没有比要对比数还小的就在剩下的数中遍历出最小的放到前面去

遍历一遍进行选择
遍历一遍先选出最小的，再遍历一遍选出次小的，依次进行

在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

注意：找的是下标，进行交换

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

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

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//直接选择排序
void SelectSort(int* a, int n)
{
	assert(a);

	//begin,end是数组下标[]里的数，下标从0开始，所以最后一个就是n-1
	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[mini])
				//更新
				mini = i;

			if (a[i]>a[maxi])
				maxi = i;
		}//此时已经找到最大值与最小值，分别存放在maxi与mini中

		//交换
		Swap(&a[begin], &a[mini]);
  	//如果begin和maxi重叠，需要修正
		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
34
35
36
37
38
39
40
41
42
43
44
45

与堆排序对比： O(N^2) 优点简单，但是速度慢

与直接插入排序对比： 插入更好(只是与希尔排序优势较弱）
选择排序几乎是最慢的 最好是N^2，
最慢也是N^2

 

2.2.3 堆排序

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

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

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

void AdjustDwon(int* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{

		if (child + 1 < size && a[child + 1] > a[child])
		{
			++child;
		}

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

// 降序 -- 建小堆
// 升序 -- 建大堆

void HeapSort(int* a, int n)

{

	for (int i = (n-1-1)/2; i >= 0; --i)

	{

		AdjustDwon(a, n, i);

	}



	// O(N*logN)

	int end = n - 1;

	while (end > 0)

	{

		Swap(&a[0], &a[end]);

		AdjustDwon(a, end, 0);

		--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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58