数据结构-排序-排序的七种算法（2）

bai_lan_ya2025-06-03 1:01

一，七种算法的介绍和比较

二，冒泡排序

  • 原理：重复遍历列表，比较相邻元素，如果顺序错误就交换它们

  • 时间复杂度：

    • 最好：O(n)（已有序时）

    • 平均：O(n²)

    • 最坏：O(n²)

  • 空间复杂度：O(1)

  • 稳定性：稳定

  • 特点：

    • 实现简单

    • 对部分有序数据效率较高

    • 每轮将最大元素"冒泡"到末尾

1.冒泡排序的基本思想：

cpp 复制代码 
/*对顺序表L作交换排序（冒泡排序初级版）*/
void Bubblesort0(SqList *L)
{
  int i,j;
  for(i=1;i<L->length;i++)
  {
     for(j=i+1;j<L->length;j++)
     {
        if(L->r[i] > L->r[j])
         {
           swap(L,i,j);//交换L->r[i]与L->r[j]的值
          }
     }
  }
}

这个思想使用图表示：

2.冒泡排序算法

cpp 复制代码 
/*对顺序表L作交换排序（冒泡排序初级版）*/
void Bubblesort(SqList *L)
{
  int i,j;
  for(i=1;i<L->length;i++)
  {
     for(j=L->length-1;j>=i;j--)
     {
        if(L->r[j] > L->r[j+1])
         {
           swap(L,i,j);//交换L->r[i]与L->r[j]的值
          }
     }
  }
}

具体表现形式如图：

当i=2时，变量j由8反向循环到2，逐个比较，在将关键字2交换到第二位置的同时，也将关键字4和3有所提升

3.冒泡排序优化

当我们待排序的序列是{2,1,3,4,5,6,7,8,9}，也就是说，除了第一和第二的关键字需要交换外，别的都已经是正常的顺序。当i=1时，交换了2和1，此时序列已经有序，但是算法仍然不停的循环将i=2到9以及每个循环中的j循环都执行了一遍，这样还会大大增加了算法计算的时间，如图

当i=2时，我们已经对9与8，8与7，.....3与2作了比较，没有任何数据交换，这就说明此序列已经有序，不需要再继续后面的循环判断工作了。

此时可以增加一个flag来实现这一算法的改进

cpp 复制代码 
/*对顺序表L作交换排序（冒泡排序初级版）*/
void Bubblesort2(SqList *L)
{
  int i,j;
  Status flag=TRUE;
  for(i=1;i<L->length&&flag;i++)
  {
     flag=GALSE;
     for(j=L->length-1;j>=i;j--)
     {
        if(L->r[j] > L->r[j+1])
         {
           swap(L,i,j);//交换L->r[i]与L->r[j]的值
           flag=TRUE;
          }
     }
  }
}

三，简单选择排序

1.核心思想

简单排序算法时一种直观但效率不高 的比较排序算法。它的核心思想是：每次从未排序的部分中找到最小（或最大）的元素，然后将其放到已排序部分的末尾

简单使用代码说明：

cpp 复制代码 
void SelectSort(SqList *L)
{
  int i,j,min;
  for(i=1;i<L->Length;i++)
  {
    min=1;
    for(j=i+1;j<=L->r[j])
       min=j;
  }
  if(i!=min)
  {
   swap(L,i,min);
  }
}

2.时间复杂度分析

  • 比较次数：无论数据初始状态如何，选择排序都需要进行大量的比较操作。

    • 第 1 趟：比较 n-1 次

    • 第 2 趟：比较 n-2 次

    • ...

    • 第 n-1 趟：比较 1 次

    • 总比较次数 = (n-1) + (n-2) + ... + 1 = n(n-1)/2

    • 因此，比较操作的时间复杂度为 O(n²)。

  • 交换次数：选择排序的优点是交换次数相对较少。

    • 最好情况（数组已有序）：每趟循环都会发现 min_index == i，因此交换 0 次。

    • 最坏情况（数组逆序）：每趟都需要交换一次，共进行 n-1 次交换。

    • 平均情况下，也是大约 O(n) 次交换。

  • 总时间复杂度 ：由于 O(n²) 的比较操作占主导地位，简单选择排序的平均和最坏情况时间复杂度都是 O(n²)。最好情况时间复杂度也是 O(n²)（因为比较次数仍然是 O(n²)，即使交换次数为 0）

