1.基本概念
排序是处理数据的一种最常见的操作，所谓排序就是将数据按某字段规律排列，所谓的字段就是数据节点的其中一个属性。比如一个班级的学生，其字段就有学号、姓名、班级、分数等等，我们既可以针对学号排序，也可以针对分数排序。
- 稳定性与非稳定性
稳定排序：排序前后两个相等的数相对位置不变，则算法稳定
非稳定排序：排序前后两个相等的数相对位置发生了变化，则算法不稳定
- 内排序与外排序
如果待排序数据量不大，可以一次性全部装进内存进行处理，则称为内排序，若数据量大到无法一次性全部装进内存，而需要将数据暂存外存，分批次读入内存进行处理，则称为外排序。
性能分析
不同的排序算法性能不同，详细性能数据如下表所示。
| 排序算法 | 平均 T(n) | 最坏 T(n) | 最好 T(n) | 空间复杂度 | 稳定性 |
| 选择排序 | O(n2) | O(n2) | O(n2) | O(1) | 不稳定 |
| 插入排序 | O(n2) | O(n2) | O(n) | O(1) | 稳定 |
| 希尔排序 | O(n1.3) | O(n2) | O(n) | O(1) | 不稳定 |
| 冒泡排序 | O(n2) | O(n2) | O(n) | O(1) | 稳定 |
| 快速排序 | O(nlog2n) | O(n2) | O(nlog2n) | O(nlog2n) | 不稳定 |
从表中可以得到一些简单的指导思路：
- 选择排序、插入排序和冒泡排序思路简单，但时间效率较差，只适用于数据样本较小的场合，这几种算法的好处是不需要额外开辟空间，空间复杂度是常量。
- 希尔排序是插入排序的改进版，在平均情况下时间效率要比直接插入法好很多，也不需要额外开辟空间，要注意的是希尔排序是不稳定排序。
- 快速排序是所有排序算法中时间效率最高的，但由于快排是一种递归运算，对内存空间要求较高，当数据量较大时，会消耗较多的内存。
2. 插入排序
2.1思路
插入排序的思路也很简单：假设前面已经有i节点是有序的（排好顺序），那么就从第i+1个节点开始，插入到前面的i个节点的合适的位置中。由于第一个元素自身总是有序的（假设性），因此从第2个开始，不断插入前面的有序序列，直到全部排列完毕。
假设总共有n个节点，那么总共需要将n−1个节点插入到有序序列中，而插入节点时需要找到合适的位置，显然这个查找的过程时间复杂度是O(n−i)，因此插入排序的时间复杂度是O(n−1)(n−i)，即O(n2)
2.2 示例代码
// 插入排序
/**插入排序就是遍历每个元素，要插入的元素都往前面的有序元素遍历比较，如果被比较的
* 元素比要插入的元素大，那就把大的元素往后挪(大的元素往后挪并且留一个空位插入)
* 一直往前比较，直到前面的元素比插入的元素小，那就把元素插入到其之后
* 设计思路:
* 设计两个循环,外循环遍历每一个元素,遍历要插入排序的元素,接着内循环拿到要插入排序
* 的元素,在前面已排序完成的元素进行插入排序。
* 理解就是假如有n个元素，那总共有n-1个元素要排序，因为第一个元素总是有序的
* 所以第一步设计for循环遍历每一个元素，将要插入的每个元素赋给一个临时变量，
* 接着进入内循环,将临时变量的元素在前面已排序完成的元素进行比较,找到要插入的地方
* 将要插入位置后面的元素向后挪再插入要插入的元素,或者直接插入要插入的元素,内循环结束
* 成功插入排序一个元素,以此类推,外循环遍历完所有的元素,插入排序完成
*/
#include <stdio.h>
/// @brief 插入排序
/// @param arr 数组首元素地址
/// @param len 数组元素个数
void insertSort(int *arr, int len)
{
int i, j, tmp;
// 当数组只有一个元素时,无需排序
if (len == 1)
{
return;
}
// 第一个元素无须排序
// 从arr[1] 到arr[len - 1]
for (i = 1; i < len; i++)
{
// 临时变量tmp拿到要插入排序的元素
tmp = arr[i];
// 在前面已排序完成的元素进行比较
for (j = i - 1; j >= 0; j--)
{
// 找到合适位置即跳出循环
if (arr[j] < tmp)
{
break;
}
else
{
// 元素向后挪,为插入元素挪出空位
arr[j + 1] = arr[j];
}
}
// 要插入的元素插入到合适位置中
arr[j + 1] = tmp;
}
}
int main(void)
{
int i, len;
int arr[6] = {0};
// 计算元素个数
len = sizeof(arr) / sizeof(int);
printf("请输入%d个整数:", len);
for (i = 0; i < len; i++)
{
scanf("%d", &arr[i]);
}
printf("排序前数据:");
for (i = 0; i < len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
// 插入排序
insertSort(arr, len);
printf("排序后数据:");
for (i = 0; i < len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
return 0;
}代码运行结果：
2.3插入排序单向循环链表：
/// @brief 插入排序链表
/// @param head 链表头节点
void insertSort(P_node_t head)
{
// 判断链表是否为空
if (isListEmpty(head))
{
printf("链表为空.\n");
return;
}
// outTmp外循环遍历链表每一个节点,inTmpPrev内循环遍历要插入节点之前的节点,inTmp为inTmpPrev后继节点
// insertNode存放指向要插入的节点,insertNodePrev为插入节点的前驱节点
P_node_t outTmp = NULL, inTmp = NULL, inTmpPrev = NULL, insertNode = NULL, insertNodePrev = NULL;
// 外循环遍历链表从有效节点开始,所以outTmp初始条件为head->next
// 当outTmp==head,outTmp遍历完整个链表,所以结束条件为outTmp!=head
for (outTmp = head->next; outTmp != head;)
{
// insertNode存放指向要插入的节点
insertNode = outTmp;
// 内循环进行每个insertNode要插入节点的插入位置寻找
// 插入需要前驱节点,所以初始条件从head头节点开始,结束条件为:遍历到要插入节点的前驱节点
for (inTmpPrev = head; inTmpPrev->next != insertNode; inTmpPrev = inTmpPrev->next)
{
// inTmpPrev遍历到合适的插入位置跳出循环
if (inTmpPrev->next->data.num > insertNode->data.num)
{
break;
}
}
// 此时跳出循环,有两种情况:
// 一是inTmpPrev遍历到要插入节点的前驱节点,即要插入节点前的链表都没有遍历到合适的位置插入
if (inTmpPrev->next == insertNode)
{
// 更新outTmp往下遍历
outTmp = outTmp->next;
// 此时要插入的节点在合适的位置无需插入,continue提高插入排序效率
continue;
}
// 插入前更新outTmp往下遍历
outTmp = outTmp->next;
// inTmp为inTmpPrev的后继节点
inTmp = inTmpPrev->next;
// 将insertNode节点插入前需要先将insertNode节点从链表中剔除下来,剔除insertNode节点需要用到其前驱节点
for (insertNodePrev = head; insertNodePrev->next != insertNode; insertNodePrev = insertNodePrev->next)
;
// 将insertNode从链表中剔除下来
// insertNode前驱节点的next指针指向insertNode的后继节点
insertNodePrev->next = insertNode->next;
// insertNode的next指针指向自己,将insertNode节点从链表剔除下来
insertNode->next = insertNode;
// 将insertNode插入到链表中,即inTmp节点和inTmpPrev节点之间
// insertNode的next指针指向inTmp
insertNode->next = inTmp;
// inTmpPrev的next指向insertNode
inTmpPrev->next = insertNode;
}
return;
}3.希尔排序
3.1. 希尔排序基本概念
1. 希尔排序的定义
希尔排序，又称为“缩小增量排序”，是插入排序的一种改进版本。它通过比较相隔一定间隔的元素，交换不相邻的元素，以在每一轮中逐步将未排序的序列变得有序。希尔排序的核心思想是通过逐渐减小元素之间的间隔，使得序列在初始阶段就呈现局部有序，从而减少插入排序的工作量。
2缩小增量排序
希尔排序的特点之一是采用了缩小增量的策略，即通过逐步减小间隔来进行排序。这种策略有助于将元素较远的部分先进行粗略排序，使得序列逐渐趋于整体有序。
3. 插入排序的变种
希尔排序可以看作是插入排序的一种变种，但在插入排序的基础上增加了分组和间隔的概念，通过这种方式来改进插入排序的性能。
3.2. 希尔排序的工作原理
1 分组
希尔排序首先将待排序的元素分成若干组，每组包含间隔为 h 的元素，其中 h 称为增量。初始增量的选择是关键的，不同的增量序列会影响排序的效率。
2 插入排序
对每组元素进行插入排序，即对每个小组内的元素使用插入排序算法进行排序。这一步的目的是在每个小组内部实现局部有序。
3 逐步减小增量
重复上述步骤，逐步减小增量，每次减小都会对分组后的小组进行插入排序。最终，当增量减小至 1 时，整个序列已经基本有序，最后进行一次插入排序，完成整个排序过程。
希尔排序通过引入增量，使得排序的过程在开始阶段就能够更好地利用局部有序性，从而提高了效率。虽然希尔排序的性能受到增量序列选择的影响，但相比于简单的插入排序，它在大规模数据集上的性能表现通常更好。
3.3. 算法步骤
希尔排序的算法步骤可以概括为以下几个关键步骤：
1. 初始化增量序列
选择一个增量序列，该序列通常是递减的正整数序列。常用的增量序列有希尔建议的序列、Hibbard序列、Sedgewick序列等。增量序列的选择会直接影响希尔排序的性能。
初始化增量一般选的是：len/2;
2. 外层循环：逐步缩小增量
使用选定的增量序列进行外层循环，每次循环缩小增量。在每一轮外层循环中，通过增量对元素进行分组，每组包含相隔一定间隔的元素。这一步骤旨在逐步减小元素之间的间隔，从而实现序列的局部有序。
3. 内层循环：插入排序
在每一组内，通过插入排序对元素进行排序。这是希尔排序的关键步骤，通过比较相隔增量的元素，并在需要时交换它们的位置，逐步实现每个小组的局部有序。
4. 完成排序
重复外层循环和内层循环，逐渐减小增量，直到增量为 1。最后一次外层循环使用增量为 1，相当于进行一次标准的插入排序。此时，整个序列已经基本有序，最终完成排序。
通过这样的逐步优化，希尔排序在大规模数据集上能够比插入排序更快速地完成排序任务。希尔排序的性能和增量序列的选择密切相关，因此对于不同的应用场景可能需要选择不同的增量序列以达到更好的排序效果。
#include <stdio.h>
void shellSort(int arr[], int n)
{
//缩小增量，以长度8为例，增量变化:4 2 1
for (int gap = n / 2; gap > 0; gap /= 2)
{
//组内排序 元素arr[gap]到arr[n-1]
for (int i = gap; i < n; i++)//
{
int temp = arr[i];
int j; //arr[0]>arr[4]
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
{
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
int main(void)
{
int i, len;
int arr[8] = {0};
//计算元素个数
len = sizeof(arr)/sizeof(int);
printf("请输入%d个整数:",len);
for(i=0; i<len; i++)
{
scanf("%d", &arr[i]);
}
printf("排序前数据:");
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
//希尔排序
shellSort(arr, len);
printf("排序后数据:");
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
return 0;
}4.冒泡排序(重点掌握)
首先引入两个概念：
- 顺序：如果两个数据的位置符合排序的需要，则称它们是顺序的。
- 逆序：如果两个数据的位置不符合排序需要，则称它们是逆序的。
冒泡排序基于这样一种简单的思路：从头到尾让每两个相邻的元素进行比较，顺序就保持位置不变，逆序就交换位置。可以预料，经过一轮比较，序列中具有“极值”的数据，将被挪至序列的末端。
假如序列中有n个数据，那么在最极端的情况下，只需要经过n−1轮的比较，则一定可以将所有的数据排序完毕。冒泡法排序的时间复杂度是O(n2)
示例代码：
#include <stdio.h>
#if 0
void maopaoSort(int arr[], int n)
{
int i, j;
//需要排序的数组次数
for(i=0; i< (n-1); i++)
{
//数组内排序 5-1 = 4
for(j=0; j < (n-i-1) ; j++)
{
if(arr[j] > arr[j+1])
{
//数据交换
int tmp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = tmp;
}
}
}
}
#else
void maopaoSort(int arr[], int n)
{
int i, j;
//需要排序的数组次数
for(i=(n-1); i > 0; i--)
{
for(j=0; j < i; j++)
{
if(arr[j] > arr[j+1])
{
//数据交换
int tmp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = tmp;
}
}
}
}
#endif
int main(void)
{
int i, len;
int arr[8] = {0};
//计算元素个数
len = sizeof(arr)/sizeof(int);
printf("请输入%d个整数:",len);
for(i=0; i<len; i++)
{
scanf("%d", &arr[i]);
}
printf("排序前数据:");
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
//冒泡排序
maopaoSort(arr, len);
printf("排序后数据:");
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
return 0;
}注意：
上述冒泡排序中，对算法做了优化，主要有两点：
1.由于每一趟比较后，都至少有1个“极值”被移至末端，因此第i趟比较只需n−i次
2.当发现某一趟比较中全部为顺序时，则意味着序列已经有序，则可以提前退出
5.选择排序
选择排序的思路非常简单，就是依次从头到尾挑选合适的元素放到前面。如果总共有n个节点，那么选择一个合适的节点需要比较n次，而总共要选择n次，因此总的时间复杂度是O(n2)
下面以无序数组data为例，假设存储的是整型数据，让其从小到大排序，示例代码：
#include <stdio.h>
void paixu(int *p,int len);
void swap(int *a, int *b);
void display(int *arr, int len);
int main(void)
{
int i, len;
int arr[10];
len = sizeof(arr)/sizeof(int);
printf("请输入10个整数:\n");
for(i=0; i<10; i++)
{
scanf("%d", &arr[i]);
}
printf("排序前数据:\n");
display(arr, len);
paixu(arr, len);
printf("排序后数据:\n");
display(arr, len);
}
//选择排序
void paixu(int *p,int len)
{
int i, j, min;
for(i=0; i<len; i++)
{
min = i; //最小值下标
for(j = i+1; j<len; j++)
{
if(p[j] < p[min]) //如果最p[j] 小于 p[min],要更换最小下标
{
min = j;
}
}
swap(&p[i], &p[min]);
}
return;
}
void swap(int *a, int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void display(int *arr, int len)
{
int i;
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
}6.快速排序（重点掌握）
1.基本思路
快排是一种递归思想的排序算法，先比较其他的排序算法，它需要更多内存空间，但快排的语句频度是最低的，理论上时间效率是最高的。
快速排序的基本思路是：在待排序序列中随便选取一个数据，作为所谓“支点”，然后所有其他的数据与之比较，以从小到大排序为例，那么比支点小的统统放在其左边，比支点大的统统放在其右边，全部比完之后，支点将位与两个序列的中间，这叫做一次划分（partition）。
一次划分之后，序列内部也许是无序的，但是序列与支点三者之间，形成了一种基本的有序状态，接下去使用相同的思路，递归地对左右两边的子序列进行排序，直到子序列的长度小于等于1为止。
2. 示例代码：
#include <stdio.h>
void display(int *arr, int len)
{
int i;
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
}
void swap(int *a, int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
//找支点
int partion(int *arr, int len)
{
int i, j;
if(len <= 1)
return 0;
i = 0;
j = len-1;
while(i < j)
{
while(arr[i] < arr[j] && i<j)
{
j--;
}
swap(&arr[i], &arr[j]);
while(arr[i] <= arr[j] && i<j)
{
i++;
}
swap(&arr[i], &arr[j]);
}
//返回支点
return i;
}
//快速排序
void quickSort(int arr[],int len)
{
if(len <= 1)
return;
//找支点
int pivort=partion(arr, len);
//左边
quickSort(arr, pivort);
//右边
quickSort(arr+pivort+1, len-pivort-1);
}
int main(void)
{
int i, len;
int arr[6] = {0};
//计算元素个数
len = sizeof(arr)/sizeof(int);
printf("请输入%d个整数:",len);
for(i=0; i<len; i++)
{
scanf("%d", &arr[i]);
}
printf("排序前数据:");
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
//快速排序
quickSort(arr, len);
printf("排序后数据:");
for(i=0; i<len; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
return 0;
}7.二分法查找（要求数据有序）
二分査找也称折半査找，其优点是查找速度快，缺点是要求所要査找的数据必须是有序序列。该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进行比较，如果相等，则表示査找成功，否则将以该位置为基准将所要査找的序列分为左右两部分。接下来根据所要査找序列的升降序规律及中间元素与所查找元素的大小关系，来选择所要査找元素可能存在的那部分序列，对其采用同样的方法进行査找，直至能够确定所要查找的元素是否存在，具体的使用方法可通过下面的代码具体了解。
#include <stdio.h>
//返回元素下标
int binarySearch(int a[], int n, int key)
{
//数组下标
int low = 0;
int high = n-1;
int midval;
int mid = 0;
while(low <= high)
{
mid = (low+high)/2;
midval = a[mid];
if(midval == key)
return mid;
if(midval < key)
{
low = mid+1;
}
else
{
high = mid-1;
}
}
return -1;
}
int main()
{
int i, val, ret;
int a[8]={-32, 12, 16, 24, 36, 45, 59, 98};
for(i=0; i<8; i++)
printf("%d\t", a[i]);
printf("\n请输人所要查找的元素：");
scanf("%d",&val);
ret = binarySearch(a,8,val);
if(-1 == ret)
printf("查找失败 \n");
else{
printf ("查找成功a[%d]:%d\n", ret, a[ret]);
}
return 0;
}运行结果：
-32 12 16 24 36 45 59 98
请输入所要查找的元素：12
查找成功
在上面的代码中，我们成功地通过二分査找算法实现了查找功能，其实现过程如下图所示。
二分査找算法的査找过程
在如上图所示的查找过程中，先将序列中间位置的元素与所要査找的元素进行比较，发现要査找的元素位干该位置的左部分序列中。接下来将mid的左边一个元素作为 high，继续进行二分査找，这时mid所对应的中间元素刚好是所要査找的元素，査找结束，返回査找元素所对应的下标。在main函数中通过返回值来判断査找是否成功，如果査找成功.就打印输出“査找成功”的信息，否则输出“査找失畋”的信息。
8.结语
在本篇博客中，我们深入探讨了数据结构中的常见排序和查找算法。排序算法不仅在数据处理和分析中扮演着重要角色，也为后续的数据操作打下了良好的基础。而查找算法则帮助我们高效地定位和访问数据，这对于提高程序性能来说至关重要。
不同的排序和查找算法各有优缺点，适用于不同的场景。选择合适的算法不仅能提升程序的效率，还能优化资源的使用。了解这些算法背后的原理和应用场景，将为你在数据处理领域打下坚实的基础。
