几种排序算法的C/C++实现

置顶 xiaoxin_zh

已于 2022-04-10 16:31:02 修改

阅读量4.8k

点赞数 23

分类专栏：数据结构排序算法文章标签：数据结构排序算法

于 2020-07-22 09:45:17 首次发布

本文链接：https://blog.csdn.net/weixin_42133358/article/details/107504760

版权

数据结构同时被 3 个专栏收录

7 篇文章 2 订阅

订阅专栏

排序

1 篇文章 0 订阅

订阅专栏

算法

1 篇文章 0 订阅

订阅专栏

几种排序算法总结及代码实现

注：本文排序算法的代码实现全部采取从小到大的方式进行排序

1. 冒泡排序

冒泡排序（Bubble Sort）就是一种交换排序，它的思想就是两个元素进行比较，如果是反序则交换，直到没有反序的元素为止。

排序图示

在这里插入图片描述

代码实现

#include <stdio.h>
//两个数进行交换的函数
void Swap(int *num1, int *num2)
{
    int temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
//冒泡排序的具体实现
void bubbleSort(int arr[], int len)
{
    for (int i = 0; i < len - 1; ++i)
    {
        for (int j = i + 1; j <= len  - 1; ++j)
        {
            if (arr[i] < arr[j])
            {
                Swap(&arr[i], &arr[j]);
            }
        }
    }
}
//打印函数
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    //求出数组的长度
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    bubbleSort(arr, len);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

输出结果

排序之前：

1 9 7 2 4 3 6 5 0 8

排序之后：

0 1 2 3 4 5 6 7 8 9

2. 选择排序

选择排序（Selection Sort）的思想就是在一直的元素中找到最大（小）的值放在起始的位置，再从剩余的元素中找到最大（小）的元素放在刚刚找到的最值得后面，以此类推，直到所有的元素全部排序结束。

排序图示

在这里插入图片描述

代码实现

#include <stdio.h>
void Swap(int *num1, int *num2)
{
    int temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
void SelectionSort(int arr[], int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < len; j++)
        {
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }
        if (i != min)
        {
            Swap(&arr[i], &arr[min]);
        }
    }
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    SelectionSort(arr, len);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

因为采用的示例和冒泡算法相同，且都是从小到大进行排序，故输出结果和冒泡排序相同，下同。

3. 快速排序

a. 快速排序(Quick Sort)也被称为划分排序或分区排序，它是目前所有的内部排序方法中速度最快的一种，快速排序是对起泡排序的一种改进。

b. 快速排序的思想是：选取一个基准数（一般取第一个数），将比基准数小的数放到基准数的前面，比基准数大的数交换到基准数的后面。经历一趟排序之后基准数左面都是比它小的数，右面都是比它大的数。对左右两个区间重复之前的操作，直到每个区间只有一个元素为止。

排序图示

在这里插入图片描述

代码实现

#include <stdio.h>
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
void QuickSort(int arr[], int start, int end)
{
    //这里的i和j表示初始的start和end
    int i = start;
    int j = end;
    int temp = arr[start];
    if (start < end)
    {
        while (start < end)
        {
            //从右向左找比基准数小的元素
            while (start < end && arr[end] >= temp)
            {
                end--;
            }
            if (start < end)
            {
                arr[start] = arr[end];
                start++;
            }
            //从左向右找比基准数大的元素
            while (start < end && arr[start] <= temp)
            {
                start++;
            }
            if (start < end)
            {
                arr[end] = arr[start];
                end--;
            }
        }
        //把基准数放到start和end重合的位置
        arr[end] = temp;
        //下面两行代码使用了递归的思想
        //对左半部分快排
        QuickSort(arr, i, end - 1);//此处用初始的start即i
        //对右半部分进行快排
        QuickSort(arr, end + 1,j);//此处用初始的end即j
    }
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    QuickSort(arr, 0, len - 1);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

4. 插入排序

插入排序（Insertion Sort)的思想就是将无需序列插入到有序序列中，从而能够得到一个新的、元素个数加1的有序序列。

排序图示

在这里插入图片描述

代码实现

#include <stdio.h>
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
void InsertionSort(int arr[], int len)
{
    for (int i = 1; i < len; i++)
    {
        int j;
        if (arr[i] < arr[i - 1])
        {
            int temp = arr[i];
            for (j = i - 1; j >= 0 && temp < arr[j]; j--)
            {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = temp;
        }
    }
}
int main(void)
{
    int arr[10] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    InsertionSort(arr, len);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

5. 希尔排序

希尔排序（Shell Sort）的思想是将待排序记录序列分成几个组，在每一组内分别进行直接插入排序，使得整个记录序列部分有序；重复此过程，直到所有记录都在同一组中，最后对所有的记录进行一次直接插入排序即可。

排序图示

在这里插入图片描述

代码实现

#include <stdio.h>
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
void ShellSort(int arr[], int len)
{
    int increment = len;
    do
    {
        increment = increment / 3 + 1;//增量序列
        int i, j, k;
        for (i = 0; i < increment; ++i)
        {
            for (j = i + increment; j < len; j += increment)
            {
                  if (arr[j] < arr[j - increment])
                  {
                      int temp = arr[j];
                      for (k = j - increment; k >=0 && temp < arr[k] ; k -= increment)
                      {
                          arr[k + increment] = arr[k];
                      }
                      arr[k + increment] = temp;
                  }
            }
        }
    }
    while (increment > 1);
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    ShellSort(arr, len);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

6.归并排序

归并排序（Merging Sort）就是利用归并的思想，将两个有序序列合并成一个有序序列（C++里STL中的merge算法）。
实现的方法：将长度为n的序列分成两个 n / 2 的子序列，对这两个子序列再次采用归并排序（递归），直到两个序列都是有序的（要求同序）。再将两个子序列合并为一个即可（再次使用归并排序）。

排序图示

在这里插入图片描述

代码实现

#include <iostream>
using namespace std;
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        cout << arr[i] << " ";
    }
}
void Merge(int arr[], int start, int end, int mid, int temp[])
{
    int i_start = start;
    int i_end = mid;
    int j_start = mid +1;
    int j_end = end;
    int length = 0;//辅助空间的元素
    //合并有序序列
    while (i_start <= i_end && j_start <= j_end)
    {
        if (arr[i_start] < arr[j_start])
        {
            temp[length] = arr[i_start];
            length++;
            i_start++;
        }
        else
        {
            temp[length] = arr[j_start];
            length++;
            j_start++;
        }
    }

    //将两区间剩余元素添加到辅助空间
    while (i_start <= i_end)
    {
        temp[length] = arr[i_start];
        i_start++;
        length++;
    }
    while (j_start <= j_end)
    {
        temp[length] = arr[j_start];
        j_start++;
        length++;
    }
    //辅助空间中的内容覆盖原序列
    for (int i = 0; i < length; ++i)
    {
        arr[start + i] = temp[i];
    }
}
void MergingSort(int arr[], int start, int end, int temp[])
{
    //首先进行分组
    if (start >= end)
    {
        return;
    }
    int mid = (start + end) / 2;
    //序列分两部分
    MergingSort(arr, start, mid, temp);
    MergingSort(arr, mid + 1, end, temp);
    Merge(arr, start, end, mid, temp);
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    int temp[len];//开辟一个辅助空间
    cout << "排序之前：" << endl;
    Print(arr, len);
    cout << endl;
    cout << "排序之后：" << endl;
    MergingSort(arr, 0, len - 1, temp);
    Print(arr, len);
    return 0;
}

7. 堆排序

在介绍堆排序之前，我们先来看一下堆的概念。

堆（Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：

堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一个完全二叉树。

其中，把堆中每个结点的值都大于或等于其左右两个子结点的值的堆称为大根堆；反之为小根堆。

大根堆图示

在这里插入图片描述

小根堆图示

在这里插入图片描述

堆排序（Heap Sort）就是利用堆进行排序的方法（因为我们要进行从小到大排序，所以利用大顶堆进行排序。）首先将待排序的序列构建为一个大顶堆，此时根结点就是值最大的元素，将该元素移到末尾，将剩余的 n - 1 个序列再重新构建为一个大顶堆，再将该序列的给结点元素移到该 n - 1 个元素的堆的末尾，以此类推，便可以得到一个有序序列。

建堆过程图示

在这里插入图片描述

排序图示

在这里插入图片描述

代码实现

#include <iostream>
#include <algorithm>
using namespace std;
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        cout << arr[i] << " ";
    }
}
void HeapAdjust(int arr[], int index, int len)//index代表待调整的结点下标
{
    int max = index;
    int lchild = index * 2 + 1;//左子结点下标
    int rchild = index * 2 + 2;//右子结点下标
    if (lchild < len && arr[lchild] > arr[max])
    {
        max = lchild;
    }
    if (rchild < len && arr[rchild] > arr[max])
    {
        max = rchild;
    }
    if (max != index)
    {
        swap(arr[index], arr[max]);
        HeapAdjust(arr, max, len);
    }
}