3.优缺点分析

  • 优点：

    • 思路简单直观，易于理解和实现。

    • 交换次数少。在数据移动成本较高时（例如要排序的数据是复杂对象），这可能是一个优点（相对于冒泡排序）。

    • 原地排序，不需要额外的存储空间（除了少量临时变量）。

  • 缺点：

    • 时间复杂度高。O(n²) 的时间复杂度使其在处理大规模数据时效率低下。

    • 不稳定。如果需要保持相等元素的原始顺序，则不能使用简单选择排序。

    • 无论数据初始状态如何，比较次数几乎相同。即使输入数据已经有序或接近有序，它仍然需要进行 O(n²) 次比较。

四，直接插入排序

1.基本思想

这是一种简单直观且在实际应用中（特别是对小规模或基本有序的数据）表现不错的比较排序 算法。其基本操作是：将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表

基本代码如下：

cpp 复制代码 
void InsertSort(SqList *L)
{
  int i,j;
  for(i=2;i<L->Length;i++)
  {
   if(L->r[i] < L->r[i-1])
    {
      L->r[0]=L->r[i];
      for(j=i-1;L->r[j] > L->r[0];j--)
      {
        L->r[i+1] = L->r[j];
        for(j=i-1;L->r[j] > L->r[0];j--)
           L->r[j+1]=L->r[j];
        L->r[j+1]=L->r[0];
      }
    }
  }
}

2.时间复杂度的分析

3.优缺点分析

  • 优点：

    • 简单直观，易于实现。

    • 对于小规模数据或基本有序的数据效率非常高（特别是 O(n) 的最好情况）。

    • 原地排序，空间效率高 (O(1))。

    • 稳定排序。

    • 适应性 (Adaptive)： 当输入数据部分有序时，实际运行时间接近 O(n)。

    • 在线性 (Online)： 可以一边接收新数据一边排序（因为排序过程是增量式的）。

  • 缺点：

    • 平均和最坏情况时间复杂度为 O(n²)，不适合大规模随机数据。 当 n 较大时，效率显著低于 O(n log n) 的算法（如快排、归并、堆排）。

    • 元素移动操作较多。 每次插入都可能需要移动大量元素。

五，希尔排序

希尔排序是插入排序的高效改进版，由 Donald Shell 于 1959 年提出。它通过将原始列表分割成多个子序列进行预处理，大幅减少数据移动次数，显著提升排序效率。

1.核心思想

  1. 分组插入：按特定增量（gap）将数组分割为若干子序列

  2. 子序列排序：对每个子序列进行插入排序

  3. 逐步缩小增量：重复上述过程，直至增量为 1（此时等同于标准插入排序）

  4. 大跨度移动：早期使用大增量使元素大幅跳跃，减少小范围调整次数

算法代码如下：

cpp 复制代码 
void ShellSort(SqList *L)
{
  int i,j;
  int increment = L->length;
  do 
  {
     increment=increment/3+1;//增量排序
     for(i=increment+1;i<=L->length;i++)
       {
         if(i=increment+1;i<=L->length;i++)
          {
            //需将L->r[i]插入有序增量子表
            L->r[0] = r[i];
            for(j=i-increment;j>0&&L->r[0] < L->r[j];j-=increment)
            {
                L->r[j+increment] = L->r[j];
            }
            L->r[j+increment] = L->r[0];
           }
       }
  }while(increment>1);
}

代码解释如下：

2.优缺点

优点：

  1. 突破 O(n²) 屏障，中等规模数据效率高

  2. 原地排序，空间效率优异

  3. 代码简洁（约 10 行核心代码）

  4. 对部分有序数组效率接近 O(n)

缺点：

  1. 时间复杂度依赖增量序列选择

  2. 不稳定排序（需谨慎处理关键字段）

  3. 大规模数据仍不如 O(n log n) 算法（如快速排序）

六，堆排序

1，基本概念

堆排序（Heap Sort）是一种高效的基于比较的排序算法 ，利用二叉堆的数据结构实现。它结合了插入排序和归并排序的优点：时间复杂度为 O(n log n)（最优、平均和最坏情况），空间复杂度为 O(1)（原地排序），且不需要递归栈（可迭代实现）。

