C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++冒泡排序实现

C++实现冒泡排序的多种方式详解

作者：无限进步_

冒泡排序是最基础的排序算法之一,它的核心思想是通过相邻元素的比较和交换,将较大的元素逐步冒泡到数组的末尾,今天我们来分析三种不同的冒泡排序实现方式,每种都有其独特之处,需要的朋友可以参考下

引言

冒泡排序是最基础的排序算法之一，它的核心思想是通过相邻元素的比较和交换，将较大的元素逐步"冒泡"到数组的末尾。今天我们来分析三种不同的冒泡排序实现方式，每种都有其独特之处。

算法基础

冒泡排序的基本原理很简单：重复遍历待排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作重复进行，直到没有再需要交换的元素，这意味着该数列已经排序完成。

时间复杂度：

空间复杂度：O(1)

方法一：基础冒泡排序

int main()
{
    int a[] = { 2,1,5,7,3,9,0,4,6,8 };
    int temp = 0;
    int n = sizeof(a) / sizeof(a[0]);
    printf("%d\n",n);
    
    for (int i = 0; i < n-1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if ( a[j] > a[j+1] )
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
 
    for (int k = 0; k < n; k++)
    {
        printf("%d ", a[k]);
    }
    printf("\n");
    return 0;
}

代码解析

特点分析

优点：

缺点：

方法二：优化版冒泡排序

int main()
{
    int a[] = { 2,1,5,7,3,9,0,4,6,8 };
    int temp = 0, falg = 0;
    int n = sizeof(a) / sizeof(a[0]);
    printf("%d\n", n);
    
    for (int i = 0; i < n - 1; i++)
    {
        int flag = 1; // 假设这趟已经有序了
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                flag = 0; // 发生交换就说明，无序
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
        if (flag == 1) // 这一趟没交换就说明已经有序了，后续无需排序了
        {
            break;
        }
    }
 
    for (int k = 0; k < n; k++)
    {
        printf("%d ", a[k]);
    }
    printf("\n");
    return 0;
}

代码解析

这个版本在基础版本上增加了一个重要的优化：提前终止机制。

特点分析

优化效果：

实际应用价值：

这种优化在实际应用中非常有价值，因为很多场景下数据可能已经部分有序。

方法三：指针版冒泡排序

int main()
{
    int a[] = { 2,1,5,7,3,9,0,4,6,8 };
    int* p = a;
    int temp = 0, falg = 0;
    int n = sizeof(a) / sizeof(a[0]);
    printf("%d\n", n);
    
    for (int i = 0; i < n - 1; i++)
    {
        p = a; // 每趟开始时重置指针到数组开头
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (*p > *(p+1))
            {
                temp = *p;
                *p = *(p + 1);
                *(p + 1) = temp;
            }
            p++; // 指针后移
        }
    }
 
    for (int k = 0; k < n; k++)
    {
        printf("%d ", a[k]);
    }
    printf("\n");
    return 0;
}

代码解析

这个版本使用指针操作代替数组下标，展示了C语言指针的强大功能。

特点分析

技术特点：

学习价值：

对于理解C语言指针和内存管理很有帮助，是进阶学习的良好示例。

补充(指针版冒泡排序)

int main()
{
    int a[] = { 2,1,5,7,3,9,0,4,6,8 };
    int* p = a;
    int temp = 0, falg = 0;  // 注意：这里有个拼写错误，应该是flag
    int n = sizeof(a) / sizeof(a[0]);
    printf("%d\n", n);
    
    for (int i = 0; i < n - 1; i++)
    {
        int flag = 1;  // 每轮开始前假设数组已有序
        p = a;  // 重置指针到数组开头
        
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (*p > *(p+1))  // 使用指针比较相邻元素
            {
                flag = 0;  // 发生交换，标记为无序
                temp = *p;
                *p = *(p + 1);
                *(p + 1) = temp;
            }
            p++;  // 指针移动到下一个元素
        }
        
        if (flag == 1)  // 如果本轮没有发生交换
        {
            break;  // 提前结束排序
        }
    }
 
    for (int k = 0; k < n; k++)
    {
        printf("%d ", a[k]);
    }
    printf("\n");
    return 0;
}

三种方法对比

特性方法一方法二方法三
代码复杂度简单中等中等
执行效率稳定O(n²)最好O(n)稳定O(n²)
内存使用低低低
适用场景教学演示实际应用指针学习
优化程度无优化提前终止无优化

总结

三种冒泡排序实现各有特色：

虽然冒泡排序在实际应用中效率不高，但作为算法学习的入门课程，它帮助我们理解排序的基本概念和算法优化的重要性。掌握这三种实现方式，能够为学习更复杂的排序算法打下坚实基础。

无论选择哪种实现方式，理解算法背后的思想才是最重要的！

以上就是C++实现冒泡排序的多种方式详解的详细内容，更多关于C++冒泡排序实现的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:
阅读全文