常见排序算法总结

排序的相关概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假设在待排序的记录序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次数能够保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，经过排序以后，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，即在排序过程中要在内外存之间移动数据的排序。

常见的排序算法

常见排序算法的实现

1 插入排序

1.1直接插入排序

直接插入排序是一种简单的插入排序法，基本思想是：把待排序的记录按其关键码的大小依次插入到一个已经排好序的有序序列中，知道所有的记录插入完毕，得到一个新的有序序列。
过程：
1.拿到一个新序列，把第一个记录当成有序区间；
2.从第二个记录开始，与前面有序区间中的值从后往前依次比较，若小于一个数，则插入到这个数的前面，从插入位置开始往后的区间中的数依次后移。
3.接着从第三个记录开始，重复这个过程，知道最后一个记录完成。
代码实现：

void InsertSort(int *array, int size)
{
   
    for (int i = 1; i < size; ++i)//把0号下标即第一个元素当成有序序列
    {
   
         int key = array[i];//保存好要插入的元素
         int end = i - 1;//标记有序序列的最后一个元素
         while (end >= 0 && key < array[end])
         {
   
             array[end + 1] = array[end];
             end--;
         }
         //从循环出来代表end位置的元素小于或等于key，而end+1位置的元素比key大
         array[end + 1] = key;
    }
}

直接插入排序的特性总结：

• 元素集合越接近有序，直接插入排序算法的效率越高
• 时间复杂度：O(N^2)
• 空间复杂度：O(1)
• 稳定性：稳定
• 适用场景：接近有序，数据量比较少

1.2希尔排序（缩小增量排序）

希尔排序法又称缩小增量法，它是插入排序的一种优化，基本思想是：先选定一个整数，把待排序的序列中所有记录分成若干个小组，所有距离为gap的记录分在同一个组内，并对每一组内的记录进行排序。然后，取gap=gap/2，重复上述分组和排序的工作，当达到gap=1时，所有就在同一组内排好序。
过程：
1.过程类似于直接插入排序，是直接插入排序的一种优化
2.首先，确定一个步长gap，根据步长，将序列分成N/gap个组，每一部分单独运用直接插入排序
3.把步长缩短，重复这个过程，直到步长为1
代码实现：

void ShellSort(int *array, int size)
{
   
    int gap = size;
    while (gap>1)
    {
   
         gap = gap / 3 + 1;
         for (int i = gap; i < size; ++i)
         {
   
             int key = array[i];
             int end = i - gap;
             while (end >= 0 && key < array[end])
             {
   
                 array[end + gap] = array[end];
                 end -= gap;
             }
             array[end + gap] = key;
         }
    }
}

希尔排序的特性总结：

• 希尔排序是对直接插入排序的优化
• 时间复杂度需要推导，平均时间复杂度：O(N^1.3-N2)
• 空间复杂度：O(1)
• 稳定性：不稳定
• 希尔提出的gap取法是每次减半，但是有人发现取gap=gap/3+1时，时间复杂度最优，O(N^1.25-1.6N1.25)

2 选择排序

2.1直接选择排序

基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，放在序列的起始位置（或末尾位置），知道全部待排序的数据元素排完。
过程：
1.遍历整个序列，找到整个序列中最大的数，与末尾位置的数交换位置。
2.遍历到倒数第二个数，找到最大的数，与倒数第二个数交换位置。
3.重复整个过程，直到整个序列都排好序。
代码实现：

void SelectSort(int *array, int size)
{
   
    //选择的趟数
    for (int i = 0; i < size - 1; i++)
    {
   
         //选择的方式
         int maxPos = 0;
         for (int j = 1; j < size - i; j++)
         {
   
             if (array[j] > array[maxPos])
                 maxPos = j;
         }
         if (maxPos != size-i-1)
             Swap(&array[maxPos], &array[size - 1 - 
i]);
    }
}

直接选择排序的特性总结：

• 很好理解，但是效率不是很好，实际中很少用。
• 时间复杂度：O(N^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

直接选择排序优化
一次遍历，一起找出最大和最小元素
代码实现：

//选择排序优化
void SelectSortOP(int *array, int size)
{
   
    int begin = 0;
    int end = size - 1;
    while (begin < end)
    {
   
         int minPos = begin;
         int maxPos = begin;
         int index = begin + 1;
         //找最大最小元素的位置
         while (index<=end)
         {
   
             if (array[index] < array[minPos])
                 minPos = index;

             if (array[index]>array[maxPos])
                 maxPos = index;