用12种主流编程语言实现冒泡排序算法（附源码）

本文用top的一些编程语言实现了最基本的算法 - 冒泡排序，依次出场的语言：C、C++、python、js、java、go、rust、swift、kotlin、ruby、R、Scala。代码逻辑比较简单，主要是对比学习下不同语言的语法和风格，也算一件比较有意思的事情。

C语言

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubbleSort(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

特点：C语言是一种通用的过程式编程语言，以高效性和可移植性著称。它提供了对内存的直接操作能力，适合系统级编程。C语言广泛应用于操作系统、嵌入式系统以及高性能应用开发。由于其简洁的语法和强大的功能，C语言成为许多现代编程语言的基础。

2. C++

#include <iostream>
using namespace std;

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr[j], arr[j+1]);
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubbleSort(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

特点：C++是C语言的扩展，支持面向对象的编程，适合开发复杂的应用程序。它结合了低级语言的性能和高级语言的抽象能力，广泛用于游戏开发、图形处理和高性能计算。C++的标准模板库（STL）提供了丰富的数据结构和算法，极大提高了开发效率。

3. Python

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# 示例
print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))

特点：Python是一种高级编程语言，以其简洁的语法和强大的库而闻名。它支持多种编程范式，包括面向对象、过程式和函数式编程。Python广泛应用于数据科学、机器学习、Web开发和自动化脚本。其活跃的社区和丰富的第三方库使得开发者能够快速构建和原型化应用。

4. JavaScript

function bubbleSort(arr) {
    let n = arr.length;
    for (let i = 0; i < n-1; i++) {
        for (let j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
            }
        }
    }
    return arr;
}

// 示例
console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90]));

特点：JavaScript是一种动态类型的脚本语言，主要用于Web开发。它支持事件驱动和异步编程，能够在客户端和服务器端运行。随着Node.js的出现，JavaScript的应用范围扩展到了后端开发。其广泛的库和框架（如React、Angular、Vue）使得构建复杂的用户界面变得更加容易。

5. Java

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-i-1; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

特点：Java是一种面向对象的编程语言，具有跨平台性，广泛应用于企业级应用和Android开发。Java的“写一次，处处运行”理念使得它在不同平台上具有良好的兼容性。Java的强类型系统和丰富的库支持使得开发复杂应用变得更加高效。

6. Go

package main

import "fmt"

func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

func main() {
    arr := []int{64, 34, 25, 12, 22, 11, 90}
    bubbleSort(arr)
    fmt.Println(arr)
}

特点：Go是一种静态类型、编译型语言，由Google开发，强调简洁性和高效性。它具有内置的并发支持，通过goroutines和channels实现高效的并发编程。Go的垃圾回收机制和强大的标准库使得开发网络服务和云应用变得更加简单和高效。

7. Rust

fn bubble_sort(arr: &mut [i32]) {
    let n = arr.len();
    for i in 0..n-1 {
        for j in 0..n-i-1 {
            if arr[j] > arr[j+1] {
                arr.swap(j, j+1);
            }
        }
    }
}

fn main() {
    let mut arr = [64, 34, 25, 12, 22, 11, 90];
    bubble_sort(&mut arr);
    println!("{:?}", arr);
}

特点：Rust是一种系统编程语言，强调安全性和性能，特别适合于并发和内存管理。Rust通过所有权系统避免了数据竞争和内存泄漏，提供了更高的安全性。其丰富的生态系统和Cargo包管理器使得开发高性能应用变得高效。

8. Swift

func bubbleSort(_ arr: inout [Int]) {
    let n = arr.count
    for i in 0..<n-1 {
        for j in 0..<n-i-1 {
            if arr[j] > arr[j+1] {
                arr.swapAt(j, j+1)
            }
        }
    }
}

// 示例
var arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(&arr)
print(arr)

特点：Swift是一种现代编程语言，主要用于iOS和macOS应用开发。它结合了安全性和性能，提供了类型安全和内存管理。Swift的语法简洁且易于阅读，支持函数式编程和面向对象编程。随着Swift的发展，越来越多的开发者选择它来替代Objective-C。

9. Kotlin

fun bubbleSort(arr: IntArray) {
    val n = arr.size
    for (i in 0 until n - 1) {
        for (j in 0 until n - i - 1) {
            if (arr[j] > arr[j + 1]) {
                val temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
}

// 示例
fun main() {
    val arr = intArrayOf(64, 34, 25, 12, 22, 11, 90)
    bubbleSort(arr)
    println(arr.joinToString(" "))
}

特点：Kotlin是一种现代编程语言，兼容Java，主要用于Android开发。它具有简洁的语法和强大的功能，支持空安全和扩展函数等特性。Kotlin的设计目标是提高开发效率，同时保持与Java的互操作性。其越来越受欢迎，成为Android开发的首选语言。

10. Ruby

def bubble_sort(arr)
    n = arr.length
    for i in 0...(n-1)
        for j in 0...(n-i-1)
            if arr[j] > arr[j+1]
                arr[j], arr[j+1] = arr[j+1], arr[j]
            end
        end
    end
    arr
end

# 示例
puts bubble_sort([64, 34, 25, 12, 22, 11, 90]).inspect

特点：Ruby是一种动态、面向对象的编程语言，以其优雅的语法和开发效率著称。Ruby强调开发者的幸福感，支持多种编程范式。Ruby on Rails框架使得Web开发变得高效和简单，吸引了大量开发者。其活跃的社区和丰富的库支持进一步促进了Ruby的普及。

11. R

bubble_sort <- function(arr) {
    n <- length(arr)
    for (i in 1:(n-1)) {
        for (j in 1:(n-i)) {
            if (arr[j] > arr[j+1]) {
                temp <- arr[j]
                arr[j] <- arr[j+1]
                arr[j+1] <- temp
            }
        }
    }
    return(arr)
}

# 示例
print(bubble_sort(c(64, 34, 25, 12, 22, 11, 90)))

特点：R是一种专门用于统计计算和数据分析的编程语言，具有强大的数据处理和可视化能力。它提供了丰富的统计模型和图形工具，广泛应用于数据科学和学术研究。R的包生态系统非常活跃，用户可以轻松获取和使用各种数据分析工具。

12. Scala

object BubbleSort {
    def bubbleSort(arr: Array[Int]): Array[Int] = {
        val n = arr.length
        for (i <- 0 until n - 1) {
            for (j <- 0 until n - i - 1) {
                if (arr(j) > arr(j + 1)) {
                    val temp = arr(j)
                    arr(j) = arr(j + 1)
                    arr(j + 1) = temp
                }
            }
        }
        arr
    }

    def main(args: Array[String]): Unit = {
        val arr = Array(64, 34, 25, 12, 22, 11, 90)
        println(bubbleSort(arr).mkString(" "))
    }
}

特点：Scala是一种融合了面向对象和函数式编程的语言，运行在Java虚拟机上。它与Java高度兼容，允许开发者利用Java的库和框架。Scala的类型推导和高阶函数使得代码更加简洁和表达力强，广泛应用于大数据处理和分布式系统开发。