Javascript 排序算法（转）

1.快速排序

class QuickSort {
  Sort(originalArray) {
    // 复制 originalArray 数组防止它被修改
    const array = [...originalArray];

    // 如果 originalArray 数组元素个数 <=1，就不需要排序了，直接返回
    if (array.length <= 1) {
      return array;
    }

    // 初始化左数组和右数组
    const leftArray = [];
    const rightArray = [];

    // 取出 originalArray 数组中的第一个元素作为中间比较值
    const pivotElement = array.shift();
    const centerArray = [pivotElement];

    // 把 originalArray 数组拆分成左、中、右三个数组
    while (array.length) {
      const currentElement = array.shift();

      if (currentElement == pivotElement) {
        centerArray.push(currentElement);
      } else if (currentElement < pivotElement) {
        leftArray.push(currentElement);
      } else {
        rightArray.push(currentElement);
      }
    }

    // 递归对左、右数组进行排序
    const leftArraySorted = this.Sort(leftArray);
    const rightArraySorted = this.Sort(rightArray);

    // 最后把排好序的左、中、右数组拼接起来，并返回
    return leftArraySorted.concat(centerArray, rightArraySorted);
  }
}

2.选择排序

class SelectionSort{
    Sort(originalArray){
        // 复制 originalArray 防止它被修改
        const array = [...originalArray];

        for(let i = 0; i<array.length - 1; i += 1){
            let minIndex = i;

            // 查找剩余数组中的最小元素
            for(let j = i+1; j<array.length; j += 1){
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
            }

            // 如果找到新的最小元素，就把它和当前元素进行交换
            if(minIndex !== i){
                const tmp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = tmp;
            }
        }

        return array;
    }
}

3.冒泡排序

class BubbleSort {
    // 常见的写法
    Sort1(originalArray) {
        const array = [...originalArray];
        for (let i = 1; i < array.length; i += 1) {
            let swapped = false;
            for (let j = 0; j < array.length - i; j += 1) {
                if (array[j] > array[j + 1]) {
                    const tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;

                    swapped = true; // 记录是否交换过元素
                }
            }
            if (!swapped) { // 如果未发生过交换（swapped = false），则表明已经排好序，结束循环
                return array;
            }
        }
    }

    // 常见的写法(循环语句换成：do..while 方式)
    Sort2(originalArray) {
        const array = [...originalArray]; // 在原始数组的副本上修改
        let n = array.length;
        let swapped = false;
        do {
            swapped = false;
            for (let i = 1; i < n; i += 1) {
                if (array[i - 1] > array[i]) {
                    const tmp = array[i - 1];
                    array[i - 1] = array[i];
                    array[i] = tmp;

                    swapped = true; // 记录是否交换过元素
                }
            }
            n = n - 1; // 最后一个元素以排好序，所以下一次它不需参与比较
        } while (swapped); // 如果未发生过交换（swapped = false），则表明已经排好序，结束循环

        return array;
    }

    // 优化后的冒泡排序算法
    // 来源：https://en.wikipedia.org/wiki/Bubble_sort
    Sort3(originalArray) {
        const array = [...originalArray]; // 在原始数组的副本上修改
        let n = array.length;
        do {
            let newn = 0;
            for (let i = 1; i < n; i += 1) {
                if (array[i - 1] > array[i]) {
                    const tmp = array[i - 1];
                    array[i - 1] = array[i];
                    array[i] = tmp;

                    newn = i; // 记录最后一次被交换的元素位置
                }
            }
            n = newn; // 只需比较至上一次发生交换的地方即可
        } while (n > 1); // 如果交换位置已移动到起始元素（n <= 1），则表明已经排好序，结束循环

        return array;
    }
}

原文地址：https://github.com/trekhleb/javascript-algorithms