JS十大经典排序排序算法

1.冒泡排序

冒泡排序通常排在第一位，说明它是排序算法的入门算法，是最简单的一个排序算法，而且必须掌握和理解。

先来看看代码吧：

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

时间复杂度：O(n^2);

思路：第一次循环，开始比较当前元素与下一个元素的大小，如果比下一个元素小或者相等，则不需要交换两个元素的值；若比下一个元素大的话，则交换两个元素的值。然后，遍历整个数组，第一次遍历完之后，相同操作遍历第二遍。

2.选择排序

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

时间复杂度：O(n^2)

思路：第一遍，从数组中选出最小的，与第一个元素进行交换；第二遍，从第二个元素开始，找出最小的，与第二个元素进行交换；依次循环，完成排序。

 

3.插入排序

function insertSort(arr) {
    let len = arr.length;
    for (let i = 0; i < len; i++) {
        let temp  = arr[i];
        for (let j = 0; j < i; j++) {
            if (temp > arr[j] && j === 0) {
                arr.spice(i, 1);
                arr.unshif(temp);
            } else if (temp > arr[j] && temp < arr[j + 1] && j < i - 1) {
                arr.splice(i, 1);
                arr.splice(j + 1, 0, temp);
            }
        }  
    }
    return arr;
}

时间复杂度：O(n^2)

思路：首先，循环原数组，然后，将当前位置的元素，插入到之前已经排序好的数组中， 依次操作。

4.快速排序

function quickSort(arr) {
    let len = arr.length;
    if (len <= 1) {
        return arr;
    }

    let temp = arr[0],
        left = [],
        right = [];
    
    for (let i = 1; i < len; i++) {
        if (arr[i] > temp) {
            right.push(arr[i]);
        } else {
            left.push(arr[i]);
        }
    }
    return quickSort(left).concat([temp], quickSort(right));
}

时间复杂度：O(nlogn)

思路：首先，我们需要找到一个基数，然后将比基数小的值放在基数的左边，将比基数大的值放在基数的右边，之后进行递归那两组已经归类好的数组。