1.冒泡排序
1.1基本思想：
冒泡排序是重复地遍历要排序的数列，一次比较两个元素大小，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
1.2基本思路：
（1）比较相邻的元素：如果第一个比第二个大，就交换它们两个。
（2）对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
（3）针对所有的元素重复以上的步骤，除了最后一个。
（4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
1.3图解过程：
动图演示：
1.4代码实现：
每一趟排序结束后把当前遍历的最大值放在最后位置
//冒泡排序
void Bubble_sort(int* arr, int n)
{
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
}
2.选择排序
2.1基本思想：
选择排序是在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复上一步，直到所有元素均排序完毕。
2.2基本思路：
（1）初始状态：假设有一个数组arr，长度为n。未排序序列为arr[0....n-1]，已排序序列为空。
（2）第一轮选择：从arr[0]到arr[n-1]中选择最小元素，假设是arr[i]，与arr[0]交换位置。此时，arr[0]到arr[0]为已排序序列，arr[1]到arr[n-1]为未排序序列。
（3）第二轮选择：在未排序序列arr[1..n-1]中继续寻找最小元素，假设是arr[j]，与arr[1]交换位置。此时，arr[0]到arr[1]为已排序序列，arr[2]到arr[n-1]为未排序序列。
（4）重复进行：每一轮都从剩余的未排序序列中选出最小元素，放到已排序序列的末尾，直到所有元素都被排序。
2.3图解过程：
动图展示：
2.4代码实现：
每趟找到最小值，把最小值放在本次寻找的范围第一个位置，这里为了提高效率，选择从两头找，分别找最大值和最小值
//选择排序
void Select_Sort(int* arr, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
int minx = begin;
int maxx = begin;
for (int i = begin + 1; i < end; i++)
{
if (arr[i] < arr[minx])
{
minx = i;
}
if (arr[i] > arr[maxx])
{
maxx = i;
}
}
Swap(&arr[minx], &arr[begin]);
if (maxx == begin)//这是最大值在第一个位置时候
maxx = minx;
Swap(&arr[maxx], &arr[end]);
end--;
begin++;
}
}
3.插入排序
3.1基本思想：
插入排序是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。在从后向前扫描过程中，找到排序位置后，需要将已排序元素逐步向后挪位，为最新元素提供插入空间。
3.2基本思路：
（1）初始状态：假设第一个元素是已排序的（或者认为它是一个只有一个元素的已排序序列）。
（2）从第二个元素开始遍历：取出下一个元素（记为当前元素），在已经排序的序列中从后向前扫描。
（3）寻找插入位置：如果当前元素小于扫描到的元素，则将该元素移到下一位置。
（4）重复步骤3，直到找到已排序的元素小于或等于当前元素的位置。
（5）插入元素：将当前元素插入到该位置后（即已排序序列的该位置后移，为新元素腾出空间）。
（6）重复步骤2~5：对序列中的下一个元素重复以上过程，直到整个序列排序完成。
3.3图解过程：
动图演示：
3.4代码实现：
前 i 个数当成有序的数组，把第 i+1 个数按照大小插入到数组中
//插入排序
void Insertion_Sort(int* arr, int n)
{
for (int i = 0; i < n - 1; i++)
{
//进行单趟排序(首先设置前 end 个数为有序的)
int end = i;
int temp = arr[end + 1];
while (end >= 0)
{
if (temp < arr[end])
{
arr[end + 1] = arr[end];
arr[end] = temp;
end--;
}
else
{
break;
}
}
arr[end + 1] = temp;
}
}
4.希尔排序
4.1基本思想：
希尔排序是一种基于插入排序的算法，其基本思路是通过设置不同的间隔序列（也称为增量序列）来将待排序的序列分割成若干个子序列，然后分别对这些子序列进行插入排序。随着间隔的逐渐减小，每个子序列包含的元素越来越多，直至间隔为1时，整个序列被视为一个子序列进行最后一次插入排序，从而完成整个排序过程。
4.2基本思路：
（1）选择初始间隔：通常选择序列长度的一半作为初始间隔（gap），即gap = length / 2。这个间隔用于将序列分割成若干个子序列。
（2）分组并排序：根据当前的间隔，将序列中的元素分组。具体来说，将间隔为gap的元素视为同一组，并对这些组内的元素进行插入排序。由于间隔的存在，这种插入排序并不是传统的相邻元素之间的比较和移动，而是间隔为gap的元素之间的比较和移动。
（3）缩小间隔：完成当前间隔下的分组和排序后，将间隔减半（gap = gap / 2），然后重复步骤2，继续对新的子序列进行插入排序。这个过程会一直重复，直到间隔为1。
（4）最后一次插入排序：当间隔减至1时，整个序列被视为一个子序列，此时进行一次普通的插入排序，完成整个排序过程。
4.3图解过程：
动图演示：
4.4代码实现：
分成间隔gap进行插入排序
//希尔排序 O(N^1.3)
void Shell_Sort(int* arr, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i++)
{
int end = i;
int temp = arr[end + gap];
while (end >= 0)
{
if (temp < arr[end])
{
arr[end + gap] = arr[end];
arr[end] = temp;
end -= gap;
}
else
{
break;
}
}
arr[end + gap] = temp;
}
}
}
5.堆排序
5.1基本思想：
堆排序是一种基于比较的排序算法，它利用堆这种数据结构所设计。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
5.2基本思路：
（1）构建堆：从最后一个非叶子节点开始，向前遍历每个节点，对每个节点进行下沉操作，确保每个节点都满足堆的性质。对于大顶堆，下沉操作是确保节点的值大于其子节点的值；对于小顶堆，则是确保节点的值小于其子节点的值。
（2）排序：将堆顶元素（即当前最大值或最小值）与堆数组的末尾元素交换，然后减少堆的大小（即不考虑已经排序好的末尾元素），并重新对新的堆顶元素执行下沉操作，以保持堆的性质。重复这个过程，直到堆的大小为1，此时数组就完全有序了。
5.3图解过程：
动态演示：
5.4代码实现：
先建立小堆进行预排序，再通过向下调整建大堆
//向上调整
void AdjustHeapUp(type* arr, int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (arr[parent] > arr[child])
{
Sweap(&arr[parent], &arr[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//向下调整
void AdjustHeapDown(type*arr,int n,int parent)
{
int child = 2 * parent + 1;
//找最小的那一个
while (child < n)
{
if (child + 1 < n && arr[child] > arr[child + 1])
{
child++;
}
if (arr[child] < arr[parent])
{
Sweap(&arr[child], &arr[parent]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
printf("\n");
}
}
void HeapSort(int* a, int n)
{
for (int i = 1; i < n; i++)
{
AdjustHeapUp(a, i);
}
printf("\n");
int k = n - 1;
while (k > 0)
{
Sweap(&a[0], &a[k]);
AdjustHeapDown(a, k, 0);
k--;
}
}