JavaScript——冒泡排序

墨问莫问645

已于 2022-07-23 22:27:20 修改

阅读量315

点赞数

文章标签： javascript 排序算法算法

于 2022-07-23 22:24:41 首次发布

本文链接：https://blog.csdn.net/qq_64133626/article/details/125952958

版权

冒泡排序原理

我认为本质上其实就是将数组内相邻的两个元素进行比较，然后判断是否交换这两个变量的值，后面的元素依次执行。

我的思路：

外层循环控制趟数，里层循环控制每一趟的循环次数；
比较数组内相邻的两个元素，根据相应条件判断是否交换它们两个的值；
从第一组到最后一组，对每一组相邻的两个元素做同样的工作；每轮循环后，末尾的元素就会是最大或最小的数；
针对数组内所有的元素重复上述的操作（除了最后一个）直到没有任何一组数字需要比较为止，输出数组。

代码示例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>冒泡排序</title>
    <script>
        var arr = [220, 190, 140, 160, 150, 180, 170, 50, 150, 88, 108];
        for (var i = 0; i < arr.length; i++) { // 外层循环控制趟数
            for (var j = 0; j < arr.length - i; j++) {  // 里层循环控制每一趟的循环次数
                if (arr[j] < arr[j + 1]) { // 从大到小 改为 > 则从小到大排序
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        console.log(arr);
    </script>
</head>
<body>
</body>
</html>

结果：

案例分析

从 1~30 中选出 5 个能被 2 整除的随机数，并对他们从大到小排序，最后输出一个数组。

方法1：

定义一个空数组 arr；
选取 1~30 中能被 2 整除的数加入数组 arr；
从中随机取 5 个数生成一个新数组 newArr；
从大到小进行冒泡排序并输出这个数组 newArr。

方法2：

定义一个空数组 arr；
从 1~30 中选出能被 2 整除的随机数放入数组 arr；
当数组长度为 5 时，跳出循环 break；
从大到小进行冒泡排序并输出数组。

代码1：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>test</title>
    <script>
        var arr = [];
        var newArr = [];
        for (var i = 1; i <= 30; i++) {
            if (i % 2 == 0) {
                arr.push(i);
            }
            for (var k = 0; k < 5; k++) {
                newArr[k] = arr[Math.floor(Math.random() * arr.length)];
            }
        }
        for (var i = 0; i < newArr.length; i++) {
            for (var j = 0; j < newArr.length - i; j++) {
                if (newArr[j] < newArr[j + 1]) { // 从大到小
                    var temp = newArr[j];
                    newArr[j] = newArr[j + 1];
                    newArr[j + 1] = temp;
                }
            }
        }
        console.log(newArr);
    </script>
</head>
<body>
</body>
</html>

代码2：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>test</title>
    <script>
        var arr = [];
        for (var i = 0; i <= 30; i++) {
            var a = Math.floor(Math.random() * 30) + 1
            if (a % 2 == 0) {
                arr.push(a);
            }
            if (arr.length == 5) {
                break;
            }
        }
        for (var i = 0; i < arr.length; i++) {
            for (var j = 0; j < arr.length - i; j++) {
                if (arr[j] < arr[j + 1]) { // 从大到小
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        console.log(arr);
    </script>
</head>
<body>
</body>
</html>

结果：

小结：上述方法只是我所知的思路，事实上肯定不止我写的这两个，而且冒泡排序还可以通过函数方法等来实现，目前我还不会，有兴趣的可以自行研究。

下面是我看到的一篇对冒泡排序分析很详细的博客：

冒泡排序（超详细）_@烟雨倾城ゝ的博客-CSDN博客_冒泡排序

墨问莫问645

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
JavaScript——冒泡排序

我认为本质上其实就是将数组内相邻的两个元素进行比较，然后判断是否交换这两个变量的值，后面的元素依次执行。外层循环控制趟数，里层循环控制每一趟的循环次数；比较数组内相邻的两个元素，根据相应条件判断是否交换它们两个的值；从第一组到最后一组，对每一组相邻的两个元素做同样的工作；每轮循环后，末尾的元素就会是最大或最小的数；针对数组内所有的元素重复上述的操作（除了最后一个）直到没有任何一组数字需要比较为止，输出数组。从 1~30 中选出 5 个能被 2 整除的随机数，并对他们从大到小排序，最后输出一个数组。.
复制链接

扫一扫