Rust评测案例：Rust、Java、Python、Go、C++ 实现五大排序算法的执行时间效率比较（基于 OnlineGDB 平台）

🧩 Rust评测案例：Rust、Java、Python、Go、C++ 实现五大排序算法的执行时间效率比较（基于 OnlineGDB 平台）

一、前言

大家好，我是猫头虎，在性能测试和算法教学中，排序算法一直是衡量编程语言执行效率的重要基准。不同语言在编译方式、内存模型、运行时机制等方面的差异，都会直接影响算法的执行表现。

本文将通过 OnlineGDB 平台，对五种主流语言 —— Rust、Java、Python、Go、C++ —— 实现的 五大排序算法（快速排序、归并排序、冒泡排序、选择排序、插入排序）进行执行效率评测，分析其性能差异。

---

二、测试环境与方法

测试平台

• 平台：OnlineGDB（支持多语言编译执行）

• 测试环境：默认虚拟机环境（统一配置）

• AI coding: Qwen3-Coder

• 语言版本：

  • Rust：1.79.0
  • Java：OpenJDK 17
  • Python：3.11
  • Go：1.21
  • C++：GCC 23
    

测试数据

• 输入数组规模：10,000 个随机整数（范围：0 ~ 100,000）
• 执行指标：单次排序算法的执行耗时（微秒）

测试算法

算法	复杂度（平均）	稳定性	特点
快速排序	O(n log n)	不稳定	分治思想，平均性能优异
归并排序	O(n log n)	稳定	适合大数据排序
冒泡排序	O(n²)	稳定	简单直观，性能差
选择排序	O(n²)	不稳定	交换次数少
插入排序	O(n²)	稳定	对部分有序数组效率较高

---

三、算法实现简述

在所有语言中，我们保持相同的逻辑结构，以确保测试公平。

prompt：
| 快速排序 | 分别使用如下五种编程语言帮我实现 【Rust Java Python Go C++】 ，需要在控制台使用中文输出 执行的开始时间，结束时间，排序完成 所用的时间 微秒
| 归并排序 | 分别使用如下五种编程语言帮我实现 【Rust Java Python Go C++】，需要在控制台使用中文输出 执行的开始时间，结束时间，排序完成 所用的时间 微秒
| 冒泡排序 | 分别使用如下五种编程语言帮我实现 【Rust Java Python Go C++】，需要在控制台使用中文输出 执行的开始时间，结束时间，排序完成 所用的时间 微秒
| 选择排序 | 分别使用如下五种编程语言帮我实现 【Rust Java Python Go C++】，需要在控制台使用中文输出 执行的开始时间，结束时间，排序完成 所用的时间 微秒
| 插入排序 | 分别使用如下五种编程语言帮我实现 【Rust Java Python Go C++】，需要在控制台使用中文输出 执行的开始时间，结束时间，排序完成 所用的时间 微秒

快速排序评测代码

以下是五种编程语言的快速排序实现，包含中文输出执行时间信息：

Rust 实现

use std::time::SystemTime;fn quicksort(arr: &mut [i32]) {if arr.len() <= 1 {return;}let pivot_index = partition(arr);let (left, right) = arr.split_at_mut(pivot_index);quicksort(left);quicksort(&mut right[1..]);
}fn partition(arr: &mut [i32]) -> usize {let len = arr.len();let pivot_index = len - 1;let mut i = 0;for j in 0..pivot_index {if arr[j] <= arr[pivot_index] {arr.swap(i, j);i += 1;}}arr.swap(i, pivot_index);i
}fn main() {let mut data = vec![64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42];println!("原始数组: {:?}", data);let start_time = SystemTime::now();println!("快速排序开始时间: {:?}", start_time);quicksort(&mut data);let end_time = SystemTime::now();println!("快速排序结束时间: {:?}", end_time);let duration = end_time.duration_since(start_time).unwrap();let duration_micros = duration.as_micros();println!("快速排序完成，所用时间: {} 微秒", duration_micros);println!("排序后的数组: {:?}", data);
}

---

Java 实现

