常见的JavaScript排序算法冒泡排序、快速排序、二分搜索、插入排序、归并排序

常见的JavaScript排序算法冒泡排序、快速排序、二分搜索、插入排序、归并排序

1、冒泡排序算法： 冒泡排序是一种简单的排序算法，它通过不断交换相邻元素实现排序。较大的元素会逐渐“冒泡”到数组的末尾。

示例代码：

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

var arr = [3, 1, 5, 2, 4];
console.log(bubbleSort(arr));  // 输出：[1, 2, 3, 4, 5]

2、快速排序算法： 快速排序是一种高效的排序算法，它通过分治的思想和递归实现。它选择一个基准元素，将数组中小于基准的元素放在左边，大于基准的元素放在右边，然后对左右两部分递归进行快速排序。

示例代码：

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  var pivotIndex = Math.floor(arr.length / 2);
  var pivot = arr.splice(pivotIndex, 1)[0];
  var left = [];
  var right = [];
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat([pivot], quickSort(right));
}

var arr = [3, 1, 5, 2, 4];
console.log(quickSort(arr));  // 输出：[1, 2, 3, 4, 5]

3、二分搜索算法： 二分搜索是一种在有序数组中查找目标元素的算法。它将数组分成左右两部分，每次取中间元素与目标元素比较，根据大小关系确定搜索范围，直到找到目标元素或搜索范围为空。

示例代码：

function binarySearch(arr, target) {
  var left = 0;
  var right = arr.length - 1;
  while (left <= right) {
    var mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) {
      return mid;
    } else if (arr[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  return -1;
}

var arr = [1, 2, 3, 4, 5];
console.log(binarySearch(arr, 3));  // 输出：2

4、插入排序算法： 插入排序是一种简单直观的排序算法，它通过构建有序序列，逐个将未排序的元素插入到已排序的序列中。

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

var arr = [3, 1, 5, 2, 4];
console.log(insertionSort(arr));  // 输出：[1, 2, 3, 4, 5]

5、归并排序算法： 归并排序是一种基于分治思想的排序算法，它将数组递归地分成两部分，分别进行归并排序，然后将两个有序的子序列合并成一个有序的序列。

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

function merge(left, right) {
  var result = [];
  while (left.length > 0 && right.length > 0) {
    if (left[0] <= right[0]) {
      result.push(left.shift());
    } else {
      result.push(right.shift());
    }
  }
  return result.concat(left, right);
}

var arr = [3, 1, 5, 2, 4];
console.log(mergeSort(arr));  // 输出：[1, 2, 3, 4, 5]