简单选择排序与堆排序
前言:简单选择排序与堆排序都属于选择排序,它们排序的思想是:每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置。然后再从剩余的未排序元素中寻找到最小(大)元素,放到已排序的序列的末尾,直到全部待排序的数据元素排完
注意:下文中所有排序都是升序
一、简单选择排序
简单选择排序思想:在待排序序列中选择关键码最小(大)的数据元素,若它不是序列中的最后一个(第一个)元素,则将它与这组元素中的最后一个(第一个)元素交换,重复上面步骤,直到序列只有1个元素为止
1.1 简单选择排序
void swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
void SelectSort(int* arr, int n)
{
assert(arr);
int begin = 0;
int end = n - 1;
while (begin < end) // 待排序序列元素个数小于等于1时退出循环
{
int max = 0; // 存放待排序序列最大值元素的下标
for (int i = begin; i <= end; i++) // 单趟排序
{
if (arr[max] < arr[i])
{
max = i;
}
}
if(max != end) // 当最大值元素不是待排序序列最后一个元素时,将最大值元素与序列最后一个元素交换
swap(&arr[max], &arr[end]);
end--;
}
}
1.2 简单选择排序优化
1.1 中每次排序找到序列中值最大的元素并与序列中最后一个元素交换。我们可以每次排序找到序列中值最小的元素和值最大的元素,分别与序列第一个元素和序列中最后一个元素交换,需要注意如果最大值元素是序列第一个元素时,需要特殊处理,因为最大值元素与序列最后一个元素交换前,最小值元素与序列第一个元素已经交换了,此时最大值元素位置存放的是最小值了
下面是错误代码
void swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
void SelectSort(int* arr, int n)
{
assert(arr);
int begin = 0;
int end = n - 1;
while (begin < end)
{
int max = begin; // 存放待排序序列最大值元素的下标
int min = begin; // 存放待排序序列最小值元素的下标
for (int i = begin; i <= end; i++)
{
if (arr[i] > arr[max])
max = i;
if (arr[i] < arr[min])
min = i;
}
if (min != begin) // 当最小值元素不是待排序序列第一个元素时,将最小值元素与序列第一个元素交换
swap(&arr[min], &arr[begin]);
if (max != end) // 当最大值元素不是待排序序列最后一个元素时,将最大值元素与序列最后一个元素交换
swap(&arr[max], &arr[end]);
begin++;
end--;
}
}
正确代码:
void swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
void SelectSort(int* arr, int n)
{
assert(arr);
int begin = 0;
int end = n - 1;
while (begin < end)
{
int max = begin; // 存放待排序序列最大值元素的下标
int min = begin;// 存放待排序序列最小值元素的下标
for (int i = begin; i <= end; i++)
{
if (arr[i] > arr[max])
max = i;
if (arr[i] < arr[min])
min = i;
}
if (min != begin) // 当最小值元素不是待排序序列第一个元素时,将最小值元素与序列第一个元素交换
swap(&arr[min], &arr[begin]);
if (max == begin) // 当max等于begin,上面操作将最大值换走了,需要调整最大值下标位置
max = min;
if (max != end) // 当最大值元素不是待排序序列最后一个元素时,将最大值元素与序列最后一个元素交换
swap(&arr[max], &arr[end]);
begin++;
end--;
}
}
1.3 时间复杂度与空间复杂度
无论是最好还是最坏情况下简单选择排序时间复杂度都是:O(N^2)
。简单选择排序只用了常数个辅助变量空间,空间复杂度:O(1)
说明:
●简单选择排序思想与代码实现比较简单,但是效率很低,一般很少使用
●简单选择排序是一个不稳定的排序算法
二、堆排序
堆排序排升序一般构造大根堆,降序一般构造小根堆
堆排序思想:利用堆的性质,将待排序的序列构造成一个大根堆,此时,整个序列的最大值就是堆顶的根节点。将它与堆数组的末尾元素交换,此时末尾元素就是最大值,然后将剩余的n-1个元素重新构造成一个大根堆,这样就会得到n个元素中的次大值。如此反复执行,便能得到一个有序序列
2.1 向下调整构建大根堆
void swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
void AdjustDown(int* data, int size, int parent) // 向下调整算法前提,左右子树必须为堆
{
/*
data为数组首元素地址,size为数组元素个数,parent为当前节点
*/
int child = parent * 2 + 1; // 左孩子
while (child < size) // 循环结束条件:1 调整到叶子节点(节点没有左孩子) 2. 孩子节点小于等于父节点
{
// 选出左右孩子中较大的一个
if (child + 1 < size && data[child + 1] > data[child])
{
child++;
}
if (data[child] > data[parent]) // 交换元素值,继续向下调整
{
swap(&data[child], &data[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
2.2 堆排序
void HeapSort(int* arr, int n)
{
assert(arr);
for (int parent = (n - 1 - 1) / 2; parent >= 0; parent--) // 建立大堆
{
AdjustDown(arr, n ,parent);
}
int end = n - 1; // 堆中最后一个元素下标
for (end; end > 0; end--)
{
swap(&arr[0], &arr[end]);
AdjustDown(arr, end, 0);
}
}
2.3 测试堆排序
#include <stdio.h>
#include <assert.h>
void PrintArray(const int* arr, int n)
{
assert(arr);
for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
void AdjustDown(int* data, int size, int parent) // 向下调整算法前提,左右子树必须为堆
{
int child = parent * 2 + 1;
while (child < size) // 循环结束条件:1 调整到叶子节点(节点没有左孩子) 2. 孩子节点大于等于(小于等于)父节点
{
// 选出左右孩子中较小(较大)的一个
if (child + 1 < size && data[child + 1] > data[child])
{
child++;
}
if (data[child] > data[parent]) // 交换元素值,继续向下调整
{
swap(&data[child], &data[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* arr, int n)
{
assert(arr);
for (int parent = (n - 1 - 1) / 2; parent >= 0; parent--) // 建立大堆
{
AdjustDown(arr, n ,parent);
}
int end = n - 1; // 堆中最后一个元素下标
for (end; end > 0; end--)
{
swap(&arr[0], &arr[end]);
AdjustDown(arr, end, 0);
}
}
int main()
{
int arr[10] = {2,5,1,9,7,4,7,3,6,10};
PrintArray(arr, 10);
HeapSort(arr,10);
PrintArray(arr, 10);
return 0;
}
输出
2 5 1 9 7 4 7 3 6 10
1 2 3 4 5 6 7 7 9 10
2.4 时间复杂度
堆排序主要消耗时间在建堆和排序上,使用向下调整建堆时间复杂度:O(N)
,排序时间复杂度:O(Nlog₂N)
,所以堆排序时间复杂度:O(Nlog₂N)
,堆排序只用了常数个辅助变量空间,空间复杂度:O(1)
说明:
●堆排序是一个不稳定的排序算法
●堆排序前需要建堆