7种数组排序算法（多语言描述）

已于 2024-03-20 00:38:37 修改
阅读量492 收藏 9
点赞数 8
分类专栏： 数据结构与算法 文章标签： 排序算法 算法 数据结构
于 2024-03-06 11:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DanielSYC/article/details/136419891
版权

912. 排序数组

冒泡排序

C++

void bubble_sort(vector<int>& nums) {
    bool sorted = false;
    int N = nums.size();
    while (!sorted) {
        sorted = true;
        for (int i = 1; i < N; i++) {
            if (nums[i - 1] > nums[i]) {
                swap(nums[i - 1], nums[i]);
                sorted = false;
            }
        }
        N--;
    }
}

Python

def bubble_sort(nums):
    N = len(nums)
    sorted = False
    while not sorted:
        sorted = True
        for i in range(1, N):
            if nums[i - 1] > nums[i]:
                nums[i - 1], nums[i] = nums[i], nums[i -1]
                sorted = False
        N -= 1

Golang

func bubbleSort(nums []int) {
    N := len(nums)
    sorted := false
    for !sorted {
        sorted = true
        for i := 1; i < N; i++ {
            if nums[i - 1] > nums[i] {
                sorted = false
                nums[i - 1], nums[i] = nums[i], nums[i - 1]
            }
        }
        N--
    }
}

Rust

fn bubble_sort(nums: &mut Vec<i32>) {
    let mut sorted = false;
    let mut N = nums.len();
    while !sorted {
        sorted = true;
        for i in 1..N {
            if nums[i - 1] > nums[i] {
                nums.swap(i - 1, i);
                sorted = false;
            }
        }
        N -= 1;
    }
}

插入排序

C++

void insertion_sort(vector<int>& nums) {
    int t = 0, i = 1, j = 0;
    for (i = 1; i < nums.size(); i++) {
        t = nums[i];
        for (j = i; j > 0 && nums[j - 1] > t; j--) {
            nums[j] = nums[j - 1];
        }
        nums[j] = t;
    }
}

Python

def insertion_sort(nums):
    for i in range(1, len(nums)):
        t = nums[i]
        j = i
        while j > 0 and nums[j - 1] > t:
            nums[j] = nums[j - 1]
            j -= 1
        nums[j] = t

Golang

func insertionSort(nums []int) {
    for i := 1; i < len(nums); i++ {
        t := nums[i]
        j := i
        for j > 0 && nums[j - 1] > t {
            nums[j] = nums[j - 1]
            j--
        }
        nums[j] = t
    }
}

Rust

fn insertion_sort(nums: &mut Vec<i32>) {
    for i in 1..nums.len() {
        let t = nums[i];
        let mut j = i;
        while j > 0 && nums[j - 1] > t {
            nums[j] = nums[j - 1];
            j -= 1;
        }
        nums[j] = t;
    }
}

希尔排序

希尔排序作为插入排序的一种改进，又被称为缩小增量排序，其每次进行增量为 d 的插入排序，d /= 2 向下递减到 1

C++

void shell_sort(vector<int>& nums) {
    int N = nums.size(), d = N >> 1, i = 0, j = 0, t = 0;
    for (; d > 0; d >>= 1) {
        for (i = d; i < N; i++) {
            t = nums[i];
            for (j = i; j >= d && nums[j - d] > t; j -= d) {
                nums[j] = nums[j - d];
            }
            nums[j] = t;
        }
    }
}

Python

def shell_sort(nums):
    N = len(nums)
    d = N >> 1
    while d > 0:
        for i in range(d, N):
            t = nums[i]
            j = i
            while j >= d and nums[j - d] > t:
                nums[j] = nums[j - d]
                j -= d
            nums[j] = t
        d >>= 1

Golang

func shellSort(nums []int) {
    N := len(nums)
    d := N >> 1
    for ; d > 0; d >>= 1 {
        for i := d; i < N; i++ {
            t := nums[i]
            j := i
            for ; j >= d && nums[j - d] > t; j -= d {
                nums[j] = nums[j - d]
            }
            nums[j] = t
        }
    }
}

Rust

