JS 冒泡排序

算法简介

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序不符合要求就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（数组的最前面）。

代码

第一种写法

function bubbleSort(arr) {

    if (!Array.isArray(arr)) {
        return;
    }

    let sortedFlag = true;     //是否是已经有序
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[i]) {
                let temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;

                sortedFlag = false;
            }
        }

        // 优化：如果是本身就是有序的，那么就不需要再继续循环了。
        if (sortedFlag) {
            break;
        }
    }
}

解读：

1. 从数组第一个元素开始，依次与其后面的元素比较，若其比后面的元素大，则交换两元素的位置。这样的话，一轮过后，数组中最小的元素就是被放在数组的最前面。前面已经排好序的就不动，不参与比较。
2. 重复步骤1，直到n-1个元素都排好序，那么最后一个就不用比较了，肯定就是其中最大的元素。

第二种写法

function bubbleSort2(arr) {
    if (!Array.isArray(arr)) {
        return;
    }

    let sortedFlag = true;     //是否是已经有序
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = 0; j < len - 1 - i; j++) {     // 这里 -i是减去已经排好序的个数   每一轮都会把最大的元素放到最后面
            if (arr[j] > arr[j + 1]) {              // 相邻元素两两对比  前一个比后一个大就交换位置
                var temp = arr[j + 1];              // 元素交换
                arr[j + 1] = arr[j];
                arr[j] = temp;

                sortedFlag = false;
            }
        }

        // 优化：如果是本身就是有序的，那么就不需要再继续循环了。
        if (sortedFlag) {
            break;
        }
    }
}

解读：

1. 从数组第一个元素开始，依次与其后相邻的元素比较，若其比后面的元素大，则交换两元素的位置。这样的话，一轮过后，数组中最大的元素就是被放在数组的最后面。已经排好序的元素就不动，不参与比较。
2. 重复步骤1，直到n-1个元素都排好序，那么最后一个就不用比较了，肯定就是其中最小的元素。

小优化
注意此处有个优化，就是如果本身数组就是有序的，那么经过一轮循环后，是可以不用继续循环了，正是因为这个，可以极大的优化算法性能。

时间复杂度和空间复杂度

再谈谈冒泡排序的时间复杂度和空间复杂度吧！

时间复杂度

1. 我们看下最好的情况，也就是本身就是有序数组，那么经过一轮循环后，如果没发生交换位置，那么可以知道sortedFlag等于true，直接跳出循环。这个最好情况，也循环了n次。
2. 如果并非是有序的，就要循环遍历了。最坏的情况就是完整的经历两轮n次循环。
3. 如果数组本身不是有序的，都要经历两轮循环，只不过比最坏的情况要好。

• 最好的情况：O（n）
• 最坏的情况：O（n^2）
• 平均：O（n^2）

空间复杂度
O（1）,基本是个定值，除了数组本身和临时变量占用内存，并没有额外用到很多内存。

如有错漏，欢迎大佬们拍砖~