JavaScript算法（三）

最新推荐文章于 2024-07-17 09:44:02 发布

海阔凭鱼跃学习笔记

最新推荐文章于 2024-07-17 09:44:02 发布

阅读量336

点赞数 7

文章标签： javascript 算法开发语言前端

本文链接：https://blog.csdn.net/qq_37633967/article/details/136710856

版权

系列文章目录

前言

JavaScript算法，排序、搜索。

11.排序和搜索

排序：把某个乱序的数组变成升序或者降序的数组（js排序：数组 sort 方法）
搜索：找出数组中某个元素的下标（js搜索：数组 indexOf 方法）

排序算法：冒泡排序、选择排序、插入排序、归并排序、快速排序...

搜索算法：顺序搜索、二分搜索...

冒泡排序

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

// 冒泡排序时间复杂度：O(n^2)
Array.prototype.bubbleSort = function(){
    for(let i = 0;i < this.length -1;i += 1){
        for(let j = 0;j < this.length - 1 - i;j += 1){
            if(this[j] > this[j+1]){
                const temp = this[j];
                this[j] = this[j + 1];
                this[j+1] = temp;
            }
        }
    }
}

const arr = [5,4,3,2,1];
arr.bubbleSort();

选择排序

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

// 选择排序时间复杂度：O(n^2)
Array.prototype.selectionSort = function(){
    for(let i = 0;i < this.length -1;i += 1){
        let indexMin = i;
        for(let j = i;j < this.length;j += 1){
            if(this[j] < this[indexMin]){
                indexMin = j;
            }
        }
        if(indexMin !== i){
            const temp = this[i];
            this[i] = this[indexMin];
            this[indexMin] = temp;
        }
    }
}

const arr = [5,4,3,2,1];
arr.selectionSort();

插入排序

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

// 插入排序时间复杂度：O(n^2)
Array.prototype.insertionSort = function(){
    for(let i = 1;i < this.length;i += 1){
        const temp = this[i];
        let j = i;
        while(j > 0){
            if(this[j-1] > temp){
                this[j] = this[j-1]
            }else{
                break;
            }
            j-=1;
        }
        this[j] = temp;
    }
}

const arr = [2,4,3,5,1];
arr.insertionSort();

归并排序

分：把数组劈成两半，再递归地对子数组进行‘分’操作，直到分成一个个单独的数
合：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个完整的数组

合并两个有序数组

新建一个空数组res，用于存放最终排序后的数组
比较两个有序数组的头部，较小者出队并推入res中
如果两个数组还有值，就重复第二步

// 分 时间复杂度: O(logN) 
// 合 时间复杂度: O(n)
// 时间复杂度: O(n*logN)
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,4,3,5,1];
arr.mergeSort();

快速排序

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

// 递归时间复杂度 O(logN)
// 分区时间复杂度 O(n)
// 时间复杂度 O(n*logN)
Array.prototype.quickSort = function(){
    const rec = (arr) => {
        if(arr.length === 1) return arr;
        const left = [];
        const right = [];
        const md = 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 = [2,4,3,5,1];
arr.quickSort();

顺序搜索

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

// 时间复杂度 O(n)
Array.prototype.sequentialSearch = function(item){
    for(let i=0; i<this.length;i+=1){
        if(this[i] === item){
            return i;
        }
    }
    return -1;
};

const res = [1,2,3,4,5].sequentialSearch(3)

二分搜索

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

// 时间复杂度 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;
};

const res = [1,2,3,4,5].binarySearch(0)

// leetCode 21 合并两个有序链表
// 两个升序链表合并为一个新链表
// 输入 
var mergeTwoLists = function(l1,l2){
    const res = new ListNode(0);
    let p = res;
    let p1 = l1;
    let p2 = l2;
    while(p1 && p2){
        if(p1.val < p2.val){
            p.next = p1;
            p1 = p1.next;
        }else{
            p.next = p2;
            p2 = p2.next;
        }
        p = p.next;
    }
    if(p1){
        p.next = p1;
    }    
    if(p2){
        p.next = p2;
    }
    return res.next;
}

// leetCode 374 猜数字大小
// 二分搜索
var guessNumber = function(n){
    let low = 1;
    let high = n;
    while(low <= high){
        const mid = Math.floor((low + high) / 2);
        const res = guess(mid);
        if(res === 0){
            return mid;
        }else if( res === 1){
            low = mid + 1;
        }else{
            high = mid -1;
        }
    }
}