本文详细介绍了六种常见的排序算法，包括插入排序、希尔排序、选择排序、冒泡排序、堆排序和快速排序，分别阐述了它们的步骤、思路、示例代码以及时间复杂度和空间复杂度。这些排序算法是计算机科学的基础，对于理解和优化数据处理至关重要。
目录
1.插入排序
步骤：
1.从第一个元素开始，该元素可以认为已经被排序
2.取下一个元素tem，从已排序的元素序列从后往前扫描
3.如果该元素大于tem，则将该元素移到下一位
4.重复步骤3，直到找到已排序元素中小于等于tem的元素
5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
6.重复步骤2~5
动图演示如下：
思路：
在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。
但我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。
代码如下：
void InsertSort(int* arr, int n)
{
for (int i = 0; i < n - 1; ++i)
{
//记录有序序列最后一个元素的下标
int end = i;
//待插入的元素
int tem = arr[end + 1];
//单趟排
while (end >= 0)
{
//比插入的数大就向后移
if (tem < arr[end])
{
arr[end + 1] = arr[end];
end--;
}
//比插入的数小，跳出循环
else
{
break;
}
}
//tem放到比插入的数小的数的后面
arr[end + 1] = tem;
//代码执行到此位置有两种情况:
//1.待插入元素找到应插入位置（break跳出循环到此）
//2.待插入元素比当前有序序列中的所有元素都小（while循环结束后到此）
}
}
时间复杂度：最坏情况下为O(N*N)，此时待排序列为逆序，或者说接近逆序
最好情况下为O(N)，此时待排序列为升序，或者说接近升序。
空间复杂度：O(1)
2.希尔排序
步骤：
1.先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…
2.当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。
动图如下：
思路：
希尔排序，先将待排序列进行预排序，使待排序列接近有序，然后再对该序列进行一次插入排序，此时插入排序的时间复杂度为O(N)。
代码如下：
//希尔排序
void ShellSort(int* arr, int n)
{
int gap = n;
while (gap>1)
{
//每次对gap折半操作
gap = gap / 2;
//单趟排序
for (int i = 0; i < n - gap; ++i)
{
int end = i;
int tem = arr[end + gap];
while (end >= 0)
{
if (tem < arr[end])
{
arr[end + gap] = arr[end];
end -= gap;
}
else
{
break;
}
}
arr[end + gap] = tem;
}
}
}
时间复杂度平均：O(N^1.3)
空间复杂度：O(1)
3.选择排序
思路：
每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。
实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。
动图如下：
代码如下：
//选择排序
void swap(int* a, int* b)
{
int tem = *a;
*a = *b;
*b = tem;
}
void SelectSort(int* arr, int n)
{
//保存参与单趟排序的第一个数和最后一个数的下标
int begin = 0, end = n - 1;
while (begin < end)
{
//保存最大值的下标
int maxi = begin;
//保存最小值的下标
int mini = begin;
//找出最大值和最小值的下标
for (int i = begin; i <= end; ++i)
{
if (arr[i] < arr[mini])
{
mini = i;
}
if (arr[i] > arr[maxi])
{
maxi = i;
}
}
//最小值放在序列开头
swap(&arr[mini], &arr[begin]);
//防止最大的数在begin位置被换走
if (begin == maxi)
{
maxi = mini;
}
//最大值放在序列结尾
swap(&arr[maxi], &arr[end]);
++begin;
--end;
}
}
时间复杂度：最坏情况：O(N^2)
最好情况：O(N^2)
空间复杂度：O(1)
4.冒泡排序
思路：
左边大于右边交换一趟排下来最大的在右边。
动图如下：
代码如下：
//冒泡排序
void BubbleSort(int* arr, int n)
{
int end = n;
while (end)
{
int flag = 0;
for (int i = 1; i < end; ++i)
{
if (arr[i - 1] > arr[i])
{
int tem = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = tem;
flag = 1;
}
}
if (flag == 0)
{
break;
}
--end;
}
}
时间复杂度：最坏情况：O(N^2)
最好情况：O(N)
空间复杂度：O(1)
5.堆排序
思路：
要实现从小到大的排序，就要建立大顶堆，即父节点比子节点都要大。
2.1、初始化数组，创建大顶堆。
1. 大顶堆的创建从下往上比较，不能直接用无序数组从根节点比较，否则有的不符合大顶堆的定义。
2.2、交换根节点和倒数第一个数据，现在倒数第一个数据就是最大的。
2.3、重新建立大顶堆。
1. 因为只有 array[0] 改变，其它都符合大顶堆的定义，所以可以根节点 array[0] 重新建立。
2.4、重复2.2、2.3的步骤，直到只剩根节点 array[0]，即 i=1。
动图如下：
代码如下：
#include <stdio.h>
void display(int array[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", array[i]);
}
printf("\n");
}
void swap(int array[], int x, int y) {
int key = array[x];
array[x] = array[y];
array[y] = key;
}
// 从大到小排序
// void Down(int array[], int i, int n) {
// int child = 2 * i + 1;
// int key = array[i];
// while (child < n) {
// if (child + 1 < n && array[child] > array[child + 1]) {
// child++;
// }
// if (key > array[child]) {
// swap(array, i, child);
// i = child;
// } else {
// break;
// }
// child = child * 2 + 1;
// }
// }
// 从小到大排序
void Down(int array[], int i, int n) { // 最后结果就是大顶堆
int parent = i; // 父节点下标
int child = 2 * i + 1; // 子节点下标
while (child < n) {
if (child + 1 < n && array[child] < array[child + 1]) { // 判断子节点那个大，大的与父节点比较
child++;
}
if (array[parent] < array[child]) { // 判断父节点是否小于子节点
swap(array, parent, child); // 交换父节点和子节点
parent = child; // 子节点下标 赋给 父节点下标
}
child = child * 2 + 1; // 换行，比较下面的父节点和子节点
}
}
void BuildHeap(int array[], int size) {
for (int i = size / 2 - 1; i >= 0; i--) { // 倒数第二排开始, 创建大顶堆，必须从下往上比较
Down(array, i, size); // 否则有的不符合大顶堆定义
}
}
void HeapSort(int array[], int size) {
printf("初始化数组：");
BuildHeap(array, size); // 初始化堆
display(array, size); // 查看初始化结果
for (int i = size - 1; i > 0; i--) {
swap(array, 0, i); // 交换顶点和第 i 个数据
// 因为只有array[0]改变，其它都符合大顶堆的定义，所以可以从上往下重新建立
Down(array, 0, i); // 重新建立大顶堆
printf("排序的数组：");
display(array, size);
}
}
int main() {
int array[] = {49, 38, 65, 97, 76, 13, 27, 49, 10};
int size = sizeof(array) / sizeof(int);
// 打印数据
printf("%d \n", size);
printf("排序前数组：");
display(array, size);
HeapSort(array, size);
return 0;
}
时间复杂度：
- 最好：O(n log n)
- 最坏：O(n log n)
- 平均：O(n log n)
空间复杂度：O(1)
稳定性：不稳定
6.快速排序
思路：
首先用数组的第一个数作为枢轴，然后将所有比它小的数都放到它的位置之前，所有比它大的数都放到它的位置之后，由此可以该“枢轴“记录最后所落的位置i作为分界线，将序列分割成两个子序列。这个过程称为一趟快速排序。
代码如下：
//快速排序
#include <iostream>
using namespace std;
void QuickSort(int *array,int low,int high){ //快排
if(low>=high){ //若待排序序列只有一个元素，返回空
return ;
}
int i=low; //i作为指针从左向右扫描
int j=high; //j作为指针从右向左扫描
int key=array[low];//第一个数作为基准数
while(i<j){
while(array[j]>=key&&i<j){ //从右边找小于基准数的元素 （此处由于j值可能会变，所以仍需判断i是否小于j）
j--; //找不到则j减一
}
array[i]=array[j]; //找到则赋值
while(array[i]<=key&&i<j){ //从左边找大于基准数的元素
i++; //找不到则i加一
}
array[j]=array[i]; //找到则赋值
}
array[i]=key; //当i和j相遇，将基准元素赋值到指针i处
QuickSort(array,low,i-1); //i左边的序列继续递归调用快排
QuickSort(array,i+1,high); //i右边的序列继续递归调用快排
}
int main(){
int array[]={49,38,65,97,76,13,27,49};
int length=sizeof(array)/sizeof(*array);
cout<<"原始序列：";
for(int i=0;i<length;i++){
cout<<array[i]<<" ";
}
cout<<endl;
QuickSort(array,0,length-1);
cout<<"快排序列：";
for(int i=0;i<length;i++){
cout<<array[i]<<" ";
}
return 0;
}时间复杂度：通常，快速排序被认为是，在所有同数量级(O(nlogn))的排序方法中，其平均性能最好。但是，若初始记录序列按关键字有序或基本有序时，快速排序将蜕化为冒泡排序，其时间复杂度为O(n²)。
最坏：O(n²) 最好和平均：O(nlogn)
1889
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
