JavaScript：数组排序（冒泡排序）

<script> // 1、默认排序 // 1.1 数组元素为数值型 let arrInt = [1,2,6,4,7,6,9,3,2,2,5,6] let newArrInt = arrInt.sort(); console.log("原数组", arrInt); console.log("排序后的数组", newArrInt); console.log("原数组是否改变", arrInt !== newArrInt); </script>

（2）数组元素为字符串型

<script> // 1、默认排序 // 1.2 数组元素为字符串型 let arrStr = ['q','','q','aaa','aa','a']; let newArrStr = arrStr.sort(); console.log("原数组", arrStr); console.log("排序后的数组", newArrStr); console.log("原数组是否改变", arrStr !== newArrStr); </script>

3、自定义排序

通过提供 compareFunction 比较函数，可以实现自定义排序，指定排序顺序；

比较函数：（ a , b ）=> { return a – b }；

（1）数组元素为数值型

按照数字大小进行排序；

// 2、自定义排序 // 2.1 数组元素为数值型 let arrInt = [1, 2, 6, 4, 7, 6, 9, 3, 2, 2, 5, 6] // let newArrInt1 = arrInt.sort((a,b)=>{ return a - b}); // console.log("数字大小升序:", newArrInt1); let newArrInt2 = arrInt.sort((a, b) => { return b - a }); console.log("数字大小降序:", newArrInt2);

（2）数组元素为字符串型

按照字符串长度进行排序；

// 2、自定义排序 // 2.2 数组元素为字符串型 let arrStr = ['Apple', 'Strawberry','Orange','Grape', 'Cherry', 'Banana', 'Watermelon', 'Durian']; // let newArrStr1 = arrStr.sort((a, b) => { return a.length - b.length }); // console.log("字符串长度升序:", newArrStr1); let newArrStr2 = arrStr.sort((a, b) => { return b.length - a.length }); console.log("字符串长度降序:", newArrStr2);

（3）数组元素为对象

按照年龄大小排序；

// 2、自定义排序 // 2.3 数组元素为对象 let arrObj = [ { name: "ZZ", age: 18 }, { name: "EE", age: 16 }, { name: "LL", age: 19 }, { name: "UU", age: 22 }, { name: "MM", age: 15 } ]; // let newArrObj1 = arrObj.sort((a, b) => { return a.age - b.age }); // console.log("年龄升序:", newArrObj1); let newArrObj2 = arrObj.sort((a, b) => { return b.age - a.age }); console.log("年龄降序:", newArrObj2);

三、冒泡排序

1、基本概念

冒泡排序，是一种简单的排序算法，它通过重复遍历待排序的数列，比较相邻元素并交换它们的位置，直到整个数列有序；

这个过程就像气泡一样，让较大的元素逐渐“浮”到数组的顶端；

2、实现步骤

从头到尾遍历整个数列，比较相邻的元素；
如果前一个元素大于后一个元素，则交换它们的位置；
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对；
比较交换结束后，被比较的元素中最后一个就是相对最大的数；
对整个数组元素重复上述过程（除了最后一个），每次需要交换的元素越来越少，直到没有需要交换的元素为止；

3、过程解析

以下的分析过程，均以该数组为例：arr = [4, 7, 2, 8, 8, 2, 4, 3, 4]，共计9个元素进行升序排序；

（1）第一次排序

找出数组元素arr[0] ~ arr[8]中的最大元素，将最大的元素放置在 arr[8] 的位置；

第一步，比较arr[0] 和arr[1]；如果arr[0] 大于 arr[1]，则交换两个位置的元素（较大的元素后置）；
第二步，比较arr[1] 和arr[2]；如果arr[1] 大于 arr[2]，则交换两个位置的元素；
……
第八步，比较arr[7] 和arr[8]；如果arr[7] 大于 arr[8]，则交换两个位置的元素；

结束后，数组arr[0] ~ arr[8]中最大的元素已经处在 arr[8] 的位置，此后，不再参与比较；

（2）第二次排序

找出数组元素arr[0] ~ arr[7]中的最大元素，将最大的元素放置在 arr[7] 的位置；

第一步，比较arr[0] 和arr[1]；如果arr[0] 大于 arr[1]，则交换两个位置的元素；
第二步，比较arr[1] 和arr[2]；如果arr[1] 大于 arr[2]，则交换两个位置的元素；
……
第七步，比较arr[6] 和arr[7]；如果arr[6] 大于 arr[7]，则交换两个位置的元素；

结束后，数组arr[0] ~ arr[7]中最大的元素已经处在 arr[7] 的位置，此后，不再参与比较；

（3）重复排序

根据第一次排序和第二次排序，重复这样的排序步骤，直到将arr[0]与arr[1]做完比较排序，使得所有的元素有序；

（4）排序规律

每一次排序都是在找，被比较的所有元素中最大的元素，并将其放置在这些元素的最后；
数组中共有n个元素（长度为n），则排序的次数总计为n-1；
第 i 次比较完成，就会有 i 个元素相对有序，参与下次比较的元素就只有 n-i 个；

4、代码示例

函数定义：bubbleSort() 函数接收一个数组 arr 作为参数；
参数校验：在排序之前，对传入的参数 arr 进行校验；
外层循环：控制排序的轮数，总共需要 n – 1 轮（ n 是数组长度）；
内层循环：进行相邻元素的比较和交换，随着外层循环的进行，已经排好序的元素会逐渐“浮”到数组的末尾，因此内层循环的范围逐渐减小；
元素交换：如果当前元素大于下一个元素，则交换它们的位置；
返回结果：排序完成后返回排序后的数组；

<script> // 传入正常数组 console.log(bubbleSort([4, 7, 2, 8, 8, 2, 4, 3, 4])); // 传入空数组 console.log(bubbleSort([])); // 传入非数组 console.log(bubbleSort('arr')); // 冒泡排序 function bubbleSort(arr) { // 判断传入的参数是否为数组 if (Object.prototype.toString.call(arr) !== "[object Array]") return '不是数组'; // 长度为0 或 1 的数组直接返回,不需要排序 if (arr.length < 2) return arr; // 外层循环 控制比较的轮数 for (let i = 0; i < arr.length-1; i++) { // 内层循环 控制相邻两个元素的比较和交换, for (let j = 0; j < arr.length - 1 - i; j++) { // 前一个元素大于后一个, 则交换这两个元素 if (arr[j] > arr[j+1]) { let temp = arr[j+1]; arr[j+1] = arr[j]; arr[j] = temp } } } return arr; } </script>

冒泡排序虽然简单易懂，但在处理大规模数据时效率较低（时间复杂度O(n²)）；

=========================================================================

每天进步一点点~！

记录一下冒泡排序这个有用的东东~~！

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://haidsoft.com/122891.html

JavaScript：数组排序（冒泡排序）

一、数组排序

二、sort()方法

1、基本语法

2、默认排序