fn shell_sort(nums: &mut Vec<i32>) {
    let N = nums.len();
    let mut d = N >> 1;
    while d > 0 {
        for i in d..N {
            let t = nums[i];
            let mut j = i;
            while j >= d && nums[j - d] > t {
                nums[j] = nums[j - d];
                j -= d;
            }
            nums[j] = t;
        }
        d >>= 1;
    }
}

选择排序

C++

int findMin(vector<int>& nums, int l, int r) {
    int min = nums[l], min_pos = l;
    for (int i = l; i <= r; i++ ) {
        if (nums[i] < min) {
            min = nums[i];
            min_pos = i;
        }
    }
    return min_pos;
}

void selectSort(vector<int>& nums) {
    int N = nums.size();
    for (int i = 0; i < N; i++) {
        int min_pos = findMin(nums, i, N - 1);
        swap(nums[i], nums[min_pos]);
    }
}

Python

def findMin(nums, l, r):
    m = nums[l]
    m_pos = l
    for i in range(l, r + 1):
        if nums[i] < m:
            m = nums[i]
            m_pos = i
    return m_pos


def selectSort(nums):
    N = len(nums)
    for i in range(0, N):
        min_pos = findMin(nums, i, N - 1)
        nums[i], nums[min_pos] = nums[min_pos], nums[i]

Golang

func findMin(nums []int, l int, r int) int {
    m := nums[l]
    mp := l
    for i := l; i <= r; i++ {
        if nums[i] < m {
            m = nums[i]
            mp = i
        }
    }
    return mp
}

func selectSort(nums []int) {
    N := len(nums)
    for i := 0; i < N; i++ {
        mp := findMin(nums, i, N - 1)
        nums[i], nums[mp] = nums[mp], nums[i]
    }
}

Rust

fn find_min(nums: &Vec<i32>, l: usize, r: usize) -> usize {
    let mut m = nums[l];
    let mut mp = l;     // min position
    for i in l..(r + 1) {
        if nums[i] < m {
            m = nums[i];
            mp = i;
        }
    }
    mp
}

fn select_sort(nums: &mut Vec<i32>) {
    let N = nums.len();
    for i in 0..N {
        let mp = find_min(nums, i, N - 1);
        nums.swap(i, mp);
    }
}

堆排序

C++

void percolate(vector<int>& nums, int i, int N) {
    int p = i;
    int top = nums[i];
    int c = 0;
    while (p * 2 + 1 < N) {
        c = p * 2 + 1;
        if (c < N - 1 && nums[c + 1] > nums[c]) {
            c++;
        }
        if (nums[c] <= top) {
            break;
        } else {
            nums[p] = nums[c];
        }
        p = c;
    }
    nums[p] = top;
}

void heap_sort(vector<int>& nums) {
    int N = nums.size();
    int i = 0;
    for (i = N / 2; i >= 0; i--) {
        percolate(nums, i, N);
    }

    for (i = N - 1; i > 0; i--) {
        swap(nums[i], nums[0]);
        percolate(nums, 0, i);
    }
}

Python

def percolate(nums, i, N):
    p = i
    top = nums[i]
    c = 0
    while p * 2 + 1 < N:
        c = p * 2 + 1
        if c + 1 < N and nums[c + 1] > nums[c]:
            c += 1
        if nums[c] <= top:
            break
        else:
            nums[p] = nums[c]
        p = c
    nums[p] = top


def heap_sort(nums):
    N = len(nums)
    for i in range(N >> 1, -1, -1):
        percolate(nums, i, N)
    for i in range(N - 1, 0, -1):
        nums[0], nums[i] = nums[i], nums[0]
        percolate(nums, 0, i)

Golang

func percolate(nums []int, i int, N int) {
    p := i
    top := nums[i]
    c := 0
    for p * 2 + 1 < N {
        c = p * 2 + 1
        if c + 1 < N && nums[c + 1]  > nums[c] {
            c++
        }
        if top >= nums[c] {
            break
        } else {
            nums[p] = nums[c]
        }
        p = c
    }
    nums[p] = top
}

func heapSort(nums []int) {
    N := len(nums)
    for i := N >> 1; i >= 0; i-- {
        percolate(nums, i, N)
    }
    for i := N - 1; i > 0; i-- {
        nums[0], nums[i] = nums[i], nums[0]
        percolate(nums, 0, i)
    }
}

