js中的冒泡排序、快速排序、选择排序、插入排序

时间复杂度指的是一个算法执行所耗费的时间
空间复杂度指运行完一个程序所需内存的大小
稳定指，如果a=b,a在b的前面，排序后a仍然在b的前面
不稳定指，如果a=b，a在b的前面，排序后可能会交换位置

冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一步，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

	function bubbleSort(arr) {
		// 判断参数是否是数组
        if (!Array.isArray(arr)) {
            throw new Error('传入的参数不是数组！')
        }
        // 缓存数组长度
        const len = arr.length
        // 数组长度小于2时，不用比较返回自身
        if (len < 2) {
            return arr
        }
        for (let i = 0; i < len - 1; i++) { //外循环会从数组的第一位迭代 至最后一位，它控制了在数组中经过多少轮排序
            for (let j = 0; j < len - 1 - i; j++) { //内循环将从第一位迭代至length - i位，因为后i位已经是排好序的，不用重新迭代
                // 相邻元素两两对比，元素交换，大的元素交换到后面
                if (arr[j] > arr[j + 1]) {
                    [arr[j + 1], arr[j]] = [arr[j], arr[j + 1]]
                }
            }
        }
        return arr
    }

快速排序

• 选择数组中间数作为基数，并从数组中取出此基数。
• 准备两个数组容器，遍历数组，逐个与基数比对，较小的放左边容器，较大的放右边容器。
• 递归处理两个容器的元素，并将处理后的数据与基数按大小合并成一个数组，返回。

   function quickSort(arr) {
        // 判断参数是否是数组
        if (!Array.isArray(arr)) {
            throw new Error('传入的参数不是数组！')
        }
        // 缓存数组长度
        const len = arr.length
        // 数组长度小于2时，不用比较返回自身
        if (len < 2) {
            return arr
        }
        // 获取数组中间值索引
        const middleIndex = Math.floor(len / 2)
        // 数组中间值
        const middle = arr[middleIndex]
        // 数组删除该中间值
        arr.splice(middleIndex, 1)
        // 定义左边数组和右边数组，循环arr数组，小于中间值的push到左边的数组，大于中间值的push到右边的数组
        const leftArr = []
        const rightArr = []
        arr.forEach(c => {
            if (c >= middle) {
                rightArr.push(c)
            } else {
                leftArr.push(c)
            }
        })
        // 递归左边的数组和右边的数组，并拼装成结果
        return quickSort(leftArr).concat(middle, quickSort(rightArr))
    }

选择排序

• 首先从原始数组中找到最小的元素，并把该元素放在数组的最前面，然后再从剩下的元素中寻找最小的元素，放在之前最小元素的后面，知道排序完毕。

   function selectSort(arr){
   		// 判断参数是否是数组
        if (!Array.isArray(arr)) {
            throw new Error('传入的参数不是数组！')
        }
        // 缓存数组长度
        const len = arr.length
        // 数组长度小于2时，不用比较返回自身
        if (len < 2) {
            return arr
        }
        // 默认最小值下标为0
        let minIndex = 0
        for (let i = 0; i < len - 1; i++) {
            minIndex = i
            for (let j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j
                }
            }
            [arr[minIndex], arr[i]] = [arr[i], arr[minIndex]]
        }
        return arr
    }

插入排序

• 从第一个元素开始，该元素可以认为已经被排序。
• 取出下一个元素，在已经排序的元素序列中从后向前扫描。
• 如果该元素（已排序）大于新元素，将该元素移到下一位置。
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
• 将新元素插入到该位置后。
• 重复步骤2~5。
  

	function insertSort(arr) {
		// 判断参数是否是数组
        if (!Array.isArray(arr)) {
            throw new Error('传入的参数不是数组！')
        }
        // 缓存数组长度
        const len = arr.length
        // 数组长度小于2时，不用比较返回自身
        if (len < 2) {
            return arr
        }
        let curr, prevIndex   // curr 记录当前元素， preIndex 记录当前元素的前面元素的下标
        for (let i = 1; i < len; i++) {
            curr = arr[i]
            prevIndex = i - 1
            while (prevIndex >= 0 && arr[prevIndex] > curr) {
                arr[prevIndex + 1] = arr[prevIndex]    // 如果前面的元素大于当前元素 则往后移动一个位置
                prevIndex --						   // 继续向前标记	
            }
            arr[prevIndex + 1] = curr				  // 当前元素插入标志的位置
        }
        return arr
    }