2.核心概念

  1. 二叉堆（Binary Heap）：

    • 完全二叉树结构（除最后一层外，所有层全满，最后一层从左向右填充）

    • 两种类型：

      • 最大堆：父节点值 ≥ 子节点值（根节点为最大值）

      • 最小堆：父节点值 ≤ 子节点值（根节点为最小值）

    • 存储方式：用数组表示，下标从 0 开始：

      • 父节点 i → 左子节点 2i+1，右子节点 2i+2

      • 子节点 i → 父节点 ⌊(i-1)/2⌋

  2. 核心操作：

    • 堆化（Heapify）：调整子树使其满足堆性质。

    • 建堆（Build Heap）：将无序数组初始化为堆。

    • 排序：反复取出堆顶元素（极值）并调整堆。

3.算法步骤

  • 建堆（Build Max Heap）：

    • 从最后一个非叶子节点开始（下标 n/2 - 1），向前遍历至根节点。

    • 对每个节点执行 下沉操作（Sift Down），使子树满足最大堆性质。

  • 排序：

    • 将堆顶元素（最大值）与当前堆末尾元素交换。

    • 堆大小减 1（排除已排序的最大值）。

    • 对新的堆顶元素执行 下沉操作，恢复最大堆性质。

    • 重复上述过程，直到堆中只剩一个元素。

4.代码示例

复制代码 
#include <stdio.h>

// 交换两个元素的值
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 下沉操作（最大堆）
void heapify(int arr[], int n, int i) {
    int largest = i;        // 初始化最大元素为当前节点
    int left = 2 * i + 1;   // 左子节点索引
    int right = 2 * i + 2;  // 右子节点索引

    // 如果左子节点大于当前节点
    if (left < n && arr[left] > arr[largest])
        largest = left;

    // 如果右子节点大于当前最大值
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // 如果最大值不是当前节点，交换并继续堆化
    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, n, largest);  // 递归调整被交换的子树
    }
}

// 堆排序主函数
void heapSort(int arr[], int n) {
    // 1. 构建最大堆（从最后一个非叶子节点开始）
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // 2. 逐个提取元素（堆排序核心）
    for (int i = n - 1; i > 0; i--) {
        // 将当前最大值（堆顶）移到数组末尾
        swap(&arr[0], &arr[i]);
        
        // 对剩余元素重新堆化（堆大小减1）
        heapify(arr, i, 0);
    }
}

// 打印数组
void printArray(int arr[], int n) {
    for (int i = 0; i < n; ++i)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("原始数组: ");
    printArray(arr, n);
    
    heapSort(arr, n);
    
    printf("排序后数组: ");
    printArray(arr, n);
    
    return 0;
}

代码解释

1. 关键函数说明

  • swap()：交换两个整数的值

  • heapify()：核心堆化操作

    • 确保以节点i为根的子树满足最大堆性质

    • 递归比较并交换父节点与子节点

  • heapSort()：堆排序主函数

    • 第一步：构建最大堆（自底向上）

    • 第二步：反复提取堆顶元素并调整堆

2. 执行流程

以输入数组 [12, 11, 13, 5, 6, 7] 为例：

  1. 构建最大堆：

    • 最后一个非叶子节点：n/2-1 = 6/2-1 = 2（即值13）

    • 从索引2开始向前处理：

      • 索引2（13）已满足堆性质

      • 索引1（11）：左子11<右子7 → 无需交换

      • 索引0（12）：左子11<13 → 与右子13交换

    • 最终堆：[13, 11, 12, 5, 6, 7]

  2. 排序过程：

    步骤 操作 当前数组状态 剩余堆大小
    1 交换堆顶13与末尾7 [7, 11, 12, 5, 6, 13] 5
    堆化剩余元素 [12, 11, 7, 5, 6, 13]
    2 交换堆顶12与末尾6 [6, 11, 7, 5, 12, 13] 4
    堆化剩余元素 [11, 6, 7, 5, 12, 13]
    3 交换堆顶11与末尾5 [5, 6, 7, 11, 12, 13] 3
    堆化剩余元素 [7, 6, 5, 11, 12, 13]
    4 交换堆顶7与末尾5 [5, 6, 7, 11, 12, 13] 2
    堆化剩余元素 [6, 5, 7, 11, 12, 13]
    5 交换堆顶6与末尾5 [5, 6, 7, 11, 12, 13] 1

  3. 最终结果 ：[5, 6, 7, 11, 12, 13]

