排序 js

if (Array.isArray(arr) && arr.length === 0) { console.log('数组为空'); }

一、冒泡（这里的两个for循环,第一个代表轮数，第二个代表比较的次数）

// let arr = [1,2,3,4,5,6,7];
let arr = [6,9,3,1,7,4,2];

function bubbleSort(arr) {
    const len = arr.length;
    for (let i = 0; i < len; i++) {
        console.log('I----------------------------------------',arr[i],arr);
        for (let j = 0; j < len - 1; j++) {
            console.log('J',arr[j]);
            if (arr[j] > arr[j + 1]) {
                // 相邻元素两两对比
                let temp = arr[j]; // 元素交换
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                }
            }
        }
    return arr;
}

bubbleSort(arr);

当arr换成第一个arr的时候，运行代码，也是做了很多无用功的

即使在每轮的第二个for循环结束后第一大数、第二大数，第三大数都会排在最后一位，增加了无效比较的次数

只需要轻微的改变就可以,如下；将每轮的第二个for循环长度每次减去轮次数

let arr = [1, 2, 3, 4, 5, 6, 7];
// let arr = [6,9,3,1,7,4,2];

//函数bubbleSort，用于冒泡排序
function bubbleSort(arr) {
  const len = arr.length;
  //外层循环，控制比较的轮数
  for (let i = 0; i < len; i++) {
    console.log("I----------------------------------------", arr[i], arr);
    //内层循环，控制每轮比较的次数
    for (let j = 0; j < len - 1 - i; j++) {
      console.log("J", arr[j]);
      //每轮比较，如果前一个元素大于后一个元素，则交换
      if (arr[j] > arr[j + 1]) {
        // 相邻元素两两对比
        let temp = arr[j]; // 元素交换
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  //返回排序后的数组
  return arr;
}

//调用函数bubbleSort，对数组arr进行冒泡排序
bubbleSort(arr);

二、快排

快速排序快速排序的实现，一看就能明白https://www.yangfei.wiki/zh/post/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F

function quickSort(arr) {
  if (arr.length <= 1) return arr
  const mIdx = Math.floor(arr.length / 2);
  const middle = arr[mIdx];
  const left = [];
  const right = []
  arr.forEach((item, idx) => {
    // 索引值不能相等
    if (idx !== mIdx) {
      if (item >= middle) {
        right.push(item)
      }
      if (item < middle) {
        left.push(item)
      }
    }
  })
  return quickSort(left).concat([middle], quickSort(right))
}

const a = [1, 22, 22, 13, 14, 14, 16, 19, 17, 18]

const b = quickSort(a)

console.log(b)

let arr = [6,9,3,5,7,4,2];
//函数quickSort,用于快速排序
function quickSort(arr) {
    //如果数组长度小于等于1,则直接返回
    console.log("-------------------本次循环开始了哈,当前将要处理的arr是", arr);
    if (arr.length <= 1) {
        console.log('当前arr无需进一步处理,直接返回')
        // 如果数组长度小于等于1无需判断直接返回
        return arr;
    }
    let pivotIndex = Math.floor(arr.length / 2);  //取基准点
    console.log(pivotIndex, "是当前arr的长度的中间值下标index值" );
    let pivot = arr.splice(pivotIndex, 1)[0];  //
    console.log('arr.splice(pivotIndex, 1)', arr.splice(pivotIndex, 1))
    console.log("pivot", pivot);
    let left = [];
    let right = [];
    //遍历数组,将基准点左右两边的元素分别存入left和right数组
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    console.log('left',left,'right',right)
    console.log('=====================本次循环结束了哈,arr被改造成了', arr);
    //递归调用quickSort函数,对left和right数组分别进行快速排序,最后将基准点插入到排序后的数组中
    return quickSort(left).concat([pivot], quickSort(right));
}
console.log(quickSort(arr))