常见排序算法的实现

原创

小明爱吃火锅

发布于 2025-02-06 19:28:47

1790

前言

排序算法是计算机科学中最基础且重要的算法之一，广泛应用于数据处理、数据库管理、图像处理等领域。通过排序算法，我们可以将无序的数据按照一定的规则重新排列，从而提高数据的查找、插入和删除效率。本次实验旨在通过实现几种常见的排序算法，深入理解其工作原理，并通过测试验证其正确性和效率。实验内容主要包括插入类排序、交换类排序和选择类排序的实现，具体涉及直接插入排序、冒泡排序、快速排序和简单选择排序。

插入类排序算法的实现

插入类排序算法的核心思想是将待排序的元素逐个插入到已排序序列中的适当位置，直到所有元素都插入完毕。直接插入排序是插入类排序算法的典型代表。

直接插入排序的实现

直接插入排序的实现步骤如下：

从第二个元素开始，依次将每个元素插入到前面已排序的序列中。
在插入过程中，如果当前元素小于前一个元素，则将前一个元素后移，直到找到合适的插入位置。
重复上述过程，直到所有元素都插入完毕。

以下是直接插入排序的代码实现：

void InsertSort(SqList &ST) { 
    for (int i = 2; i <= ST.length; i++) {
        if (ST.elem[i] < ST.elem[i - 1]) {
            ST.elem[0] = ST.elem[i]; // 暂存待插入元素
            int j;
            for (j = i - 1; ST.elem[j] > ST.elem[0]; j--) {
                ST.elem[j + 1] = ST.elem[j]; // 元素后移
            }
            ST.elem[j + 1] = ST.elem[0]; // 插入元素
        }
    }
}

直接插入排序的特点

时间复杂度：最好情况下为O(n)，最坏和平均情况下为O(n²)。
空间复杂度：O(1)，是一种原地排序算法。
稳定性：稳定排序算法，相同元素的相对位置不会改变。

交换类排序算法的实现

交换类排序算法的核心思想是通过交换元素的位置来实现排序。常见的交换类排序算法包括冒泡排序和快速排序。

冒泡排序的实现

冒泡排序的实现步骤如下：

从第一个元素开始，依次比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。
每一轮比较都会将当前未排序序列中的最大元素“冒泡”到末尾。
重复上述过程，直到所有元素都排序完毕。

以下是冒泡排序的代码实现：

void BubbleSort(SqList &L){  
    for (int i = 1; i < L.length; i++) {
        for (int j = 1; j <= L.length - i; j++) {
            if (L.elem[j] > L.elem[j + 1]) {
                swap(L.elem[j], L.elem[j + 1]); // 交换元素
            }
        }
    }
}

冒泡排序的特点

时间复杂度：最好情况下为O(n)，最坏和平均情况下为O(n²)。
空间复杂度：O(1)，是一种原地排序算法。
稳定性：稳定排序算法。

快速排序的实现

快速排序是一种分治算法，其实现步骤如下：

选择一个基准元素（通常选择第一个元素），将序列分为两部分，左边部分小于基准元素，右边部分大于基准元素。
递归地对左右两部分进行快速排序。
合并左右两部分，得到最终排序结果。

以下是快速排序的代码实现：

int Partition(SqList &L, int low, int high) {
    L.elem[0] = L.elem[low]; // 暂存基准元素
    while (low < high) {
        while (low < high && L.elem[high] >= L.elem[0]) high--;
        L.elem[low] = L.elem[high]; // 元素后移
        while (low < high && L.elem[low] <= L.elem[0]) low++;
        L.elem[high] = L.elem[low]; // 元素前移
    }
    L.elem[low] = L.elem[0]; // 基准元素归位
    return low;
}

void QuickSort(SqList &L, int low, int high) {
    if (low < high) {
        int pivotloc = Partition(L, low, high);
        QuickSort(L, low, pivotloc - 1);
        QuickSort(L, pivotloc + 1, high);
    }
}

void QuickSort(SqList &L) {
    QuickSort(L, 1, L.length);
}

快速排序的特点

时间复杂度：平均情况下为O(n log n)，最坏情况下为O(n²)。
空间复杂度：O(log n)，递归调用栈的深度。
稳定性：不稳定排序算法。

选择类排序算法的实现

选择类排序算法的核心思想是通过选择最小（或最大）元素来实现排序。简单选择排序是选择类排序算法的典型代表。

简单选择排序的实现

简单选择排序的实现步骤如下：

从第一个元素开始，依次找到未排序序列中的最小元素。
将最小元素与未排序序列的第一个元素交换位置。
重复上述过程，直到所有元素都排序完毕。

以下是简单选择排序的代码实现：

void SelectSort(SqList &L) {
    for (int i = 1; i < L.length; i++) {
        int min = i;
        for (int j = i + 1; j <= L.length; j++) {
            if (L.elem[j] < L.elem[min]) {
                min = j;
            }
        }
        if (min != i) {
            swap(L.elem[i], L.elem[min]); // 交换元素
        }
    }
}

简单选择排序的特点

时间复杂度：最好、最坏和平均情况下均为O(n²)。
空间复杂度：O(1)，是一种原地排序算法。
稳定性：不稳定排序算法。

总结

通过本次实验，我们实现了插入类、交换类和选择类排序算法，并对它们的特点进行了分析。以下是各排序算法的总结：

直接插入排序：适合小规模数据或基本有序的数据，时间复杂度为O(n²)，稳定且原地排序。
冒泡排序：适合小规模数据，时间复杂度为O(n²)，稳定且原地排序。
快速排序：适合大规模数据，平均时间复杂度为O(n log n)，不稳定但效率高。
简单选择排序：适合小规模数据，时间复杂度为O(n²)，不稳定但实现简单。

在实际应用中，我们需要根据数据规模、数据特点以及性能要求选择合适的排序算法。例如，对于大规模数据，快速排序通常是更好的选择；而对于小规模数据或基本有序的数据，直接插入排序或冒泡排序可能更为合适。通过本次实验，我们不仅掌握了这些排序算法的实现方法，还加深了对它们性能特点的理解。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S11#重启人生

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S11#重启人生

登录后参与评论

0 条评论

热度