js排序和搜索

冒泡排序 O(n^2)

比较所有相邻元素，如果第一个比第二个大，则交换它们。

一轮下来，可以保证最后一个数是最大的。

function bubbleSort (arr) {
            for (var i = 0; i < arr.length - 1; i++) {
                for (var j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                    }
                }
            }
            console.log(arr);

        }
        bubbleSort([5, 4, 3, 2, 1])

选择排序 O(n^2)

找到数组中的最小值，选中它并将其放置在第一位。

接着找到第二小的值，选中它并将其放置在第二位。

以此类推，执行n-1轮。

function selectionSort (arr) {
            for (var i = 0; i < arr.length - 1; i++) {
                var indexMin = i
                for (var j = i; j < arr.length; j++) {
                    if (arr[j] < arr[indexMin]) {
                        indexMin = j
                    }
                }
                if (indexMin !== i) {
                    var temp = arr[i]
                    arr[i] = arr[indexMin]
                    arr[indexMin] = temp
                }
            }
            console.log(arr);
        }
        selectionSort([5, 4, 3, 2, 1])

 插入排序 O(n^2)

从第二个数开始往前比。

比它大就往后排。

以此类推进行到最后一个数。

function insertionSort (arr) {
            for (var i = 1; i < arr.length; i++) {
                var temp = arr[i]
                var j = i
                while (j > 0) {
                    if (arr[j - 1] > temp) {
                        arr[j] = arr[j - 1]
                    } else {
                        break
                    }
                    j--
                }
                arr[j] = temp
            }
            console.log(arr);
        }
        insertionSort([5, 4, 3, 2, 1])

归并排序 O(nlogn)

分：把数组劈成两半，再递归的对子数组进行“分”操作，直到分成一个个单独的数。O(logn)

合：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个完整数组。O(n)

合并两个有序数组：

        新建一个空数组res，用于存放最终排序后的数组。

        比较两个有序数组的头部，较小者出队并推入res中。

        如果两个数组还有值，就重复第二步。

function mergeSort (arr) {
            var rec = (e) => {
                if (e.length === 1) { return e }
                var mid = Math.floor(e.length / 2)
                var left = e.slice(0, mid)
                var right = e.slice(mid, e.length)
                var orderLeft = rec(left)
                var orderRight = rec(right)
                var res = []
                while (orderLeft.length || orderRight.length) {
                    if (orderLeft.length && orderRight.length) {
                        res.push(orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift())
                    } else if (orderLeft.length) {
                        res.push(orderLeft.shift())
                    } else if (orderRight.length) {
                        res.push(orderRight.shift())
                    }
                }
                return res
            }
            var res = rec(arr)
            res.forEach((n, i) => {
                arr[i] = n
            });
            console.log("mergeSort",arr);
        }
        mergeSort([5, 4, 3, 2, 1])

 快速排序 O(nlogn)

分区：从数组中任意选择一个“基准”，所有比基准小的元素放在基准前面，比基准大的元素放在基准的后面。O(n)

递归：递归的对基准前后的子数组进行分区。O(logn)

function quickSort (arr) {
            var rec = (e) => {
                if (e.length <= 1) { return e }
                var left = []
                var right = []
                var mid = e[0]
                for (var i = 1; i < e.length; i++) {
                    if (e[i] < mid) {
                        left.push(e[i])
                    } else {
                        right.push(e[i])
                    }
                }
                return [...rec(left), mid, ...rec(right)]
            }
            var res = rec(arr)
            res.forEach((n, i) => {
                arr[i] = n
            })

            console.log("quickSort", arr);
        }
        quickSort([5, 4, 3, 2, 1])

顺序搜索 O(n)

遍历数组。

找到跟目标值相等的元素，就返回它的下标。

遍历结束后，如果没有搜索到目标值，就返回-1。

Array.prototype.sequentialSearch = function (item) {
            for (let i = 0; i < this.length; i++) {
                if (this[i] === item) {
                    return i
                }
            }
            return -1
        }
        var res =[5, 4, 3, 2, 1].sequentialSearch(3)
        console.log(res);

 二分搜索 O(logn)

从数组的中间元素开始，如果中间元素正好是目标值，则搜索结束。

如果目标值大于或者小于中间元素，则在大于或者小于中间元素的那一半数组中搜索。

Array.prototype.binarySearch = function (item) {
            let low = 0
            let high = this.length - 1
            while (low <= high) {
                const mid = Math.floor((low + high) / 2)
                const element = this[mid]
                if (element < item) {
                    low = mid + 1
                } else if (element > item) {
                    high = mid - 1
                } else {
                    return mid
                }
            }
            return -1
        }
        var res = [5, 4, 3, 2, 1].binarySearch(3)
        console.log(res);