void HeapSort(int arr[], int len)
{
    //初始化为大顶堆
    for (int i = len / 2 - 1; i >= 0; --i)
    {
        HeapAdjust(arr, i, len);
    }
    for (int j = len - 1; j >= 0; --j)
    {
        swap(arr[0], arr[j]);
        HeapAdjust(arr, 0, j);
    }
}
int main()
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    int temp[len];//开辟一个辅助空间
    cout << "排序之前：" << endl;
    Print(arr, len);
    HeapSort(arr, len);
    cout << endl;
    cout << "排序之后：" << endl;
    Print(arr, len);
    return 0;
}

总结

总结以上几种算法的时间、空间复杂度

算法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n²⁾	O(1)	不稳定
选择排序	O(n²⁾	O(1)	数组：不稳定 / 链表：稳定
快速排序	O(nlog2n)	O(log2n)	不稳定
插入排序	O(n²⁾	O(1)	稳定
希尔排序	O(n^1.5)	O(1)	不稳定
归并排序	O(nlog2n)	O(n)	稳定
堆排序	O(nlog2n)	O(1)	不稳定

xiaoxin_zh

关注

23
点赞
踩
133

收藏

觉得还不错? 一键收藏
3
评论
几种排序算法的C/C++实现

几种常用排序算法总结及代码实现注：本文排序算法的代码实现全部采取从小到大的方式进行排序1. 冒泡排序冒泡排序（Bubble Sort）就是一种交换排序，它的思想就是两个元素进行比较，如果是反序则交换，直到没有反序的元素为止。排序图示代码实现#include <stdio.h>//两个数进行交换的函数void Swap(int *num1, int *num2){ int temp = *num1; *num1 = *num2; *num2 = te
复制链接

扫一扫