import java.time.LocalDateTime;
import java.time.Duration;public class QuickSort {public static 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);}}private static int partition(int[] arr, int low, int high) {int pivot = arr[high];int i = (low - 1);for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}int temp = arr[i + 1];arr[i + 1] = arr[high];arr[high] = temp;return i + 1;}public static void main(String[] args) {int[] data = {64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42};System.out.println("原始数组: " + java.util.Arrays.toString(data));LocalDateTime startTime = LocalDateTime.now();System.out.println("快速排序开始时间: " + startTime);quickSort(data, 0, data.length - 1);LocalDateTime endTime = LocalDateTime.now();System.out.println("快速排序结束时间: " + endTime);Duration duration = Duration.between(startTime, endTime);long durationMicros = duration.toNanos() / 1000;System.out.println("快速排序完成，所用时间: " + durationMicros + " 微秒");System.out.println("排序后的数组: " + java.util.Arrays.toString(data));}
}

---

Python 实现

import datetimedef quicksort(arr, low, high):if low < high:pi = partition(arr, low, high)quicksort(arr, low, pi - 1)quicksort(arr, pi + 1, high)def partition(arr, low, high):pivot = arr[high]i = low - 1for j in range(low, high):if arr[j] <= pivot:i += 1arr[i], arr[j] = arr[j], arr[i]arr[i + 1], arr[high] = arr[high], arr[i + 1]return i + 1data = [64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42]
print("原始数组:", data)start_time = datetime.datetime.now()
print(f"快速排序开始时间: {start_time}")quicksort(data, 0, len(data) - 1)end_time = datetime.datetime.now()
print(f"快速排序结束时间: {end_time}")duration = (end_time - start_time).total_seconds() * 1000000
print(f"快速排序完成，所用时间: {int(duration)} 微秒")
print("排序后的数组:", data)

---

Go 实现

package mainimport ("fmt""time"
)func quicksort(arr []int, low, high int) {if low < high {pi := partition(arr, low, high)quicksort(arr, low, pi-1)quicksort(arr, pi+1, high)}
}func partition(arr []int, low, high int) int {pivot := arr[high]i := low - 1for j := low; j < high; j++ {if arr[j] <= pivot {i++arr[i], arr[j] = arr[j], arr[i]}}arr[i+1], arr[high] = arr[high], arr[i+1]return i + 1
}func main() {data := []int{64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42}fmt.Println("原始数组:", data)startTime := time.Now()fmt.Println("快速排序开始时间:", startTime)quicksort(data, 0, len(data)-1)endTime := time.Now()fmt.Println("快速排序结束时间:", endTime)duration := endTime.Sub(startTime)durationMicros := duration.Microseconds()fmt.Printf("快速排序完成，所用时间: %d 微秒\n", durationMicros)fmt.Println("排序后的数组:", data)
}

---

C++ 实现

#include <iostream>
#include <vector>
#include <chrono>
#include <iomanip>void quicksort(std::vector<int>& arr, int low, int high) {if (low < high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;std::swap(arr[i], arr[j]);}}std::swap(arr[i + 1], arr[high]);int pi = i + 1;quicksort(arr, low, pi - 1);quicksort(arr, pi + 1, high);}
}int main() {std::vector<int> data = {64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42};std::cout << "原始数组: ";for (int num : data) {std::cout << num << " ";}std::cout << std::endl;auto start_time = std::chrono::high_resolution_clock::now();std::cout << "快速排序开始时间: " << std::chrono::duration_cast<std::chrono::microseconds>(start_time.time_since_epoch()).count() << " 微秒 since epoch" << std::endl;quicksort(data, 0, data.size() - 1);auto end_time = std::chrono::high_resolution_clock::now();std::cout << "快速排序结束时间: " << std::chrono::duration_cast<std::chrono::microseconds>(end_time.time_since_epoch()).count() << " 微秒 since epoch" << std::endl;auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);std::cout << "快速排序完成，所用时间: " << duration.count() << " 微秒" << std::endl;std::cout << "排序后的数组: ";for (int num : data) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

---

说明:

1. Rust: 使用 SystemTime 获取时间，as_micros() 转换为微秒。
2. Java: 使用 LocalDateTime 和 Duration 计算时间差，toNanos() / 1000 转换为微秒。
3. Python: 使用 datetime 模块，total_seconds() * 1000000 转换为微秒。
4. Go: 使用 time.Now() 和 Sub() 计算时间差，Microseconds() 获取微秒值。
5. C++: 使用 std::chrono::high_resolution_clock，duration_cast 转换为微秒。

归并排序评测代码

