【算法训练】 -- 冒泡排序

最新推荐文章于 2024-11-14 21:21:03 发布

橘子☆心酸

最新推荐文章于 2024-11-14 21:21:03 发布

阅读量123

点赞数

分类专栏：数据结构与算法分析文章标签：算法排序算法

本文链接：https://blog.csdn.net/zhqi9277/article/details/131506309

版权

数据结构与算法分析专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章介绍了冒泡排序的基本概念、实现方法、动图演示以及时间复杂度分析。冒泡排序在已排序和逆序情况下有不同时间复杂度，平均为O(n^2)。文章提供了四个LeetCode问题的解决方案，展示了冒泡排序在实际编程场景中的应用，尽管效率不高，但适用于小规模数据排序。

摘要由CSDN通过智能技术生成

1.定义

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换。

2.实现方法

冒泡排序需要选择一个元素，一般是第一个元素或者是最后一个元素，不断地与后面的元素进行比较，若不满足想要的顺序（正序或者倒叙）则进行位置交换，一轮交换完后，选择第二个元素进行第二轮交换，直到除最后一个元素外的所有元素均进行了一轮交换，序列变成有序。

3.动图演示

在这里插入图片描述

4.复杂度分析

当一个序列已经是有序时，其速度最快，此时冒泡排序只需要进行一次比较，时间复杂度为O(n)。
当一个序列是完全逆序是，其速度最慢，此时需要进行n-1趟排序，每趟比较n-i次，时间复杂度为O(n^2)。
平均情况：平均时间复杂度也为O(n^2)。

5.代码实现

力扣 - 1046. 最后一块石头的重量
在这里插入图片描述
实现代码：

var bubbleSort = function(nums){
    const n = nums.length
    for(let i =0;i < n -1;i++){
        for(let j = i;j < n;j++){
            if(nums[i] > nums [j]){
                let tmp = nums[i]
                nums[i] = nums[j]
                nums[j] = tmp
            }
        }
    }
}

var lastStoneWeight = function(stones) {
    while(stones.length > 1){
        bubbleSort(stones)
        let num1 = stones.pop()
        let num2 = stones.pop()
        if(num1 === num2) continue
        else stones.push(num1 - num2)
    }
    return stones
};

力扣 - 2148. 元素计数
在这里插入图片描述
实现代码：

var bubbleSort = function(nums){
    const n = nums.length
    for(let i = 0;i < n - 1;i++){
        for(let j = i;j < n;j++){
            if(nums[i] > nums[j]){
                let tmp = nums[i]
                nums[i] = nums[j]
                nums[j] = tmp
            }
        }
    }
}

var countElements = function(nums) {
    bubbleSort(nums)
    let ans = 0
    for(let i = 0;i < nums.length;i++){
        if(nums[i] === nums[0]||nums[nums.length - 1] === nums[i]) continue
        ans++
    }
    return ans
};

力扣 - 1464. 数组中两元素的最大乘积

在这里插入图片描述
实现代码：

var bubbleSort = function(nums){
    const n = nums.length
    for(let i=0;i<n-1;i++){
        for(let j = i;j < n;j++){
            if(nums[i] > nums[j]){
                let tmp = nums[i]
                nums[i] = nums[j]
                nums[j] = tmp
            }
        }
    }
}

var maxProduct = function(nums) {
    bubbleSort(nums)
    const len = nums.length
    return (nums[len - 1] - 1) * (nums[len - 2] - 1)
};

力扣 - 88. 合并两个有序数组

在这里插入图片描述
实现代码：

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

var merge = function(nums1, m, nums2, n) {
    nums1.splice(m)
    nums2.splice(n)
    nums1.push(...nums2)
    bubbleSort(nums1)
};

6.总结

冒泡排序（Bubble Sort）是一种基础的排序算法，它的思想比较简单：每次比较相邻的两个数，如果顺序不对则交换，这样一轮下来，最大（或最小）的数就会被交换到最后面。接下来再从头开始重复上述操作，直到全部排序完成。冒泡排序的时间复杂度为 O(n^2)，效率较低，但对于小规模的数据排序还是比较适用的。

冒泡排序的优点是实现简单，只需要一个循环和一个判断即可，且不需要额外的内存空间。缺点是效率较低，时间复杂度为 O(n^2)，在处理大规模的数据时速度会很慢。

总的来说，冒泡排序适合处理小规模的数据，如果数据量较大，可以采用其他更加高效的排序算法，如快速排序、归并排序等。。