Rust

fn percolate(nums: &mut Vec<i32>, i: usize, N: usize) {
    let mut p = i;
    let top = nums[i];
    let mut c = 0;
    while p * 2 + 1 < N {
        c = p * 2 + 1;
        if c + 1 < N && nums[c + 1] > nums[c] {
            c += 1;
        }
        if top >= nums[c] {
            break;
        } else {
            nums[p] = nums[c];
        }
        p = c
    }
    nums[p] = top;
}

fn heap_sort(nums: &mut Vec<i32>) {
    let N = nums.len();
    for i in (0 as usize..(N >> 1) + 1).rev() {
        percolate(nums, i, N);
    }
    for i in (0..N).rev() {
        nums.swap(0, i);
        percolate(nums, 0, i);
    }
}

归并排序

C++

void merge(vector<int>& nums, int low, int mid, int high) {
    auto it = nums.begin();
    vector<int> L(it + low, it + mid + 1);
    vector<int> R(it + mid + 1, it + high + 1);
    int i = 0, j = 0, k = low;
    while (i < L.size() && j < R.size()) {
        if (L[i] <= R[j]) {
            nums[k++] = L[i++];
        } else {
            nums[k++] = R[j++];
        }
    }
    while (i < L.size()) nums[k++] = L[i++];
    while (j < R.size()) nums[k++] = R[j++];
}

void mergesort(vector<int>& nums, int low, int high) {
    if (low < high) {
        int mid = (low + high) >> 1;
        mergesort(nums, low, mid);
        mergesort(nums, mid + 1, high);
        merge(nums, low, mid, high);
    }
}

Python

def merge(nums, l, mid, r):
    left = nums[l: mid + 1]
    right = nums[mid + 1: r + 1]
    i, j, k = 0, 0, l
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            nums[k] = left[i]
            i += 1
        else:
            nums[k] = right[j]
            j += 1
        k += 1
    while i < len(left):
        nums[k] = left[i]
        k += 1
        i += 1
    while j < len(right):
        nums[k] = right[j]
        k += 1
        j += 1

def merge_sort(nums, l, r):
    if l < r:
        mid = (l + r) >> 1
        merge_sort(nums, l, mid)
        merge_sort(nums, mid + 1, r)
        merge(nums, l, mid, r)

Golang

func merge(nums []int, low int, mid int, high int) {
    L := make([]int, mid - low + 1)
    R := make([]int, high - mid)
    copy(L, nums[low: mid + 1])
    copy(R, nums[mid + 1: high + 1])
    i, j, k := 0, 0, low
    for i < len(L) && j < len(R) {
        if L[i] <= R[j] {
            nums[k] = L[i]
            i++
        } else {
            nums[k] = R[j]
            j++
        }
        k++
    }
    for i < len(L) {
        nums[k] = L[i]
        k++
        i++
    }
    for j < len(R) {
        nums[k] = R[j]
        k++
        j++
    }
}

func mergesort(nums []int, low int, high int) {
    if low < high {
        mid := (low + high) >> 1
        mergesort(nums, low, mid)
        mergesort(nums, mid + 1, high)
        merge(nums, low, mid, high)
    }
}

Rust

fn merge(nums: &mut Vec<i32>, l: usize, mid: usize, r: usize) {
    let it = nums.iter();
    let L: Vec<i32> = it.clone().skip(l).take(mid - l + 1).map(|&x| x).collect();
    let R: Vec<i32> = it.clone().skip(mid + 1).take(r - mid).map(|&x| x).collect();

    let mut i = 0;
    let mut j = 0;
    let mut k = l;
    while i < L.len() && j < R.len() {
        if L[i] <= R[j] {
            nums[k] = L[i];
            i += 1;
        } else {
            nums[k] = R[j];
            j += 1;
        }
        k += 1;
    }
    while i < L.len() {
        nums[k] = L[i];
        i += 1;
        k += 1;
    }
    while j < R.len() {
        nums[k] =R[j];
        j += 1;
        k += 1;
    }
}

