进阶算法之“搜索与排序”

排序与搜索简介

排序和搜索是什么？

• 排序：把某个乱序的数组变成升序或者降序的数组
• 搜索：找出数组中某个元素的下标

JS中的排序和搜索

• JS中的排序：数组的sort方法
• JS中的搜索：数组的indexOf方法

排序算法

• 冒泡排序(效率低)
• 选择排序(效率低)
• 插入排序(效率低)
• 归并排序(效率还行 可用于工作中)
• 快速排序(效率还行 可用于工作中)
• ...

搜索算法

• 顺序搜索(性能 O(n))
• 二分搜索(性能 O(logN))
• ...

冒泡排序

冒泡排序的思路

• 比较所有相邻元素，如果第一个比第二个大，则交换它们
• 一轮下来，可以保证最后一个数是最大的
• 执行n-1轮，就可以完成排序

可通过动画观看实现： visualgo.net/zh/sorting

代码实现

Array.prototype.bubbleSort = function(){
    for(let i = 0;i < this.length - 1;i++){
        for(let j = 0;j < this.length - 1 - i; j++){
            let tmp;
            if(this[j] > this[j+1]){
                tmp = this[j];
                this[j] = this[j+1];
                this[j+1] = tmp;
            }
        }
    }
};

const arr = [2,3,45,23,3,4,2];
arr.bubbleSort();

两个嵌套循环，时间复杂度：O(n*n)

选择排序

• 找到数组中的最小值，选中它并将其放置在第一位
• 接着找到第二小的值，选中它并将其放置在第二位
• 以此类推，执行n-1轮

可通过动画观看实现： visualgo.net/zh/sorting

代码实现

Array.prototype.selectionSort = function(){
    for(let i = 0; i < this.length -1; i++){
        let indexMin = i;
        for(let j = i+1; j < this.length; j++){
            if(this[j] < this[indexMin]){
                indexMin = j;
            }
        }
        let tmp = this[i];
        this[i] = this[indexMin];
        this[indexMin] = tmp;
    }
};

const arr = [1,7,7,7,7,7,3,3,3,212,2,3,45,23,3,4,2];
arr.selectionSort();
console.log(arr)

两个嵌套循环，时间复杂度：O(n*n)

插入排序

• 从第二个数开始往前比
• 比它大就往后排
• 以此类推进行到最后一个数

可通过动画观看实现： visualgo.net/zh/sorting

代码实现

Array.prototype.insertionSort = function(){
    for(let i = 1;i < this.length; i++){        
        for(let j = i; j > 0; j--){
            if(this[j]<this[j-1]){
                let temp = this[j];
                this[j] = this[j-1];
                this[j-1] = temp;
            }
        }
    }
};

const arr = [1,7,7,7,5,3,3,212,2,3,45,23,3,4,2];
arr.insertionSort();
console.log(arr)

两个嵌套循环，时间复杂度：O(n*n)

归并排序的时间复杂度

• 分：把数组劈成两半，再递归地对子数组进行“分”操作，直到分成一个个单独的数
• 合：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个完整数组
  • 新建一个空数组res,用于存放最终排序后的数组
  • 比较两个有序数组的头部，较小者出队并推入res中
  • 如果两个数组还有值，就重复第二步

可通过动画观看实现： visualgo.net/zh/sorting

Array.prototype.mergeSort = function(){
    const rec = (arr) =>{
        if(arr.length <= 1){ return arr ;}
        const mid = Math.floor(arr.length/2);
        const left = arr.slice(0,mid);
        const right = arr.slice(mid,arr.length);
        const orderLeft = rec(left);
        const orderRight = rec(right);
        const 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;
    }
    const res = rec(this);
    res.forEach((n,i) => {this[i] = n;});
};

const arr = [2,5,4,3,1];
arr.mergeSort();
console.log(arr)

• 分的时间复杂度是O(logN)
• 合的时间得杂度是O(n)
• 总的时间复杂度：O(n*logN)

LeetCode题目21

答案可参考官方题解

题解：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);

        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;

        return prehead.next;
    }
}

快速排序的思路

• 分区：从数组中任意选择一个"基准"，所有比基准小的元素放在基准前面，比基准大的元素放在基准的后面
• 递归：递归地对基准前后的子数组进行分区

可通过动画观看实现： visualgo.net/zh/sorting

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

const arr = [1,7,7,7,5,3,3,212,2,3,45,23,3,4,2];
arr.quickSort();
console.log(arr)

• 递归的时候复杂度是O(logN)
• 分区操作的时间复杂度是O(n)
• 总的时间复杂度：O(n*logN)

顺序搜索

• 遍历数组
• 找到跟目标值相等的元素，就返回它的下标
• 遍历结束后，如果没有搜索到目标值，就返回-1

Array.prototype.sequentialSearch = function(item){
    for(let i = 0; i < this.length; i++){
        if(this[i] === item){
            return i;
        }
    }
    return -1;
};

const arr = [2,5,4,3,1];
arr.sequentialSearch(3);
console.log(arr.sequentialSearch(1))

• 遍历数组是一个循环操作
• 时间复杂度：O(n)

二分搜索的思路

• 从数组的中间元素开始，如果中间元素正好是目标值，则搜索结束
• 如果目标值大于或者小于中间元素，则在大于或小于中间元素的那一半数组中搜索
• 前提是已经排好序的数组

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

const arr = [1,2,3,4,5];
arr.binarySearch(3);
console.log(arr.binarySearch(4))

• 每一次比较都使搜索范围搜索一半
• 时间复杂度：O(logN)

LeetCode题374

题解：

/** 
 * Forward declaration of guess API.
 * @param {number} num   your guess
 * @return 	            -1 if num is lower than the guess number
 *			             1 if num is higher than the guess number
 *                       otherwise return 0
 * var guess = function(num) {}
 */

/**
 * @param {number} n
 * @return {number}
 */

var guessNumber = function(n) {
    let left = 1, right = n;
    while (left < right) { // 循环直至区间左右端点相同
        const mid = Math.floor((left + right ) / 2); 
        if (guess(mid) <= 0) {
            right = mid; // 答案在区间 [left, mid] 中
        } else {
            left = mid + 1; // 答案在区间 [mid+1, right] 中
        }
    }
    // 此时有 left == right，区间缩为一个点，即为答案
    return left;
};