几种常用排序(冒泡插入希尔快排归并)
冒泡法（沉底法）
- 简介：简单排序中第一个学习的算法，入门必学算法。
- 效率：非常低。当数据达到一定数量级时，排序时间非常长。
- 原理：每一个元素和其他元素比较，符合条件就交换位置，不符合条件则不操作。
- 时间复杂度：
$O(n^2)$
- 空间复杂度：
$O(1)$
- 稳定性：稳定
- 代码实现：
bubble_Sort(int *a,int len)
{
int i, j;
int tmp;
for ( i = 0; i < len; ++i)
{
for ( j = 0; j < len - i; ++j)
{
if (a[j] < a[j + 1])
{
tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
}
}
插入法
- 简介：简单排序的一种。
- 效率：非常低，排序效率和冒泡法差不多。
- 原理：从第二个元素开始，记录该元素值，循环和前面的元素比较，符合条件则插入，不符合则继续与更前面的一个元素比，若循环结束都没找到符合条件的，则直接插入最前面。
- 时间复杂度：
$O(n^2)$
- 空间复杂度：
$O(1)$
- 稳定性：稳定
- 代码实现：
void insert_Sort(int *a, int len)
{
int tmp;
int j;
for (int i = 1; i < len; ++i)
{
tmp = a[i];
j = i - 1;
while (j >= 0 && a[j] > tmp)
{
a[j+1] = a[j];
j--;
}
a[j + 1] = tmp;
}
}
希尔排序
- 简介：高级排序的一种，插入法优化版，将数组按增量分组后再按插入法排序。
- 效率：较高
- 代码实现：
//希尔排序
void shell_sort(int *a, int len)
{
int inc = len;
while (inc > 1)
{
inc = inc / 3 + 1;
//把数组根据增量分组,然后遍历每一组
int i;
for (i = 0; i < inc; ++i)
{//对每组执行插入排序
int j;
for (j = i + inc; j < len; j += inc)
{
int tmp = a[j];
int k = j - inc;
while (k >= 0 && tmp < a[k])
{
a[k + inc] = a[k];
k -= inc;
}
a[k + inc] = tmp;
}
}
}
}
快速排序
- 简介：所有排序中速度最快的，但不稳定，递归实现。
- 效率：很高。
- 原理：取出左边第一个元素为tmp，1、右边倒序与tmp比较（小于tmp放左边取出元素的位置（进入循环2）），不符合则继续循环1；2、随即从左边按顺序与tmp比较，大于tmp的放右边取出元素的位置。1、2轮换进行循环。然后递归排序tmp左边和右边部分。左边和右边下标值相等或左边大于右边，则return。
- 时间复杂度：
$O(n log_2 n)$
- 空间复杂度：
$O(n log_2 n)$
- 稳定性：不稳定
- 代码实现：
//快速排序
void QuickSort(int *arr, int start, int end)
{
if (start >= end)
return;
int i = start;
int j = end;
int tmp = arr[i];
while (i < j)
{
while (i < j&&arr[j] >= tmp)
{
--j;
}
if (i<j&&tmp>arr[j])
{
arr[i] = arr[j];
i++;
}
while (i < j&&i < j&&arr[i] <= tmp)
{
++i;
}
if (i < j&&arr[i] > tmp)
{
arr[j] = arr[i];
j--;
}
}
arr[i] = tmp;
QuickSort(arr, start, i - 1);
QuickSort(arr, i + 1, end);
}
归并排序
- 简介：稳定的排序中效率最高的，递归实现。
- 效率：很高。
- 原理：归并操作的工作原理如下：
- 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
- 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
- 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
- 重复步骤3直到某一指针超出序列尾
- 将另一序列剩下的所有元素直接复制到合并序列尾
- 时间复杂度：
$O(n log_2 n)$
- 空间复杂度：
$O(n)$
- 稳定性：稳定
- 代码实现：
//归并排序辅助函数
void Merge(int *a, int start, int mid, int end, int *tmp)
{
int i = start;
int j = mid + 1;
int k = 0;
while (i <= mid&&j <= end)
{
if (a[i] < a[j])
{
tmp[k++] = a[i++];
}
else
{
tmp[k++] = a[j++];
}
}
while (i <= mid)
{
tmp[k++] = a[i++];
}
while (j <= end)
{
tmp[k++] = a[j++];
}
for (int i = 0; i < k; ++i)
{
a[start + i] = tmp[i];
}
}
//归并排序接口
void MergeSort(int *arr, int start, int end, int *tmp)
{
if (start == end)
{
return;
}
int mid = (start + end) / 2;
MergeSort(arr, start, mid, tmp);
MergeSort(arr, mid + 1, end, tmp);
Merge(arr, start, mid, end, tmp);
}
