JavaScript-10种排序算法及代码示例

以下整理了十种JS常用的排序算法，及其代码示例。

1.冒泡排序

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

2.选择排序

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

3.快速排序

function quickSort(array) {
  if (array.length <= 1) {
    return array;
  }

  var pivotIndex = Math.floor(array.length / 2);
  var pivot = array.splice(pivotIndex, 1)[0];
  var left = [];
  var right = [];

  for (var i = 0; i < array.length; i++) {
    if (array[i] < pivot) {
      left.push(array[i]);
    } else {
      right.push(array[i]);
    }
  }

  return quickSort(left).concat([pivot], quickSort(right));
}

4.插入排序

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

5.希尔排序

function shellSort(arr) {
  const len = arr.length;
  let gap = Math.floor(len / 2);
  while (gap > 0) {
    for (let i = gap; i < len; i++) {
      let j = i;
      while (j - gap >= 0 && arr[j] < arr[j - gap]) {
        [arr[j], arr[j - gap]] = [arr[j - gap], arr[j]];
        j -= gap;
      }
    }
    gap = Math.floor(gap / 2);
  }
  return arr;
}

6.归并排序

function mergeSort(arr) {
  const merge = (left, right) => {
    const res = [];
    while (left.length && right.length) {
      if (left[0] <= right[0]) {
        res.push(left.shift());
      } else {
        res.push(right.shift());
      }
    }
    while (left.length) {
      res.push(left.shift());
    }
    while (right.length) {
      res.push(right.shift());
    }
    return res;
  }
  if (arr.length <= 1) {
    return arr;
  }
  const mid = Math.floor(arr.length / 2);
  const left = arr.slice(0, mid);
  const right = arr.slice(mid);
  return merge(mergeSort(left), mergeSort(right));
}

7.堆排序

function heapSort(arr) {
  buildMaxHeap(arr);
  for(let i = arr.length - 1; i >= 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]];
    maxHeapify(arr, 0, i);
  }
  return arr;
}

function buildMaxHeap(arr) {
  const len = arr.length;
  for(let i = Math.floor(len / 2); i >= 0; i--) {
    maxHeapify(arr, i, len);
  }
}

function maxHeapify(arr, index, size) {
  const left = 2 * index + 1;
  const right = 2 * index + 2;
  let largest = index;
  if(left < size && arr[left] > arr[largest]) {
    largest = left;
  }
  if(right < size && arr[right] > arr[largest]) {
    largest = right;
  }
  if(largest !== index) {
    [arr[index], arr[largest]] = [arr[largest], arr[index]];
    maxHeapify(arr, largest, size);
  }
}

8.计数排序

function countingSort(arr) {
  if(arr.length <= 1) {
    return arr;
  }
  const counts = new Array(Math.max(...arr) + 1).fill(0);
  for(let i = 0; i < arr.length; i++) {
    counts[arr[i]]++;
  }
  for(let i = 1; i < counts.length; i++) {
    counts[i] += counts[i - 1];
  }
  const result = new Array(arr.length);
  for(let i = arr.length - 1; i >= 0; i--) {
    result[counts[arr[i]] - 1] = arr[i];
    counts[arr[i]]--;
  }
  return result;
}

9.桶排序

function bucketSort(arr, bucketSize = 5) {
  if(arr.length <= 1) {
    return arr;
  }
  const minVal = Math.min(...arr);
  const maxVal = Math.max(...arr);
  const bucketCount = Math.floor((maxVal - minVal) / bucketSize) + 1;
  const buckets = new Array(bucketCount);
  for(let i = 0; i < buckets.length; i++) {
    buckets[i] = [];
  }
  for(let i = 0; i < arr.length; i++) {
    const bucketIndex = Math.floor((arr[i] - minVal) / bucketSize);
    buckets[bucketIndex].push(arr[i]);
  }
  const result = [];
  for(let i = 0; i < buckets.length; i++) {
    if(buckets[i].length > 0) {
      result.push(...insertionSort(buckets[i]));
    }
  }
  return result;
}

10.基数排序

function radixSort(arr) {
  if(arr.length <= 1) {
    return arr;
  }
  const maxNum = Math.max(...arr);
  let digit = 1;
  while(Math.floor(maxNum / digit) > 0) {
    arr = countingSortForRadix(arr, digit);
    digit *= 10;
  }
  return arr;
}

function countingSortForRadix(arr, digit) {
  const counts = new Array(10).fill(0);
  for(let i = 0; i < arr.length; i++) {
    const num = Math.floor(arr[i] / digit) % 10;
    counts[num]++;
  }
  for(let i = 1; i < counts.length; i++) {
    counts[i] += counts[i - 1];
  }
  const result = new Array(arr.length);
  for(let i = arr.length - 1; i >= 0; i--) {
    const num = Math.floor(arr[i] / digit) % 10;
    result[counts[num] - 1] = arr[i];
    counts[num]--;
  }
  return result;
}

创作不易，关注收藏。