今天我们将来介绍一下三种基础的排序算法：冒泡排序、选择排序和插入排序。

冒泡排序

冒泡排序的基本思想是通过比较相邻元素并进行交换，将较大的元素逐步“冒泡”到数组的末尾。具体步骤如下：

1. 创建一个循环，从数组的第一个元素开始，直到倒数第二个元素（因为最后一个元素在内部循环中会与下一个元素进行比较）。
2. 在内部循环中，比较当前元素和下一个元素的值。如果当前元素大于下一个元素，则交换它们的位置。
3. 继续进行第 2 步的比较，直到内部循环结束。
4. 每完成一轮外部循环，最大的元素就会“冒泡”到数组的末尾。
5. 重复步骤 1-4，直到所有元素都排好序。

下面是用 JavaScript 实现冒泡排序的示例代码：

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 unsortedArray = [5, 1, 4, 2, 8];
var sortedArray = bubbleSort(unsortedArray);
console.log(sortedArray); // 输出 [1, 2, 4, 5, 8]

在上面的代码中，我们定义了一个 bubbleSort 函数，它接受一个数组作为输入，并返回一个排好序的新数组。函数内部使用两个嵌套循环来进行比较和交换操作，最终返回排好序的数组。

通过调用 bubbleSort 函数并传入未排序的数组 [5, 1, 4, 2, 8]，我们可以得到排好序的数组 [1, 2, 4, 5, 8]。

需要注意的是，在实际应用中，冒泡排序算法的效率较低，因为它需要重复遍历整个数组，时间复杂度为O(n^2)。

选择排序

选择排序的基本思想是依次从未排序的部分中选出最小（或最大）的元素，然后将其放置在已排序部分的末尾。具体步骤如下：

1. 创建一个循环，从数组的第一个元素开始，直到倒数第二个元素。
2. 假设当前元素是未排序部分的最小元素。
3. 在内部循环中，遍历未排序部分的元素，从当前元素的下一个位置开始。
4. 检查每个元素是否比当前最小元素更小。如果是，则更新最小元素为该元素。
5. 完成内部循环后，将最小元素与当前元素进行交换。
6. 继续进行第 2-5 步的操作，直到外部循环结束。
7. 完成排序后，数组就会按升序排列。

下面是用 JavaScript 实现选择排序的示例代码：

function selectionSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len - 1; i++) { // 外部循环控制轮数
    var minIndex = i; // 假设当前元素是未排序部分的最小元素
    for (var j = i + 1; j < len; j++) { // 内部循环找出未排序部分的最小元素
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    // 将最小元素与当前元素进行交换
    var temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

// 示例用法
var unsortedArray = [5, 1, 4, 2, 8];
var sortedArray = selectionSort(unsortedArray);
console.log(sortedArray); // 输出 [1, 2, 4, 5, 8]

在上面的代码中，我们定义了一个 selectionSort 函数，它接受一个数组作为输入，并返回一个排好序的新数组。函数内部使用两个嵌套循环来找出未排序部分的最小元素，并将其与当前元素进行交换，最终返回排好序的数组。

通过调用 selectionSort 函数并传入未排序的数组 [5, 1, 4, 2, 8]，我们可以得到排好序的数组 [1, 2, 4, 5, 8]。

选择排序的时间复杂度也为O(n^2)。

插入排序

插入排序是一种简单直观的排序算法，其基本思想是将数组分为已排序部分和未排序部分，然后逐个将未排序部分的元素插入到已排序部分的合适位置，直到整个数组有序。

插入排序的详细步骤：

1. 从第二个元素开始，将当前元素插入到已排序序列中的合适位置；
2. 持续比较当前元素和已排序序列中的元素，将当前元素插入到合适的位置；
3. 重复上述步骤，直到整个数组排序完成。

插入排序的代码示例：

function insertionSort(arr) {
  var len = arr.length;
  for (var i = 1; i < len; i++) {
    var current = arr[i]; // 当前需要排序的元素
    var j = i - 1;
    while (j >= 0 && arr[j] > current) {
      arr[j + 1] = arr[j]; // 将大于当前元素的元素向后移动
      j--;
    }
    arr[j + 1] = current; // 将当前元素插入到合适的位置
  }
  return arr;
}

// 测试
var arr = [5, 3, 8, 6, 4];
console.log(insertionSort(arr)); // 输出 [3, 4, 5, 6, 8]

在这段代码中，我们使用了两层循环。外层循环用于遍历整个数组，内层循环用于找到当前元素的合适位置并进行插入操作。在内层循环中，我们不断将大于当前元素的元素向后移动，直到找到当前元素的合适位置，然后将当前元素插入到该位置。

插入排序的时间复杂度为O(n^2)，对于小规模的数据和基本有序的数据，插入排序效率较高。