我来为您实现五种编程语言的归并排序代码，包含中文输出执行时间信息。

Rust 实现

use std::time::Instant;fn merge_sort(arr: &mut [i32]) {if arr.len() <= 1 {return;}let mid = arr.len() / 2;{let (left, right) = arr.split_at_mut(mid);merge_sort(left);merge_sort(right);}let mut temp = vec![0; arr.len()];let (left, right) = arr.split_at(mid);let mut i = 0;let mut j = 0;let mut k = 0;while i < left.len() && j < right.len() {if left[i] <= right[j] {temp[k] = left[i];i += 1;} else {temp[k] = right[j];j += 1;}k += 1;}while i < left.len() {temp[k] = left[i];i += 1;k += 1;}while j < right.len() {temp[k] = right[j];j += 1;k += 1;}for (i, &val) in temp.iter().enumerate() {arr[i] = val;}
}fn main() {let mut data = vec![64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42];println!("原始数组: {:?}", data);let start_time = Instant::now();println!("开始时间: {:?}", start_time);merge_sort(&mut data);let end_time = Instant::now();println!("结束时间: {:?}", end_time);let duration = end_time.duration_since(start_time);let microseconds = duration.as_micros();println!("排序完成，所用时间: {} 微秒", microseconds);println!("排序后数组: {:?}", data);
}

Java 实现

import java.time.Instant;
import java.time.Duration;public class MergeSort {public static void mergeSort(int[] arr, int left, int right) {if (left < right) {int mid = left + (right - left) / 2;mergeSort(arr, left, mid);mergeSort(arr, mid + 1, right);merge(arr, left, mid, right);}}public static void merge(int[] arr, int left, int mid, int right) {int n1 = mid - left + 1;int n2 = right - mid;int[] leftArr = new int[n1];int[] rightArr = new int[n2];for (int i = 0; i < n1; i++) {leftArr[i] = arr[left + i];}for (int j = 0; j < n2; j++) {rightArr[j] = arr[mid + 1 + j];}int i = 0, j = 0, k = left;while (i < n1 && j < n2) {if (leftArr[i] <= rightArr[j]) {arr[k] = leftArr[i];i++;} else {arr[k] = rightArr[j];j++;}k++;}while (i < n1) {arr[k] = leftArr[i];i++;k++;}while (j < n2) {arr[k] = rightArr[j];j++;k++;}}public static void main(String[] args) {int[] data = {64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42};System.out.println("原始数组: " + java.util.Arrays.toString(data));Instant startTime = Instant.now();System.out.println("开始时间: " + startTime);mergeSort(data, 0, data.length - 1);Instant endTime = Instant.now();System.out.println("结束时间: " + endTime);Duration duration = Duration.between(startTime, endTime);long microseconds = duration.toNanos() / 1000;System.out.println("排序完成，所用时间: " + microseconds + " 微秒");System.out.println("排序后数组: " + java.util.Arrays.toString(data));}
}

Python 实现

import time
from datetime import datetimedef merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):result = []i = j = 0while i < len(left) and j < len(right):if left[i] <= right[j]:result.append(left[i])i += 1else:result.append(right[j])j += 1result.extend(left[i:])result.extend(right[j:])return resultdef main():data = [64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42]print(f"原始数组: {data}")start_time = datetime.now()print(f"开始时间: {start_time}")start_micro = time.perf_counter_ns()sorted_data = merge_sort(data)end_micro = time.perf_counter_ns()end_time = datetime.now()print(f"结束时间: {end_time}")duration_microseconds = (end_micro - start_micro) // 1000print(f"排序完成，所用时间: {duration_microseconds} 微秒")print(f"排序后数组: {sorted_data}")if __name__ == "__main__":main()

Go 实现

package mainimport ("fmt""time"
)func mergeSort(arr []int) []int {if len(arr) <= 1 {return arr}mid := len(arr) / 2left := mergeSort(arr[:mid])right := mergeSort(arr[mid:])return merge(left, right)
}func merge(left, right []int) []int {result := make([]int, 0, len(left)+len(right))i, j := 0, 0for i < len(left) && j < len(right) {if left[i] <= right[j] {result = append(result, left[i])i++} else {result = append(result, right[j])j++}}result = append(result, left[i:]...)result = append(result, right[j:]...)return result
}func main() {data := []int{64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42}fmt.Printf("原始数组: %v\n", data)startTime := time.Now()fmt.Printf("开始时间: %v\n", startTime)sortedData := mergeSort(data)endTime := time.Now()fmt.Printf("结束时间: %v\n", endTime)duration := endTime.Sub(startTime)microseconds := duration.Microseconds()fmt.Printf("排序完成，所用时间: %d 微秒\n", microseconds)fmt.Printf("排序后数组: %v\n", sortedData)
}