fn merge_sort(nums: &mut Vec<i32>, l: usize, r: usize) {
    if l < r {
        let mid = (l + r) >> 1;
        merge_sort(nums, l, mid);
        merge_sort(nums, mid + 1, r);
        merge(nums, l, mid, r);
    }
}

快速排序（递归）

naive 实现1（消耗额外空间）

在这里插入图片描述
消耗额外的空间，但思路最简单

Golang

func quicksort(nums []int) []int {
	if len(nums) < 2 {
		return nums
	}
	pivot := nums[0]
	var left, right []int
	for _, e := range nums[1:] {
		if e <= pivot {
			left = append(left, e)
		} else {
			right = append(right, e)
		}
	}
	return append(quicksort(left), append([]int{pivot}, quicksort(right)...)...)
}

Python

def quicksort(nums):
    l = len(nums)
    if l < 2:
        return nums

    p = nums[0]
    left, right = [], []
    for n in nums[1:]:
        if n <= p:
            left.append(n)
        else:
            right.append(n)
    return quicksort(left) + [p] + quicksort(right)

js

function quicksort(nums) {
    let l = nums.length;
    if (l < 2) return nums;
    let pivot = nums[0];
    let left = [], right = [];
    for (let i = 1; i < nums.length; i++) {
        if (nums[i] <= pivot) {
            left.push(nums[i]);
        } else {
            right.push(nums[i]);
        }
    }
    return [...quicksort(left), pivot, ...quicksort(right)];
}

naive 实现2（借助 partition）

Python

def partition(nums, l, r):
    pivot = nums[l]
    while l < r:
        while l < r and pivot <= nums[r]:
            r -= 1
        nums[l] = nums[r]
        while l < r and pivot >= nums[l]:
            l += 1
        nums[r] = nums[l]
    nums[l] = pivot
    return l

def quicksort(nums, l, r):
    if (l < r):
        p = partition(nums, l, r)
        quicksort(nums, l, p - 1)
        quicksort(nums, p + 1, r)

C++

int partition(vector<int>& nums, int l, int r) {
    int pivot = nums[l];
    while (l < r) {
        while (l < r && nums[r] >= pivot) r--;
        nums[l] = nums[r];
        while (l < r && nums[l] <= pivot) l++;
        nums[r] = nums[l];
    }
    nums[l] = pivot;
    return l;
}

void quicksort(vector<int>& nums, int l, int r) {
    if (l < r) {
        int p = partition(nums, l, r);
        quicksort(nums, l, p - 1);
        quicksort(nums, p + 1, r);
    }
}

naive 实现3（额外消耗空间+随机选主元）

rand.Seed(time.Now().UnixNano())

func quicksort(nums []int) []int {
    l := len(nums)
	if l < 2 {
		return nums
	}
	p := rand.Intn(l)
	pivot := nums[p]

	var left, right []int
	for i, e := range nums {
        if i == p {
            continue
        }
		if e <= pivot {
			left = append(left, e)
		} else {
			right = append(right, e)
		}
	}
	return append(quicksort(left), append([]int{pivot}, quicksort(right)...)...)
}

标准模板（简洁可AC）

C++

