数组排序

数组（数字）排序

冒泡排序 选择排序 插入排序 归并排序 快速排序

1. 冒泡排序

使用两个嵌套的 for 循环遍历数组。如果当前元素大于下一个元素，我们就交换他们的位置。这个过程会一直重复，直到整个数组都排序完成。

function bubbleSort(arr) {
  let len = arr.length;
  for (let i = 0; i < len; i++) {
    for (let j = 0; j < len - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

let numbers = [4, 2, 9, 6, 23, 12];
console.log(bubbleSort(numbers)); // 输出：[2, 4, 6, 9, 12, 23]

1. 选择排序

使用两个嵌套的 for 循环来遍历数组。在每一轮外层循环中，我们都会找到剩余未排序元素中的最小元素，并将其放到已排序序列的末尾。

function selectionSort(arr) {
  let len = arr.length;
  for (let i = 0; i < len; i++) {
    let minIndex = i;
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    let temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

let numbers = [4, 2, 9, 6, 23, 12];
console.log(selectionSort(numbers)); // 输出：[2, 4, 6, 9, 12, 23]

1. 插入排序

使用两个嵌套的 for 循环来遍历数组。在每一轮外层循环中，我们都会找到剩余未排序元素中的最小元素，并将其放到已排序序列的末尾。

function insertionSort(arr) {
  let len = arr.length;
  for (let i = 1; i < len; i++) {
    let value = arr[i];
    let j = i - 1;
    while (j >= 0 && arr[j] > value) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = value;
  }
  return arr;
}

let numbers = [4, 2, 9, 6, 23, 12];
console.log(insertionSort(numbers)); // 输出：[2, 4, 6, 9, 12, 23]

1. 归并排序

将数组一分为二，然后对每个子数组进行排序，最后将排序后的子数组合并成一个有序的数组。

function mergeSort(arr) {
  let len = arr.length;
  if (len < 2) {
    return arr;
  }
  let middle = Math.floor(len / 2),
      left = arr.slice(0, middle),
      right = arr.slice(middle);
  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  let result = [],
      leftIndex = 0,
      rightIndex = 0;
  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }
  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

let numbers = [4, 2, 9, 6, 23, 12];
console.log(mergeSort(numbers)); // 输出：[2, 4, 6, 9, 12, 23]

1. 快速排序

选择一个基准元素（pivot），然后将数组分为两个子数组，一个包含所有小于基准元素的元素，另一个包含所有大于或等于基准元素的元素。然后我们对这两个子数组进行快速排序。

function quickSort(arr) {
  if (arr.length < 2) {
    return arr;
  }
  let pivot = arr[0];
  let left = [];
  let right = [];
  for (let i = 1; i < arr.length; i++) {
    if (pivot > arr[i]) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
}

let numbers = [4, 2, 9, 6, 23, 12];
console.log(quickSort(numbers)); // 输出：[2, 4, 6, 9, 12, 23]

1. sort 排序

// 增序
let array1 = [5, 2, 7, 3, 1];
const arr1 = array1.sort((a, b) => a - b);
console.log(array1); // 输出：[1, 2, 3, 5, 7]
console.log(arr1); // 输出：[1, 2, 3, 5, 7]

console.log('-------------------------------');

// 降序
let array2 = [5, 2, 7, 3, 1];
const arr2 = array2.sort((a, b) => b - a);
console.log(array2); // 输出：[7, 5, 3, 2, 1]
console.log(arr2); // 输出：[7, 5, 3, 2, 1]

数组（数字和字母）排序

1. 数字数组排序(增，降)

// 增序
let array1 = [5, 2, 7, 3, 1];
const arr1 = array1.sort((a, b) => a - b);
console.log(array1); // 输出：[1, 2, 3, 5, 7]
console.log(arr1); // 输出：[1, 2, 3, 5, 7]

console.log('-------------------------------');

// 降序
let array2 = [5, 2, 7, 3, 1];
const arr2 = array2.sort((a, b) => b - a);
console.log(array2); // 输出：[7, 5, 3, 2, 1]
console.log(arr2); // 输出：[7, 5, 3, 2, 1]

1. 字母数组排序（ASCII 码）

// 增序
let array1 = ['c', 'b', 'a', 'ba', 'bb'];
const arr1 = array1.sort();
console.log(array1); // 输出：['a', 'b', 'ba', 'bb', 'c']
console.log(arr1); // 输出：['a', 'b', 'ba', 'bb', 'c']

console.log('-------------------------------');

// 降序
let array2 = ['c', 'b', 'a', 'ba', 'bb'];
const arr2 = array2.sort().reverse();
console.log(array2); // 输出：['c', 'bb', 'ba', 'b', 'a']
console.log(arr2); // 输出：['c', 'bb', 'ba', 'b', 'a']

1. 数组对象选项排序(增)

    // 增序
    let array1 = [{
        value: 3,
        label: '标题3'
    }, {
        value: 1,
        label: '标题1'
    }, {
        value: 5,
        label: '标题5'
    }, {
        value: 2,
        label: '标题2'
    }, {
        value: 4,
        label: '标题4'
    }];
    const arr1 = array1.sort((a, b) => a.value - b.value);
    console.log(array1);
    console.log(arr1);
    /* [
        {
            "value": 1,
            "label": "标题1"
        },
        {
            "value": 2,
            "label": "标题2"
        },
        {
            "value": 3,
            "label": "标题3"
        },
        {
            "value": 4,
            "label": "标题4"
        },
        {
            "value": 5,
            "label": "标题5"
        }
    ] */