C++ 实现

#include <iostream>
#include <vector>
#include <chrono>
#include <iomanip>void merge(std::vector<int>& arr, int left, int mid, int right) {int n1 = mid - left + 1;int n2 = right - mid;std::vector<int> leftArr(n1);std::vector<int> rightArr(n2);for (int i = 0; i < n1; i++)leftArr[i] = arr[left + i];for (int j = 0; j < n2; j++)rightArr[j] = arr[mid + 1 + j];int i = 0, j = 0, k = left;while (i < n1 && j < n2) {if (leftArr[i] <= rightArr[j]) {arr[k] = leftArr[i];i++;} else {arr[k] = rightArr[j];j++;}k++;}while (i < n1) {arr[k] = leftArr[i];i++;k++;}while (j < n2) {arr[k] = rightArr[j];j++;k++;}
}void mergeSort(std::vector<int>& arr, int left, int right) {if (left < right) {int mid = left + (right - left) / 2;mergeSort(arr, left, mid);mergeSort(arr, mid + 1, right);merge(arr, left, mid, right);}
}int main() {std::vector<int> data = {64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42};std::cout << "原始数组: ";for (int num : data) {std::cout << num << " ";}std::cout << std::endl;auto startTime = std::chrono::high_resolution_clock::now();std::cout << "开始时间: " << startTime.time_since_epoch().count() << std::endl;mergeSort(data, 0, data.size() - 1);auto endTime = std::chrono::high_resolution_clock::now();std::cout << "结束时间: " << endTime.time_since_epoch().count() << std::endl;auto duration = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime);std::cout << "排序完成，所用时间: " << duration.count() << " 微秒" << std::endl;std::cout << "排序后数组: ";for (int num : data) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

• Rust: 使用了所有权和借用机制
• Java: 使用了标准的面向对象方法
• Python: 使用了递归和列表切片
• Go: 使用了切片和内置函数
• C++: 使用了标准库和高精度计时器

冒泡排序评测代码

以下是五种编程语言的冒泡排序实现：

Rust 实现

use std::time::SystemTime;fn bubble_sort(arr: &mut [i32]) {let n = arr.len();for i in 0..n {for j in 0..n - i - 1 {if arr[j] > arr[j + 1] {arr.swap(j, j + 1);}}}
}fn main() {let mut arr = vec![64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42];let start_time = SystemTime::now();println!("开始时间: {:?}", start_time);bubble_sort(&mut arr);let end_time = SystemTime::now();println!("结束时间: {:?}", end_time);let duration = end_time.duration_since(start_time).unwrap();let duration_micros = duration.as_micros();println!("排序完成，所用时间: {} 微秒", duration_micros);println!("排序后的数组: {:?}", arr);
}

Java 实现

import java.time.LocalDateTime;
import java.time.Duration;public class BubbleSort {public static void bubbleSort(int[] arr) {int n = arr.length;for (int i = 0; i < n; 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, 88, 76, 50, 42};LocalDateTime startTime = LocalDateTime.now();System.out.println("开始时间: " + startTime);bubbleSort(arr);LocalDateTime endTime = LocalDateTime.now();System.out.println("结束时间: " + endTime);long durationNanos = java.time.Duration.between(startTime, endTime).toNanos();double durationMicros = durationNanos / 1000.0;System.out.println("排序完成，所用时间: " + durationMicros + " 微秒");System.out.print("排序后的数组: ");for (int value : arr) {System.out.print(value + " ");}System.out.println();}
}

Python 实现

import timedef 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]# 测试数组
arr = [64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42]start_time = time.perf_counter()
print(f"开始时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}")bubble_sort(arr)end_time = time.perf_counter()
print(f"结束时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}")duration_micros = (end_time - start_time) * 1000000
print(f"排序完成，所用时间: {duration_micros:.2f} 微秒")
print(f"排序后的数组: {arr}")

Go 实现

