冒泡算法

Posted 2021-11-30 mawawa

冒泡排序：

需求：对一个数组内元素进行从大到小或者从小到大排序；

前提：要知道肯定是双重循环，单循环无法排列；

方法：（比如从大到小排列）遍历这个素组，对n 与 n+1(相邻的)元素进行比较，如果n < n+1(即前一个小于后一个) 那么交换它们俩的位置；前面所说的是内循环，那么这样的内循环要循环整个数组长度；

// 冒泡排序

const sortArr = [23, 22, 13, 54, 24, 76, 99];
// js 提供的方法 sort
const afterSortArr = sortArr.sort((a, b) => {
  return a - b;
})
console.log(afterSortArr, ‘js sort 方法排序，其原理也是冒泡排序‘)
const sortArrSpecial = [0, 1, 1, 1, 1, 23, 22, 13, 54, 24, 76, 99, 0, 0, 0, 0, 0, 1, 1];
// js 提供的方法 sort
const afterSortArrSpecial = sortArrSpecial.sort((a, b) => {
  return a - b;
})
console.log(afterSortArrSpecial, ‘js sort 方法排序，其原理也是冒泡排序特殊版‘)

// 冒泡排序 传统方法 (每次比较相邻位置，如果从大到小排列，每次比较完如果小与都互换位置，反之亦然)
const customSortArrDesc = [23, 22, 13, 54, 24, 76, 99];
const customSortArrDescLen = customSortArrDesc.length;
for( let i = 0; i < customSortArrDescLen; i ++) {
  for(let j = 0; j < customSortArrDescLen - 1; j ++) {
    // console.log(customSortArrDesc[j]) // 这里可以打印出看下，交换位置后下次取值还会是上一次取得值
    if(customSortArrDesc[j] > customSortArrDesc[j + 1]) { // 这一行决定从大到小排列还是从小到大排列
      let temporary = customSortArrDesc[j]; // 临时存放
      customSortArrDesc[j] = customSortArrDesc[j + 1];
      customSortArrDesc[j + 1] = temporary;
    }
  }
}
console.log(customSortArrDesc, ‘js 双重for循环方法从大到小冒泡排序‘)
// 升序
const customSortArrAsce = [23, 22, 13, 54, 24, 76, 99];
const customSortArrAsceLen = customSortArrAsce.length;
for( let i = 0; i < customSortArrAsceLen; i ++) {
  for(let j = 0; j < customSortArrAsceLen - 1; j ++) {
    // console.log(customSortArrAsce[j]) // 这里可以打印出看下，交换位置后下次取值还会是上一次取得值
    if(customSortArrAsce[j] < customSortArrAsce[j + 1]) { // 这一行决定从大到小排列还是从小到大排列
      let temporary = customSortArrAsce[j]; // 临时存放
      customSortArrAsce[j] = customSortArrAsce[j + 1];
      customSortArrAsce[j + 1] = temporary;
    }
  }
}
console.log(customSortArrAsce, ‘js 双重for循环方法从小到大冒泡排序‘)