void quick_sort(int q[], int l, int r) {
    if (l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

Rust

pub fn quicksort(nums: &mut Vec<i32>, l: usize, r: usize) {
    if l >= r {
        return;
    }
    let mut i = l as isize - 1;
    let mut j = r as isize + 1;
    let x = nums[(l + r) >> 1];
    
    while i < j {
        loop {
            i += 1;
            if nums[i as usize] >= x {
                break;
            }
        }
        loop {
            j -= 1;
            if nums[j as usize] <= x {
                break;
            }
        }
        if i < j {
            nums.swap(i as usize, j as usize);
        }
    }
    Self::quicksort(nums, l, j as usize);
    Self::quicksort(nums, j as usize + 1, r);
}

Python

def quicksort(nums, l, r):
    if l >= r:
        return
    i, j = l - 1, r + 1
    x = nums[(l + r) >> 1]
    while i < j:
        i += 1
        while nums[i] < x:
            i += 1
        j -= 1
        while nums[j] > x:
            j -= 1
        if i < j:
            nums[i], nums[j] = nums[j], nums[i]
    quicksort(nums, l, j)
    quicksort(nums, j + 1, r)

Golang

func quicksort(nums []int, l int, r int) {
    if l >= r {
        return
    }
    i := l - 1
    j := r + 1
    x := nums[(l + r) >> 1]
    for i < j {
        for i++; nums[i] < x; i++ {}
        for j--; nums[j] > x; j-- {}
        if i < j {
            nums[i], nums[j] = nums[j], nums[i]
        }
    }
    quicksort(nums, l, j)
    quicksort(nums, j + 1, r)
}

快速排序（非递归）

非递归算法借助于上面的模板代码实现：

C++

void quick_sort(vector<int>& v, int l, int r) {
    using range = pair<int, int>;
    stack<range> task;
    task.push(range(l, r));
    while (!task.empty()) {
        auto t = task.top();
        task.pop();
        if (t.first >= t.second) continue;
        int i = t.first - 1, j = t.second + 1, x = v[i + j >> 1];
        while (i < j) {
            do i++; while (v[i] < x);
            do j--; while (v[j] > x);
            if (i < j) swap(v[i], v[j]);
        }
        task.push(range(t.first, j));
        task.push(range(j + 1, t.second));
    }
}

Golang

type Rng struct {
    left int
    right int
}

func quickSort(nums []int, l int, r int) {
    task := []Rng{{l, r}}
    for len(task) > 0 {
        t := task[len(task) - 1]
        task = task[:len(task) - 1]
        if t.left >= t.right {
            continue
        }
        i, j := t.left - 1, t.right + 1
        x := nums[(i + j) >> 1]
        for i < j {
            i++
            for nums[i] < x {
                i++
            }
            j--
            for nums[j] > x {
                j--
            }
            if i < j {
                nums[i], nums[j] = nums[j], nums[i]
            }
        }
        task = append(task, Rng{t.left, j})
        task = append(task, Rng{j + 1, t.right})
    }
}
Daniel_187
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组的五种排序方式
Txmouse的博客
03-29 2万+
数组的五种排序方式 排序是对数组施加的最常用的算法，所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列；那么对于元素较多的数组，排序算法的优劣至关重要； 一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣； 而常用的排序算法有插入排序、冒泡排序、选择排序和java系统排序。 1.选择排序 选择排序的原理如下： • 将数组中每个元素与第一个元素比较，如果这个元素小于第一个...
数组排序常见的7种方法
tylls的博客
06-29 2979
数组排序 1、桶排序（桶中出现的数组元素都做个标记1，然后将桶数组中有1标记的元素依次打印） //简单, 但是不用,浪费内存 var arr2=[]; for(var i=0;i<arr.length;i++){ var key=arr[i]; arr2[key]=1; } for(var j in arr2){ console.log(j); } 2、冒泡排序（每一趟找出最大的） for(var i =0,len= arr.length;i<len;i++){ // arr[i] // 前面的
数组的常用五种排序算法
热门推荐
Innocence网的博客
09-27 2万+
数组的五种排序方法，选择法、冒泡法、交换法、插入法、折半法
【数组排序算法】
DiKL_Y的博客
05-10 946
数组排序算法的脚本编写
c语言中四种简单的数组排序
wsbydmm的博客
11-15 2万+
c语言中四种数组排序方式
go语言睡眠排序算法实例分析
01-20
睡眠排序算法是一个天才程序员发明的，想法很简单，就是针对数组里的不同的数开多个线程，每个线程根据数的大小睡眠，自然睡的时间越长的，数越大，哈哈，搞笑吧，这种算法看起来很荒唐，但实际上很天才，它可以充分...
Go语言排序算法之插入排序与生成随机数详解
01-01
排序，对于每种编程语言都是要面对的。这里跟大家一起分享golang实现一些排序算法，并且说明如何生成随机数。下面话不多说了，来一起看看详细的介绍吧。 经典排序算法 算法的学习非常重要，是检验一个程序员水平的...
python算法-数组和链表 数组和链表.pdf
04-18
Python算法中，数组和链表是两种常用的数据结构。它们都是用于存储和管理数据的，但是它们在实现和使用上有很大的区别。 数组是具有相同的数据类型且按一定次序排列的集合体。它的元素在内存中的地址是连续相邻的...
详解Java常用排序算法-快速排序
08-26
快速排序算法详解 快速排序（Quick Sort）是一种分治思想的排序算法，它的...快速排序算法是一种高效、稳定的排序算法，广泛应用于各种编程语言和应用领域中。但是，它也存在一些缺点，需要在实际应用中注意这些缺点。
最快的排序算法 javahash实现-Java-哈希算法-最快的实现，排序算法数据结构
04-07
7. 排序算法的选择：在选择排序算法时，需要考虑到哈希函数的选择和实现方式，以及实际应用场景的需求。 8. 数据结构的选择：在选择数据结构时，需要考虑到ハシ表、树形结构、图结构等不同的数据结构的优缺点，并...
java数组排序源代码
03-07
数组的排序源代码 一维或是二维数组 冒泡排序，选择排序，插入排序，希尔（Shell）排序 Java的实现
关于数组排序的三种方法
我要记录学习博客
07-29 4160
每天笔记（7-29） 一、关于数组排序的三种方法 第一种，直接使用Arrays.sort()方法排序数组 public static void main(String[] args) { // 定义一个arr一维数组 int[] arr = {5,4,2,4,1,7,3}; // 使用Arrays.sort()排序数组 Arrays.sort(arr); // 可以使用两种方法进行输出查看 // 第一种，通过循环打印 for(int i = 0;
使用冒泡算法对数组进行排序
fath_kevin的博客
10-12 1万+
作业: 1.    考试成绩已经保存在数组scores中，依次为 89,23,64,91,119,52,73,-23. 要求根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入, 要求判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩.   1.  public class Scores { 2.    3.  public static void main(Strin...
与数组相关算法
wudiyong22的专栏
08-12 3283
找出递增数组中和为s的两个数 问题： 已知一个递增排序的数组和一个数字s，在数组中找出两个数，使它们的和正好等于s，找出任意一对便可。 思路： 普通解法： 第一个数从数组的开头开始，然后利用二分法找第二个数，时间复杂度为nlogn，因为第一个数是从头到尾顺序选择的。 时间复杂度为n的解法： 第一个数从数组的开头开始，第二个数从数组的结尾开始，如果两者的和大于s，则第二个数往前取下一个
leetcode 排序数组 十大排序算法实现
qq_41918762的博客
04-01 1211
leetcode912. 排序数组 十大排序算法实现 文章目录leetcode912. 排序数组 十大排序算法实现[912. 排序数组](https://leetcode-cn.com/problems/sort-an-array/)题目描述排序算法分类算法复杂度Solution Ideabubble sort(冒泡排序)Selection sort(选择排序)Insertion sort(插入排...
C语言--数组实现--各种排序算法个人总结
王日月斤欠
08-15 3040
C语言--数组实现--排序算法：插入排序；希尔排序；冒泡排序；快速排序1；快速排序2；堆排序；归并排序；基数排序；选择排序；计数排序；
数组排序的一些算法实现
chenjialan9214的博客
04-14 92
1.这里先介绍排序算法之一的冒泡排序，该方法总是将小数往前方，大数往后放，类似水中水泡上升的动作，所以叫冒泡排序。 外层循环控制排序轮数，此算法中，有六个数，则排序五轮。而内部循环则控制比较排序，总是把一个数放到比它大的数的前面。 故此实现数组内数字的排序。 public class...
LeetCode 排序数组（八种常见排序算法）
hestyle的博客
06-25 3005
给定一个整数数组 nums，将该数组升序排列。 示例 1： 输入：[5,2,3,1] 输出：[1,2,3,5] 示例 2： 输入：[5,1,1,2,0,0] 输出：[0,0,1,1,2,5] 提示： 1 <= A.length <= 10000 -50000 <= A[i] <= 50000 思路分析：\color{blue}思路分析：思路分析：排序问题是算法中最为经...
使用scala语言编写一个冒泡排序算法
最新发布
09-02
冒泡排序是一种简单的排序算法，其思想是通过相邻元素的比较并交换位置，将较大的元素逐渐“冒泡”到数组的末尾。以下是用Scala语言实现的冒泡排序算法： ```Scala def bubbleSort(arr: Array[Int]): Array[Int] = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值