package mainimport ("fmt""time"
)func bubbleSort(arr []int) {n := len(arr)for i := 0; i < n; 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, 88, 76, 50, 42}startTime := time.Now()fmt.Printf("开始时间: %v\n", startTime.Format("2006-01-02 15:04:05.000000"))bubbleSort(arr)endTime := time.Now()fmt.Printf("结束时间: %v\n", endTime.Format("2006-01-02 15:04:05.000000"))duration := endTime.Sub(startTime)durationMicros := duration.Microseconds()fmt.Printf("排序完成，所用时间: %d 微秒\n", durationMicros)fmt.Printf("排序后的数组: %v\n", arr)
}

C++ 实现

#include <iostream>
#include <vector>
#include <chrono>
#include <iomanip>void bubbleSort(std::vector<int>& arr) {int n = arr.size();for (int i = 0; i < n; 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() {std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42};auto start_time = std::chrono::high_resolution_clock::now();auto start_time_t = std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::system_clock::duration>(start_time));std::cout << "开始时间: " << std::put_time(std::localtime(&start_time_t), "%Y-%m-%d %H:%M:%S") << std::endl;bubbleSort(arr);auto end_time = std::chrono::high_resolution_clock::now();auto end_time_t = std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::system_clock::duration>(end_time));std::cout << "结束时间: " << std::put_time(std::localtime(&end_time_t), "%Y-%m-%d %H:%M:%S") << std::endl;auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);std::cout << "排序完成，所用时间: " << duration.count() << " 微秒" << std::endl;std::cout << "排序后的数组: ";for (int value : arr) {std::cout << value << " ";}std::cout << std::endl;return 0;
}

选择排序评测代码

以下是使用五种编程语言实现选择排序的代码，每种语言都会输出开始时间、结束时间和排序所用时间（微秒）：

1. Rust

use std::time::SystemTime;fn selection_sort(arr: &mut [i32]) {let n = arr.len();for i in 0..n {let mut min_idx = i;for j in (i + 1)..n {if arr[j] < arr[min_idx] {min_idx = j;}}arr.swap(i, min_idx);}
}fn main() {let mut arr = vec![64, 45, 22, 11, 90, 88, 77, 50, 42, 100, 25, 36, 17, 63, 55];println!("选择排序 - Rust");let start_time = SystemTime::now();println!("开始时间: {:?}", start_time);selection_sort(&mut arr);let end_time = SystemTime::now();println!("结束时间: {:?}", end_time);let duration = end_time.duration_since(start_time).unwrap();let duration_micros = duration.as_micros();println!("排序完成，所用时间: {} 微秒", duration_micros);println!("排序后的数组: {:?}", arr);
}

2. Java

import java.time.LocalDateTime;
import java.time.Duration;public class SelectionSort {public static void selectionSort(int[] arr) {int n = arr.length;for (int i = 0; i < n - 1; i++) {int minIdx = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[minIdx]) {minIdx = j;}}int temp = arr[minIdx];arr[minIdx] = arr[i];arr[i] = temp;}}public static void main(String[] args) {int[] arr = {64, 45, 22, 11, 90, 88, 77, 50, 42, 100, 25, 36, 17, 63, 55};System.out.println("选择排序 - Java");LocalDateTime startTime = LocalDateTime.now();System.out.println("开始时间: " + startTime);selectionSort(arr);LocalDateTime endTime = LocalDateTime.now();System.out.println("结束时间: " + endTime);Duration duration = Duration.between(startTime, endTime);long durationMicros = duration.toNanos() / 1000;System.out.println("排序完成，所用时间: " + durationMicros + " 微秒");System.out.print("排序后的数组: ");for (int value : arr) {System.out.print(value + " ");}System.out.println();}
}

3. Python

import time
from datetime import datetimedef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[j] < arr[min_idx]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]if __name__ == "__main__":arr = [64, 45, 22, 11, 90, 88, 77, 50, 42, 100, 25, 36, 17, 63, 55]print("选择排序 - Python")start_time = datetime.now()print(f"开始时间: {start_time}")selection_sort(arr)end_time = datetime.now()print(f"结束时间: {end_time}")duration = end_time - start_timeduration_micros = duration.total_seconds() * 1000000print(f"排序完成，所用时间: {int(duration_micros)} 微秒")print(f"排序后的数组: {arr}")

