不同语言下的冒泡排序的写法

本文深入解析冒泡排序算法,涵盖其定义、原理及C++、C#、JavaScript实现。通过详细步骤与代码示例,帮助读者理解冒泡排序如何通过交换相邻元素实现排序。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

冒泡排序的定义

它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。

冒泡排序算法的原理

1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2.对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤,除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

C++冒泡排序

// An highlighted block

#include <iostream>
using namespace std;
template<typename T>
//整数或浮点数皆可使用
void bubble_sort(T arr[], int len)
{
    int i, j;  T temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
        if (arr[j] > arr[j + 1])
        {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
}
int main()
{
    int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    bubble_sort(arr, len);
    for (int i = 0; i < len; i++)
        cout << arr[i] << ' ';
 
    cout << endl;
 
    float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
    len = (int) sizeof(arrf) / sizeof(*arrf);
    bubble_sort(arrf, len);
    for (int i = 0; i < len; i++)
        cout << arrf[i] << ' ';
 
    return 0;
}
--------------------- 

C#冒泡排序

// An highlighted block
namespace 数组排序
{
    class Program
    {
        static void Main(string[] args)
        {
            int temp = 0;
            int[] arr = {23, 44, 66, 76, 98, 11, 3, 9, 7};
            #region该段与排序无关
            Console.WriteLine("排序前的数组:");
            foreach (int item in arr)
            {
                Console.Write(item + "");
            }
            Console.WriteLine();
            #endregion
            for (int i = 0; i < arr.Length - 1; i++)
            {
                #region将大的数字移到数组的arr.Length-1-i
                for (int j = 0; j < arr.Length - 1 - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                    }
                }
            #endregion
            }
            Console.WriteLine("排序后的数组:");
            foreach (int item in arr)
            {
                Console.Write(item+"");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

C++冒泡排序

public static void bubbleSort(int []arr) {
        for(int i =0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-i-1;j++) {//-1为了防止溢出
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                     
                    arr[j]=arr[j+1];
                     
                    arr[j+1]=temp;
            }
            }    
        }
    }

- 关于 **Mermaid** 语法,参考 [这儿][3],

## FLowchart流程图

我们依旧会支持flowchart的流程图:
```mermaid
flowchat
st=>start: 开始
e=>end: 结束
op=>operation: 我的操作
cond=>condition: 确认?

st->op->cond
cond(yes)->e
cond(no)->op

javascript冒泡排序/js冒泡排序

function bubbleSort(arr) {
    var i = arr.length, j;
    var tempExchangVal;
    while (i > 0) {
        for (j = 0; j < i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                tempExchangVal = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tempExchangVal;
            }
        }
        i--;
    }
    return arr;
}
 
var arr = [8,1,5,6,3,9,2,7,4];
var arrSorted = bubbleSort(arr);
console.log(arrSorted);
alert(arrSorted);
控制台将输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]
并且弹窗;


### 冒泡排序算法的实现 冒泡排序是一种简单的排序算法,其核心思想是比较相邻的两个元素并根据大小关系进行交换。通过多次遍历待排序序列,最终使得较大的元素逐步向右移动到正确位置。 #### Python 实现 以下是基于 Python 的冒泡排序实现: ```python def bubble_sort(arr): n = len(arr) for i in range(n - 1): # 控制外层循环次数 swapped = False # 标记是否发生了交换 for j in range(0, n - i - 1): # 遍历未排序部分 if arr[j] > arr[j + 1]: # 如果前一个元素大于后一个元素 arr[j], arr[j + 1] = arr[j + 1], arr[j] # 进行交换 swapped = True if not swapped: # 若本轮无任何交换,则提前退出 break # 测试代码 if __name__ == "__main__": data = [64, 34, 25, 12, 22, 11, 90] print("原始数组:", data) bubble_sort(data) print("排序后的数组:", data) ``` 此代码实现了基本的冒泡排序逻辑,并加入了优化机制:当某一轮遍历时没有发生任何交换操作时,可以认为数据已完全有序,从而提前终止程序运行[^1]。 #### C语言实现 对于 C 语言而言,可以通过嵌套 `for` 循环完成相同功能。下面是一个标准版本的 C 实现方式: ```c #include <stdio.h> // 定义冒泡排序函数 void bubbleSort(int array[], int size) { for (int step = 0; step < size - 1; ++step) { bool swapped = false; for (int i = 0; i < size - step - 1; ++i) { if (array[i] > array[i + 1]) { // 比较相邻两数 int temp = array[i]; array[i] = array[i + 1]; array[i + 1] = temp; // 交换较大值至右侧 swapped = true; } } if (!swapped) // 提前结束条件判断 break; } } // 打印数组辅助函数 void printArray(const int* array, int size) { for (int i = 0; i < size; ++i) { printf("%d ", array[i]); } printf("\n"); } // 主函数调用示例 int main() { int data[] = {64, 34, 25, 12, 22, 11, 90}; int length = sizeof(data) / sizeof(data[0]); printf("原始数组:\n"); printArray(data, length); bubbleSort(data, length); printf("排序后的数组:\n"); printArray(data, length); return 0; } ``` 这段代码同样具备早期停止特性,在检测不到新交换的情况下能够减少不必要的迭代次数[^2]。 #### Java 实现 Java 中也可以采用类似的思路来编写冒泡排序算法如下所示: ```java public class BubbleSortExample { public static void bubbleSort(int[] arr){ int n = arr.length; boolean swapped; for (int i=0;i<n-1;i++){ swapped=false; for (int j=0;j<n-i-1;j++) { if (arr[j]>arr[j+1]){ // swap elements at index 'j' and 'j+1' int tmp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=tmp; swapped=true; } } // If no two elements were swapped by inner loop then we can exit early. if(!swapped){ break ; } } } private static void displayArray(int []a){ for(int e:a){ System.out.print(e+" "); } System.out.println(); } public static void main(String[]args){ int nums[]={7,4,5,1,3}; System.out.print("Before Sorting:"); displayArray(nums); bubbleSort(nums); System.out.print("After Sorting:"); displayArray(nums); } } ``` 该段代码展示了如何利用布尔变量监控每一次内部循环中的变化情况以便及时中断多余的计算过程[^3]. --- ### 性能分析 冒泡排序的时间复杂度通常被定义为 O(n²),其中最坏情况下(逆序排列)需执行约 \( \frac{n*(n-1)}{2} \) 次比较与可能接近数量级的数据搬移动作;而最佳情形下(正序输入),只需做一次线性的扫描即可确认无需调整顺序[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值