js 冒泡排序基础写法

冒泡排序是一种简单的排序算法，其基本思想是比较相邻的元素，如果前一个元素比后一个元素大，则交换这两个元素，依次进行，直到没有任何一对元素需要交换为止。

下面是冒泡排序的基础写法：

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;
}

其中，`arr`是待排序的数组，`len`表示数组的长度，`i`和`j`分别表示外层循环和内层循环的下标。通过两层循环，依次比较相邻的元素，如果前一个元素比后一个元素大，则交换这两个元素。内层循环每次可以确定一个最大值，外层循环每次可以确定一个最大值的位置，因此需要进行`len-1`和`len-1-i`次比较。

最后，返回排好序的数组。

相关问题

js中最优冒泡排序写法

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。最优冒泡排序写法是在原始冒泡排序的基础上进行了优化，减少了不必要的比较和交换次数，从而提高了排序效率。下面是最优冒泡排序的写法：

function bubbleSort(arr) {
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
var flag = true; //设置标志位
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;
flag = false; //如果有交换，标志位设为false
}
}
if (flag) break; //如果没有交换，说明已经排好序，直接退出循环
}
return arr;
}

这个算法的时间复杂度为O(n^2)，但是在实际应用中，由于它的常数项比较小，所以它的效率还是比较高的。

冒泡排序多种写法，python

冒泡排序是一种基本的排序算法，它的思路是不断比较相邻的两个元素，如果顺序不对就交换位置，直到最后一个元素。以下是几种不同的 Python 冒泡排序实现方法：

1. 普通的冒泡排序写法

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

2. 优化版 1：增加 flag 标志，如果某一轮没有交换，说明已经有序了，可以提前结束循环。

def bubble_sort_v1(arr):
    n = len(arr)
    for i in range(n - 1):
        flag = False
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                flag = True
        if not flag:
            break
    return arr

3. 优化版 2：记录最后一次交换的位置，因为该位置后的元素已经是有序的了，下一轮循环不需要再比较。

def bubble_sort_v2(arr):
    n = len(arr)
    last_swap = n - 1
    for i in range(n - 1):
        flag = False
        for j in range(last_swap):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                flag = True
                last_swap = j
        if not flag:
            break
    return arr

4. 递归版本：每次调用递归函数时，将待排序的数组长度减 1，直到长度为 1。

def bubble_sort_v3(arr, n=None):
    if n is None:
        n = len(arr)
    if n == 1:
        return arr
    for i in range(n - 1):
        if arr[i] > arr[i + 1]:
            arr[i], arr[i + 1] = arr[i + 1], arr[i]
    return bubble_sort_v3(arr, n - 1)

以上是几种不同的冒泡排序实现方法，它们的时间复杂度都是 O(n^2)，但是优化后的版本能够在特定情况下提高排序效率。