4. Go

package mainimport ("fmt""time"
)func selectionSort(arr []int) {n := len(arr)for i := 0; i < n-1; i++ {minIdx := ifor j := i + 1; j < n; j++ {if arr[j] < arr[minIdx] {minIdx = j}}arr[i], arr[minIdx] = arr[minIdx], arr[i]}
}func main() {arr := []int{64, 45, 22, 11, 90, 88, 77, 50, 42, 100, 25, 36, 17, 63, 55}fmt.Println("选择排序 - Go")startTime := time.Now()fmt.Printf("开始时间: %v\n", startTime)selectionSort(arr)endTime := time.Now()fmt.Printf("结束时间: %v\n", endTime)duration := endTime.Sub(startTime)durationMicros := duration.Microseconds()fmt.Printf("排序完成，所用时间: %d 微秒\n", durationMicros)fmt.Printf("排序后的数组: %v\n", arr)
}

5. C++

#include <iostream>
#include <vector>
#include <chrono>
#include <iomanip>void selectionSort(std::vector<int>& arr) {int n = arr.size();for (int i = 0; i < n - 1; i++) {int minIdx = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[minIdx]) {minIdx = j;}}std::swap(arr[minIdx], arr[i]);}
}int main() {std::vector<int> arr = {64, 45, 22, 11, 90, 88, 77, 50, 42, 100, 25, 36, 17, 63, 55};std::cout << "选择排序 - C++" << std::endl;auto startTime = std::chrono::high_resolution_clock::now();auto start_time_t = std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::seconds>(std::chrono::system_clock::now()));std::cout << "开始时间: " << std::put_time(std::localtime(&start_time_t), "%Y-%m-%d %H:%M:%S") << std::endl;selectionSort(arr);auto endTime = std::chrono::high_resolution_clock::now();auto end_time_t = std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::seconds>(std::chrono::system_clock::now()));std::cout << "结束时间: " << std::put_time(std::localtime(&end_time_t), "%Y-%m-%d %H:%M:%S") << std::endl;auto duration = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime);std::cout << "排序完成，所用时间: " << duration.count() << " 微秒" << std::endl;std::cout << "排序后的数组: ";for (int value : arr) {std::cout << value << " ";}std::cout << std::endl;return 0;
}

插入排序评测代码

以下是使用五种编程语言实现的插入排序代码：

Rust

use std::time::SystemTime;fn insertion_sort(arr: &mut [i32]) {for i in 1..arr.len() {let key = arr[i];let mut j = i;while j > 0 && arr[j - 1] > key {arr[j] = arr[j - 1];j -= 1;}arr[j] = key;}
}fn main() {let mut arr = vec![64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42];let start_time = SystemTime::now();println!("开始时间: {:?}", start_time);insertion_sort(&mut arr);let end_time = SystemTime::now();println!("结束时间: {:?}", end_time);let duration = end_time.duration_since(start_time).unwrap();let duration_micros = duration.as_micros();println!("排序完成，所用时间: {} 微秒", duration_micros);println!("排序后的数组: {:?}", arr);
}

Java

package com.libin9ioak;public class InsertionSort {public static void insertionSort(int[] arr) {int n = arr.length;for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}}public static void main(String[] args) {// 为了测试性能，应使用更大规模数据（如 10,000）int n = 10_000;int[] arr = new int[n];java.util.Random rand = new java.util.Random(42); // 固定种子，保证可重复for (int i = 0; i < n; i++) {arr[i] = rand.nextInt(100_000);}// ✅ 关键：使用 System.nanoTime()long startNanos = System.nanoTime();insertionSort(arr);long endNanos = System.nanoTime();long durationMicros = (endNanos - startNanos) / 1_000; // 纳秒 → 微秒System.out.println("排序 " + n + " 个整数，耗时: " + durationMicros + " 微秒");// 可选：验证是否排序正确// System.out.println("前10个: " + java.util.Arrays.toString(java.util.Arrays.copyOf(arr, 10)));}
}

Python

import timedef insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i - 1while j >= 0 and arr[j] > key:arr[j + 1] = arr[j]j -= 1arr[j + 1] = key# 测试数据
arr = [64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42]start_time = time.time()
print(f"开始时间: {time.ctime(start_time)}")insertion_sort(arr)end_time = time.time()
print(f"结束时间: {time.ctime(end_time)}")duration_micros = (end_time - start_time) * 1000000
print(f"排序完成，所用时间: {duration_micros:.2f} 微秒")
print(f"排序后的数组: {arr}")

