数组排序

1.冒泡排序
算法思想：比较相邻元素，进行排序。每次遍历会冒泡一个最大或最小值（这取决于你是降序还是升序），然后每次对除过冒泡出去的元素外再进行遍历。

   var a = [1, 3, 6, 3, 23, 76, 1, 34, 222, 6, 456, 221];

        function bubbleSort(arr) {
        	let temp
            for (let i = 0; i < arr.length - 1; i++) {
                for (let j = 0; j < arr.lentgh - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr
        }
        console.log(bubbleSort(arr));//[1, 1, 3, 3, 6, 6, 23, 34, 76, 221, 222, 456]

2.快速排序
快排思想：在数组中选取一个基数（一般是第一个元素），然后将数组与基数比较，将数组分成两部分，基数右边是大于基数的数组，基数左边是小于基数的数组。然后对基数两边的数组递归调用函数，直到数组长度<=1，则排序完成进行拼接

        var a = [1, 3, 6, 3, 23, 76, 1, 34, 222, 6, 456, 221];

        function quickSort(arr) {
        //判断数组长度，小于等于1时是递归出口
            if (arr.length <= 1) return arr
            const len = arr.length
            //选基数，将其从数组取出
            const index = Math.floor(arr.length / 2)
            const pivot = arr.splice(index, 1)[0]
            const left = []
            const right = []
            //将数组与基数比较，小的放letf中，大的放right中
            for (let i = 0; i < arr.length; i++) {
                if (arr[i] <= pivot) {
                    left.push(arr[i])
                } else {
                    right.push(a[i])
                }
            }
            //递归调用函数对left、right进行排序，最后进行拼接
            return quickSort(left).concat(pivot, quickSort(right))
        }
        console.log(quickSort(a));//[1, 1, 3, 3, 6, 6, 23, 34, 76, 221, 222, 456]

3.插入排序
插入思想：第一项为已排，后边剩下的为待排。每次从待排里取一个值与已排的进行比较，然后将其插入到合适的位置，然后其也成为已排的一项。依次循环直到待排为空。

   var a = [1, 3, 6, 3, 23, 76, 1, 34, 222, 6, 456, 221];
   function insertSort(array) {
   		let len = array.length
   		let current,prev
   		for (let i = 0; i < len; i++) {
   			current = a[i]
   			prev = i - 1
   			while (prev >= 0 && array[prev] > current) {
   				array[prev + 1] = array[prev]
   				prev--
   			}
   			array[prev] = current
   		}
   }
   console.log(insertSort(a))//[1, 1, 3, 3, 6, 6, 23, 34, 76, 221, 222, 456]

4.选择排序
算法思想：首先用第一项与其余项比较，如果最小则不变，如果有比他大的则交换位置，一直循环直到当前第一项最小。进入外层的第二次循环，这时用数组的第二项继续与之后的比较…以此循环直到剩下最后一个值，则此时数组已经完成排序。

        var a = [1, 3, 6, 3, 23, 76, 1, 34, 222, 6, 456, 221];

        function selectSort(array) {
            const len = array.length
            let temp, minIndex
            for (let i = 1; i < len - 1; i++) {
                minIndex = i
                for (let j = i + 1; j < len; j++) {
                    if (array[j] < array[minIndex]) {
                        minIndex = j
                    }
                }
                temp = array[i]
                array[i] = array[minIndex]
                array[minIndex] = temp
            }
            return array
        }
        console.log(selectSort(a));// [1, 1, 3, 3, 6, 6, 23, 34, 76, 221, 222, 456]