排序 “壹” 之插入排序

编辑

一、排序的概念

1、排序：

2、稳定性：

[3.1 基本思想](#3.1 基本思想)

[3.2 直接插入排序](#3.2 直接插入排序)

[3.2.1 排序过程：](#3.2.1 排序过程：)

[3.2.2 代码示例：](#3.2.2 代码示例：)

[3.2.3 直接插入排序的特性总结：](#3.2.3 直接插入排序的特性总结：)

[3.3 希尔排序](#3.3 希尔排序)

[3.3.1 排序过程：](#3.3.1 排序过程：)

[3.3.2 代码示例：](#3.3.2 代码示例：)

[3.3.3 希尔排序的特性总结：](#3.3.3 希尔排序的特性总结：)

一、排序的概念

1、排序：

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

2、稳定性：

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

3、内部排序：

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

4、外部排序：

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

二、排序的运用

三、插入排序算法实现

3.1 基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

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

3.2 直接插入排序

3.2.1 排序过程：

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

**其基本思想是将待排序的元素逐个插入到已经有序的序列中，从而得到一个新的有序序列。**下面是直接插入排序的过程：

初始状态：将第一个元素视为一个有序序列，其余元素视为无序序列。

遍历无序序列：从第二个元素开始，依次将无序序列中的元素插入到有序序列中。

插入操作：对于每个待插入的元素，将其与有序序列中的元素从后往前逐个比较，找到合适的位置插入。

移动元素：再找到合适位置之后，需要将有序序列中大于待插入元素的元素依次向后移动，为待插入元素腾出位置。

插入元素：将待插入元素插入到正确的位置，形成新的有序序列。

重复步骤 2~5，直到所有元素都被插入到有序序列中，排序完成。

有些排序逻辑比较复杂，所以我们可以试试"先单趟再多趟，先局部再整体"的思想去实现它。

3.2.2 代码示例：

cpp 复制代码

//打印
void PrintSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

//直接插入排序
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 (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		//插入当前元素到正确位置
		a[end + 1] = tmp;
	}
}

//测试
int main()
{
	int a[] = { 2, 4, 5, 6, 5, 1, 9, 8, 0, 7, 3 };
	InsertSort(a, sizeof(a) / sizeof(int));
	PrintSort(a, sizeof(a) / sizeof(int));

	return 0;
}

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

元素集合越接近有序，直接插入排序算法的时间效率越高。

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

空间复杂度：O(1)，它是一种稳定的排序算法。

稳定性：稳定。

3.3 希尔排序

3.3.1 排序过程：

希尔排序是一种改进的插入排序算法，也称为缩小增量排序。它通过将原始数组分割成多个子序列来进行排序，然后对这些子序列进行插入排序。随着排序进行，逐渐缩小子序列的间隔，最终完成排序。

下面是希尔排序的基本过程：

选择一个增量序列，通常是使用希尔增量序列，例如：n/2、n/4、n/8、...... 、1。

根据选定的增量序列，将原始数组分割成若干个子序列，每个子序列包含元素间隔为增量的元素。

对每个子序列进行插入排序。

逐渐缩小增量，重复步骤2和3，直到增量为1。

最后一次以增量为1的插入排序完成后，整个数组就会被排序。

3.3.2 代码示例：

cpp 复制代码

//打印
void PrintSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;

	//gap > 1时是预排序，目的是让它接近有序
	//gap == 1时是直接插入排序，目的是让它有序
	while (gap > 1)
	{
		//加1是为了防止排到最后出现gap == 0的情况
		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;
		}
	}
}

//测试
int main()
{
	int a[] = { 3, 5, 7, 9, 0, 2, 4, 8, 8, 6 };
	ShellSort(a, sizeof(a) / sizeof(int));
	PrintSort(a, sizeof(a) / sizeof(int));

	return 0;
}

3.3.3 希尔排序的特性总结：

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

2.稳定性：不稳定。

当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序了，这样就会很快，整体而言，可以达到优化的效果。

希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定，但一般都是按**O(n^1.3)**计算。