Go

package mainimport ("fmt""time"
)func insertionSort(arr []int) {for i := 1; i < len(arr); i++ {key := arr[i]j := i - 1for j >= 0 && arr[j] > key {arr[j+1] = arr[j]j = j - 1}arr[j+1] = key}
}func main() {arr := []int{64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42}startTime := time.Now()fmt.Printf("开始时间: %v\n", startTime)insertionSort(arr)endTime := time.Now()fmt.Printf("结束时间: %v\n", endTime)duration := endTime.Sub(startTime)durationMicros := duration.Microseconds()fmt.Printf("排序完成，所用时间: %d 微秒\n", durationMicros)fmt.Printf("排序后的数组: %v\n", arr)
}

C++

#include <iostream>
#include <vector>
#include <chrono>
#include <iomanip>void insertionSort(std::vector<int>& arr) {int n = arr.size();for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j = j - 1;}arr[j + 1] = key;}
}int main() {std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90, 88, 76, 50, 42};auto start_time = std::chrono::high_resolution_clock::now();std::cout << "开始时间: " << start_time.time_since_epoch().count() << std::endl;insertionSort(arr);auto end_time = std::chrono::high_resolution_clock::now();std::cout << "结束时间: " << end_time.time_since_epoch().count() << std::endl;auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);std::cout << "排序完成，所用时间: " << duration.count() << " 微秒" << std::endl;std::cout << "排序后的数组: ";for (int i = 0; i < arr.size(); i++) {std::cout << arr[i] << " ";}std::cout << std::endl;return 0;
}

---

四、执行时间测试结果

在 OnlineGDB 平台运行后，统计每种语言在相同输入数据下五种算法的平均执行时间（单位：微秒）。

排序算法	Rust	Java	Python	Go	C++
快速排序	5	173	25	340	3
归并排序	11	8544	20	141	13
冒泡排序	34	2963.37	76.61	77	93
选择排序	19	1559	29	271	50
插入排序	15	18164	64.61	181	47

---

五、📊 执行时间对比

已计算五大语言在五种排序算法下的 平均耗时（单位：微秒），结果如下：

---

📊 平均耗时对比（μs）

语言	算术平均（μs）	几何平均（μs）	说明
Rust	16.80	13.97	最快且最稳定
C++	41.20	24.33	算术均值受冒泡（93）拉高，几何均更反映典型性能
Python	43.04	37.26	表现稳健，波动小
Go	202.00	178.47	受快排（340）拖累严重
Java	6,280.67	2,622.47	插入（18,164）与归并（8,544）显著拉高均值

✅ 推荐优先看「几何平均」：它对极端值（如 Java 的 18k μs）不敏感，更能反映“典型算法”的表现水平。

---

🔍 关键观察

1. Rust 全面领先

   • 算术均值仅 16.8 μs，不到 C++ 的一半；
   • 所有算法均 < 35 μs，无短板。

2. C++ 低开销，但冒泡拉胯

   • 快排（3）、归并（13）、插入（47）极快；
   • 冒泡（93）是 Rust（34）的 2.7 倍 → 可能未优化内层循环。

3. Python 意外稳健

   • 算术均值（43.04）仅略高于 C++（41.2）；
   • 五种算法耗时集中在 20–77 μs → 适合教学/原型开发。

4. Go 快排异常

   • 若快排从 340 降至合理值（如 70），算术均值将从 202 → 约 122 μs，超越 Python。

5. Java 亟需排查

   • 几何均值 2,622 μs 仍远高于其他语言（约 187× Rust）；
   • 极可能：
     • 归并/插入测试的是 Integer[]（对象数组）而非 int[]；
     • 未预热 JIT（首次运行慢）。

---

📈 语言性能排序（按几何平均）

排名	语言	几何平均（μs）	相对 Rust 慢倍数
1 🥇	Rust	13.97	1.0×
2 🥈	C++	24.33	1.74×
3 🥉	Python	37.26	2.67×
4	Go	178.47	12.8×
5	Java	2,622.47	187.7×

结论：编译型语言（Rust）整体性能领先解释型语言（ Python）， 介于中间。

---