5.优化方向

5.1 迭代版heapify：避免递归调用

复制代码 
void heapify_iterative(int arr[], int n, int i) {
    int largest = i;
    while (1) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        
        if (left < n && arr[left] > arr[largest])
            largest = left;
        if (right < n && arr[right] > arr[largest])
            largest = right;
        
        if (largest == i) break;
        
        swap(&arr[i], &arr[largest]);
        i = largest;  // 移动到被交换的子节点
    }
}

5.2.减少交换次数

复制代码 
// 在heapify中使用
void sift_down(int arr[], int start, int end) {
    int root = start;
    while (2 * root + 1 <= end) {
        int child = 2 * root + 1;
        int swap_idx = root;
        
        if (arr[swap_idx] < arr[child])
            swap_idx = child;
        if (child + 1 <= end && arr[swap_idx] < arr[child + 1])
            swap_idx = child + 1;
        
        if (swap_idx == root) return;
        
        // 仅一次赋值操作
        int temp = arr[root];
        arr[root] = arr[swap_idx];
        arr[swap_idx] = temp;
        
        root = swap_idx;
    }
}

七，归并排序

1.基本思想

归并排序采用分治策略（Divide and Conquer）：

  1. 分：将数组递归地分成两半

  2. 治：对每个子数组进行排序

  3. 合：将两个有序子数组合并为一个有序数组

2.算法步骤

  1. 分解：将数组分成两个大小相等的子数组（奇数长度时允许差1）

  2. 递归：对左右子数组递归进行归并排序

  3. 合并：合并两个已排序的子数组

3.代码举例

复制代码 
#include <stdio.h>
#include <stdlib.h>

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    
    int *L = malloc(n1 * sizeof(int));
    int *R = malloc(n2 * sizeof(int));
    
    for (int i = 0; i < n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
    
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
    
    free(L);
    free(R);
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

八，快速排序

1.基本思想

快速排序同样采用分治策略：

  1. 分区：选择一个基准元素（pivot），将数组分为两部分

    • 左侧：所有元素 ≤ pivot

    • 右侧：所有元素 > pivot

  2. 递归：对左右子数组递归进行快速排序

2.算法步骤

  1. 选择基准元素（pivot）

  2. 分区操作：将数组重新排列，使基准位于正确位置

  3. 递归排序左子数组和右子数组

3.代码举例

复制代码 
#include <stdio.h>

void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
相关推荐
czxyvX19 分钟前
06-排序
c语言·数据结构·算法·排序算法
2301_8203010239 分钟前
【机器学习】支持向量机
算法·机器学习·支持向量机
拾忆-eleven1 小时前
NLP学习路线图（二十）：FastText
人工智能·算法·机器学习·nlp
你真会1 小时前
【数据结构知识分享】顺序表详解
数据结构·学习·算法
@蓝莓果粒茶2 小时前
LeetCode第245题_最短单词距离III
c语言·c++·笔记·学习·算法·leetcode·c#
闻闻不会编程2 小时前
704. 二分查找 （力扣）
数据结构·算法·leetcode
AndrewHZ2 小时前
【图像处理基石】立体匹配的经典算法有哪些？
图像处理·算法·计算机视觉·滤波·模式识别·立体匹配
AndrewHZ2 小时前
【图像处理入门】4. 图像增强技术——对比度与亮度的魔法调节
图像处理·算法·计算机视觉·几何变换·图像增强·模式识别
不二狗3 小时前
每日算法 -【Swift 算法】查找字符串数组中的最长公共前缀
开发语言·算法·swift
不二狗3 小时前
每日算法 -【Swift 算法】将整数转换为罗马数字
开发语言·算法·swift
热门推荐
01机器学习实验--- 金融数据基础与计算在线实验闯关02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06DeepSeek各版本说明与优缺点分析07wandb使用遇到的一些问题08【2025年最新】OpenWrt 更换国内源的指南（图形界面版)09组基轨迹建模 GBTM的介绍与实现（Stata 或 R）10【解决】Android Gradle Sync 报错 Could not read workspace metadata