目录
一、排序的概念
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
二、插入排序
比如，在实际中我们玩扑克牌时，就用了插入排序的思想
1、直接插入排序
直接插入排序的算法过程如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
我们来看一下代码的运行过程：
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++) {
int end = i;
int tmp = a[i + 1];
while (end >= 0) {
if (a[end] > tmp) {
a[end + 1] = a[end];
end--;
}
else {
break;
}
}
a[end + 1] = tmp;
}
}- 函数参数：指针a接收数组，n接收数组元素个数。
- 首先，外层循环从第一个元素开始遍历到倒数第二个元素，因为在内层循环中需要比较当前元素和前一个元素的大小，所以最后一个元素不需要再比较。
- 在外层循环中，我们将当前元素的下一个元素作为待插入元素，将当前元素的下标保存在变量end中，这个变量表示当前元素在已排序部分中的位置。
- 接下来while循环中，我们在已排序部分从后往前遍历，比较当前元素和已排序部分中的元素大小，如果当前元素小于已排序部分中的元素，则将已排序部分中的元素后移一位，直到找到当前元素的正确位置。
- 最后，我们将待插入元素插入到正确的位置，即end+1的位置。
- 内层循环结束后，当前元素已经被插入到了正确的位置，我们继续外层循环，处理下一个元素，直到所有元素都被插入到正确的位置。
直接插入排序的特性总结：
2、希尔排序
希尔排序的算法过程如下：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对每个子序列进行插入排序；
- 将各个子序列中的排序结果合并成一个序列。
代码如下：
void ShellSort(int* a, int n)
{
//1、gap > 1 预排序
//2、gap == 1 直接插入排序
int gap = n;
while (gap > 1) {
gap = gap / 3 + 1;// +1可以保证最后一次一定是1
for (int i = 0; i < n - gap; i++) {
int end = i;
int tmp = a[end + gap];
while (end >= 0) {
if (a[end] > tmp) {
a[end + gap] = a[end];
end -= gap;
}
else {
break;
}
}
a[end + gap] = tmp;
}
}
}- 首先，我们选择一个增量gap=n，然后将序列分成若干个子序列，对每个子序列进行插入排序。
- 在这个实现中，我们使用了一个while循环来计算增量gap，每次将gap除以3并加1，保证gap最小为1，此时进行直接插入排序。
- 在外层while循环中，我们将序列分成若干个子序列，每个子序列的长度为gap。然后，我们对每个子序列进行插入排序，将子序列中的元素插入到已排序部分的正确位置。
-
在内层循环中，我们使用了一个变量end来表示当前元素的下标，每次将end减去gap，直到找到当前元素的正确位置。然后，我们将待插入元素插入到正确的位置，即end+gap的位置。
-
内层循环结束后，当前子序列已经排好序了，我们继续外层while循环，处理下一个子序列，直到所有子序列都被排好序了。
图中颜色相同的值为当前<间距gap>下的子序列，从前往后依次比较每个子序列（也就是相距 gap 个位置的值的大小）。
希尔排序的特性总结：
三、选择排序
1、直接选择排序
我们先看代码，然后通过一个例子就能明白了。
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int maxi = begin, mini = begin;
for (int i = begin; i <= end; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
// 如果maxi和begin重叠，修正一下即可
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
++begin;
--end;
}
}- 代码中的变量begin和end分别表示当前未排序的元素范围的起始和结束位置。
- 在while循环中，每次从begin到end的范围内找到最大和最小的元素，分别用maxi和mini记录它们的下标。
- 然后将mini所指向的元素与begin所指向的元素交换位置，将maxi所指向的元素与end所指向的元素交换位置。
- 如果maxi和begin重叠，说明mini所指向的元素是当前未排序元素中最大的，需要将maxi更新为mini。
- 最后，begin指针向后移动一位，end指针向前移动一位，继续进行下一轮排序。
begin = 0
end = 5maxi = 2
mini = 5begin = 1
end = 4maxi = 3
mini = 1时间复杂度
2、堆排序—排升序(建大堆)
向下调整函数
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
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;
}
}- 通过传入参数获取到当前的左子节点的位置。
- 当child位置小于数组元素个数时进行判断。
- 进入循环，首先判断检查右子节点是否存在并且比左子节点的值大，如果是，将
child更新为右子节点的索引，以确保选择更小的子节点进行比较。 - 比较选定的子节点的值与父节点的值，如果子节点的值大于父节点的值，就交换它们。
- 更新parent为新的子节点位置，更新child为新的左子节点位置，然后继续比较和交换，直到不再需要交换为止。
- 如果当前子节点不大于当前父节点则停止循环。
堆排序函数
// 排升序
void HeapSort(int* a, int n)
{
// 建大堆
for (int i = (n-1-1)/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;
}
}- 在HeapSort函数中，第一个循环调用了AdjustDown函数，将待排序数组构建成了一个大堆。但是，这个大堆并不是完全有序的，只是满足了大堆的性质，即每个节点的值都大于或等于其左右子节点的值。因此，需要进行第二个while循环，将大堆中的元素依次取出，交换堆顶元素和数组末尾元素，并重新调整大堆，直到整个数组有序。
- 第二个while循环中，将堆顶元素与数组末尾元素交换，然后将剩余元素重新调整为大堆。这样，每次交换后，数组末尾的元素就是当前大堆中的大值，而剩余元素仍然满足大堆的性质。重复以上步骤，直到整个数组有序。
代码完整版：
头文件
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
void PrintArray(int* a, int n);
void InsertSort(int* a, int n);
void ShellSort(int* a, int n);
void SelectSort(int* a, int n);
void HeapSort(int* a, int n);函数文件
#include "sort.h"
void PrintArray(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[i + 1];
while (end >= 0) {
if (a[end] > tmp) {
a[end + 1] = a[end];
end--;
}
else {
break;
}
}
a[end + 1] = tmp;
}
}
void ShellSort(int* a, int n)
{
//1、gap > 1 预排序
//2、gap == 1 直接插入排序
int gap = n;
while (gap > 1) {
gap = gap / 3 + 1;// +1可以保证最后一次一定是1
for (int i = 0; i < n - gap; i++) {
int end = i;
int tmp = a[end + gap];
while (end >= 0) {
if (a[end] > tmp) {
a[end + gap] = a[end];
end -= gap;
}
else {
break;
}
}
a[end + gap] = tmp;
}
}
}
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int maxi = begin, mini = begin;
for (int i = begin; i <= end; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
// 如果maxi和begin重叠，修正一下即可
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
++begin;
--end;
}
}
void AdjustDown(int* a, int n, int parent)
{
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 - 1 - 1) / 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--;
}
}
测试文件
#include"Sort.h"
#include<time.h>
void TestInsertSort()
{
//int a[] = { 4,7,1,9,3,4,5,8,3,2 };
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
PrintArray(a, sizeof(a) / sizeof(int));
InsertSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestSelectSort()
{
//int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
int a[] = { 9,7,1,3,3,0,5,8,3,2,3 };
PrintArray(a, sizeof(a) / sizeof(int));
SelectSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestHeapSort()
{
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
PrintArray(a, sizeof(a) / sizeof(int));
HeapSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestOP()
{
srand(time(0));
const int N = 1000000;//运行时间较长可自行更改大小
int* a1 = (int*)malloc(sizeof(int) * N);
int* a2 = (int*)malloc(sizeof(int) * N);
int* a3 = (int*)malloc(sizeof(int) * N);
int* a4 = (int*)malloc(sizeof(int) * N);
int* a5 = (int*)malloc(sizeof(int) * N);
int* a6 = (int*)malloc(sizeof(int) * N);
int* a7 = (int*)malloc(sizeof(int) * N);
for (int i = 0; i < N; ++i)
{
a1[i] = rand();
a2[i] = a1[i];
a3[i] = a1[i];
a4[i] = a1[i];
a5[i] = a1[i];
a6[i] = a1[i];
a7[i] = a1[i];
}
int begin1 = clock();
InsertSort(a1, N);
int end1 = clock();
int begin2 = clock();
ShellSort(a2, N);
int end2 = clock();
int begin3 = clock();
SelectSort(a3, N);
int end3 = clock();
int begin4 = clock();
HeapSort(a4, N);
int end4 = clock();
printf("InsertSort:%d\n", end1 - begin1);
printf("ShellSort:%d\n", end2 - begin2);
printf("SelcetSort:%d\n", end3 - begin3);
printf("HeapSort:%d\n", end4 - begin4);
free(a1);
free(a2);
free(a3);
free(a4);
free(a5);
free(a6);
free(a7);
}
int main()
{
//TestInsertSort();
//TestShellSort();
//TestSelectSort();
//TestHeapSort();
TestOP();
return 0;
}
