冒泡算法

冒泡排序：

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

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

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

降序排列代码如下：

• 　写法一：

// 冒泡排序 传统方法 (每次比较相邻位置，如果从大到小排列，每次比较完如果小与都互换位置，反之亦然)
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 chooseSortArrDesc = [23, 22, 13, 54, 24, 76, 99];
  // 从小到大排序(双重for循环) 需要一个替换元素
  for( let i = 0; i < chooseSortArrDesc.length; i ++) {
    for(let j = i + 1; j <chooseSortArrDesc.length; j ++) {
      if(chooseSortArrDesc[i] < chooseSortArrDesc[j]) { // 这一行决定从大到小排列还是从小到大排列
        let temporary = chooseSortArrDesc[i]; // 临时存放
        chooseSortArrDesc[i] = chooseSortArrDesc[j];
        chooseSortArrDesc[j] = temporary;
      }
    }
  }

console.log(chooseSortArrDesc, '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循环方法从小到大冒泡排序')

• 写法二

const chooseSortArrAsce = [0, 1, 1, 1, 1, 23, 22, 13, 54, 24, 76, 99, 0, 0, 0, 0, 0, 1, 1];
// 从小到大排序(双重for循环) 需要一个替换元素
for( let i = 0; i < chooseSortArrAsce.length; i ++) {
  for(let j = i + 1; j <chooseSortArrAsce.length; j ++) {
    if(chooseSortArrAsce[i] > chooseSortArrAsce[j]) { // 这一行决定从大到小排列还是从小到大排列
      let temporary = chooseSortArrAsce[i]; // 临时存放
      chooseSortArrAsce[i] = chooseSortArrAsce[j];
      chooseSortArrAsce[j] = temporary;
    }
  }
}
console.log(chooseSortArrAsce, 'js 双重for循环方法从小到大选择排序')