几种常用排序(冒泡插入希尔快排归并)

几种常用排序(冒泡插入希尔快排归并)

冒泡法（沉底法）

• 简介：简单排序中第一个学习的算法，入门必学算法。
• 效率：非常低。当数据达到一定数量级时，排序时间非常长。
• 原理：每一个元素和其他元素比较，符合条件就交换位置，不符合条件则不操作。
• 时间复杂度：$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);
}