数据结构—排序

在数据结构中，排序是一种将数据元素重新排列的过程，通常是为了使它们按照特定的顺序（如升序或降序）组织起来。排序在计算机科学中非常重要，下面是一些常见的数据结构排序方法和它们的特点

1.冒泡排序

• 原理：重复遍历待排序的列表，比较相邻元素并交换它们的顺序，使得较大的元素逐渐"冒泡"到列表的末端。
• 时间复杂度：O(n²)
• 空间复杂度：O(1)（原地排序）

冒泡排序的时间复杂度太高，处理大量数据消耗太长时间，通常只具有教学意义 

void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1]);
			}
		}
	}
}

函数中参数的 int* a 是一个数组，n是数组的元素个数

 这里的Swap是交换数据的函数

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

 2.选择排序 

• 原理：不断从未排序部分选择最小（或最大）元素，放到已排序部分的末尾
• 时间复杂度：O(n²)
• 空间复杂度：O(1)（原地排序）

 

标准选择排序的代码演示： 

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

为了稍微提高一些效率，可以一趟排两个数，即最大值和最小值，如下：

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

3.插入排序

• 原理: 将数组分为已排序和未排序部分，逐步将未排序元素插入到已排序部分。
• 时间复杂度: O(n²)
• 空间复杂度: O(1)

 插入排序的代码演示：

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

插入排序和冒泡排序是有区别的，通过动画可以看出，冒泡排序只是两两比较，大的数（或者小的数）两两交换位置，而插入排序是选定了一个数tmp，将它放在合适的位置，只是交换一次tmp，tmp并没有一直处在交换的状态

4.希尔排序 

• 时间复杂度：O( n 的1.3次方)  希尔排序的时间复杂度计算复杂，主流认为是n的1.3次方

 希尔排序是一种基于插入排序的排序算法，效率较高，它通过将数据集分成若干个子序列来改进插入排序的效率。这种分组的方式使得在每次插入时，数据元素的移动范围更小，从而加快了整体的排序速度

希尔排序是插入排序的进阶算法，与插入排序的区别是：有一个增量gap，对处在gap跨度的位置的数据看作一个整体，这时有多个整体，对其进行插入排序，gap逐渐变小，直至gap变为1，对其进行最后一次排序，并且这次排序就是插入排序

gap的变化：通常gap以 n/2 ，每次除2的形式变小，直至变为1，也有的以每次变为 1/3 的形式变小  

 希尔排序的代码演示：

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

5.堆排序

• 时间复杂度：n log n 

堆排序同样是比较高效的排序，将数据看作完全二叉树，建立大堆(堆顶的值最大)或小堆(堆顶的值最小)再将堆顶的数据放到末尾，并缩小末尾一个数据的范围，再调整建堆，直到最后变得有序

重要性质：排序时若父节点的位置是 n ，则左子节点的位置是 2*n + 1，右子节点的位置是 2*n + 2 ，依靠这个性质寻找父子节点

堆排序需要以堆为基础，再进行排序，因此需要调整建堆，代码： 

//向下调整建堆
void AdjustDown(int* a, int n, int parent) //n为数组有效数据
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && 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 - 2) / 2; i >= 0; i--) //大堆
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

这里排升序，一般采用建大堆，再将大的数据放到后面，便完成排序

堆排序中的for循环

for (int i = (n - 2) / 2; i >= 0; i--)
{
    AdjustDown(a, n, i);
}

实际上是从最末尾的小树调整建堆，最末尾可以形成树的父节点是 (n - 2 ) / 2

然后对父节点 - 1的节点依次建堆，直到以首元素为父节点的树进行建堆，便完成了整棵树的建堆

堆排序的while循环

while (end > 0)
{
    Swap(&a[0], &a[end]);
    AdjustDown(a, end, 0);
    --end;
}

是对堆顶元素放到末尾的操作，对剩余元素再调整建堆，重复操作，最后整个数组变得有序 

6.快速排序 

•  平均时间复杂度：O(n方)

快速排序并不好理解，以一趟为例：

选择一个数key（选择基准），放在头位置，两个指针分别从头位置和尾位置向中间移动

移动的规则是： 从头开始的指针向后移动如果遇到比key大的值就停下

从尾开始的指针向前移动，如果遇到比key小的值就停下

这两个指针都停下时，两个指针的值进行交换，如果两个指针相遇，则相遇的值与头位置的key的值交换（到这里，相遇左侧的值都比key小，相遇右侧的值都比key大）

然后以相遇位置为标记（分区），左侧进行同样的操作，右侧也进行同样的操作，（递归排序）

但是，真正的快速排序，还增加了小区间优化，和选择基准的优化

小区间优化简单来说就是，排序区间比较小时，采用插入排序完成，

 选择基准的优化：对头、尾、和中间数进行比较，选择中值为基准，作为key，可避免有序时的栈溢出

void QuickSort(int* a, int left, int right)
{
	if (left > right)
		return;
	
	if (right - left + 1 < 10)
	{
		InsertSort(a + left, right - left);
	}
	int	midi = GetMidi(a, left, right);
	Swap(&a[left], &a[midi]);

	int keyi = left;
	int begin = left;
	int end = right;
	while (begin < end)
	{
		while (begin < end && a[end] >= a[keyi])
		{
			--end;
		}
		while (begin < end && a[begin] <= a[keyi])
		{
			++begin;
		}
		Swap(&a[begin], &a[end]);
	}
	Swap(&a[keyi], &a[begin]);
	keyi = begin;
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}