前端-查找算法系列刷题笔记

 

查找算法类题型

算法学习参考

1.二分查找

leetcode参考

二分法搜算步骤:预处理,对集合进行排序;二分查找,使用循坏或者递归再每次比较厚将查找空间分为两半;后处理,在剩余空间中确定可行的候选者;

Question1:   简述二分查找算法与时间复杂度,并实现一个二分查找算法!

如:[2,3,0,9] 在这个数组中查找9,则应该返回下标索引3;

Answer1:  对要查找的数组按从小到大排好序,然后找到中间点;比对中间点和要找的值的大小,如果找的值大于中间值,则在上半部分数组查找,反之;以此循坏直到上下界限相等;没找到就返回-1;

Code1:  Math.floor向下取整的意思  sort()要传入回调函数,指定是从小到大排序还是从大到小排序  时间复杂度O(logn) 空间复杂度O(1)

//二分法查找
function binarySearch(items, item) {
    var low = 0,
        hight = items.length - 1,
        elem, mid;
    while (low <= hight) {
        mid = Math.floor((low + hight) / 2);
        elem = items[mid];
        if (elem < item) {
            low = mid + 1;
        } else if (elem > item) {
            hight = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
};
//测试
var arr = [2, 3, 0, 9];
//使用自带的排序sort 
arr.sort((a,b)=>a-b);
console.log(arr); //[0.2,3,9]
var result = binarySearch(arr, 9);
console.log(result); //3

Question2:   用二分法查找x的平方根??

Answer2:  数组x的平方根不会超过x/2所以只需要在1-x/2之间查找平方根;有的说mid用left+(right-left)/2是因为防止溢出问题;

Code2: 时间复杂度O(logn)n=x/2,但是经过数学化解之后logn 就是 -1+logn ,所以呢时间复杂度就是O(logn)空间复杂度O(1)

var mySqrt = function(x) {
    if (x < 2) return x;
    let left = 1,
        right = Math.floor(x / 2),
        mid;
    while (left <= right) {
        mid = Math.floor(left + (right - left) / 2);
        if (x / mid < mid) {
            right = mid - 1;
        } else if (x / mid > mid) {
            left = mid + 1;
        } else {
            return mid;
        }
    };
    return right;
}

Question3:   用二分法实现猜数字游戏,每轮游戏从1-n随机选择数字,让我们程序去猜它选的哪个数字,搞了半天终于懂了这个题说的啥意思了,是让我写代码去实现猜准这个数字,噗??

可以调用预定义好的guess(num)函数获取猜测结果,猜大了返回-1,猜小了返回1,猜对了返回的是0;

Answer3:  利用二分法的思想从1-n之间去查找选定的数字是哪个,通过返回值来判断是应该向下还是向上半部分查找;

Code3: 时间复杂度O(logn)  空间复杂度O(1)

var guessNumber = function(n) {
    let left = 1,
        right = n,
        mid;
    while (left <= right) {
        mid = Math.floor(left + (right - left) / 2);
        let returnValue = guess(mid);
        if (returnValue == -1) {
            right = mid - 1;
        } else if (returnValue == 1) {
            left = mid + 1;
        } else {
            return mid;
        }
    }
}

Question4:   搜索旋转排序数组,升序排列的数组nums在某个点上进行了旋转,比如[0,1,2,4,5,6,7]旋转后为[4,5,6,7,0,1,2]; 在数组中搜索target,存在返回它的索引,不存在返回-1;

Answer4:  可以观察到旋转之后有一部分有序,有一部分可能无序,所以可以先判断有序无序nums[left]<=nums[midIndex]表示前部分有序,反之后部分有序;然后在有序里面判断是否存在这个值,要是不存在就在无序部分搜索;以此循坏知道left>right

Code4: 平均时间复杂度O(logn),空间复杂度O(1)

var search = function(nums, target) {
    let left = 0,
        right = nums.length - 1,
        midIndex;
    while (left <= right) {
        midIndex = Math.floor(left + (right - left) / 2);
        if (nums[midIndex] == target) {
            return midIndex;
        }
        if (nums[left] <= nums[midIndex]) {
            if (target >= nums[left] && target <= nums[midIndex]) {
                right = midIndex - 1;
            } else {
                left = midIndex + 1;
            }
        } else {
            if (target >= nums[midIndex] && target <= nums[right]) {
                left = midIndex + 1;
            } else {
                right = midIndex - 1;
            }
        }
    }
    return -1;
};

2021.01.12

Question5:   第一个错误版本,有n个版本[1,2,3,....,n],,有一个版本错了则后面的都错,我们需要编程找到导致之后所有版本出错的第一个版本;如:给定n=5,version=4是第一个出错版本;isBadVersion()是预先定义好的;

Answer5:  根据题目意思的话我们可以用二分法的第二个模板来做;先是判断mid的状态,如果mid错误了那就向左查找,错误版本肯定在mid之前或者就是mid;mid是正确的那就像右查找;

Code5: 平均时间复杂度O(logn)  空间复杂度O(1)  

var solution = function(isBadVersion) {
    /**
     * @param {integer} n Total versions
     * @return {integer} The first bad version
     */
    return function(n) {
        if (n == 0) return -1;
        let left = 1,
            right = n,
            mid;
        while (left < right) {
            mid = Math.floor(left + (right - left) / 2);
            if (isBadVersion(mid)) {
                //向左查找
                right = mid;
            } else {
                //向右查找
                left = mid + 1;
            }
        }
        if (isBadVersion(left)) return left;
        return -1;
    };
};

Question6:   题目 峰值元素是指其值大于左右相邻值的元素;给你一个输入数组 nums,找到峰值元素并返回其索引。数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。假设 nums[-1] = nums[n] = -∞

Answer6:  根据题目的假设,我们可以用中位mid值处于上坡还是下坡去判断,要是处于上坡就往右边查找,处于下坡往左边去查找;

Code6: 平均时间复杂度O(logn)  空间复杂度O(1)  

var findPeakElement = function(nums) {
    if(nums.length==1) return 0;
let left = 0,
        right = nums.length,
        midIndex;
    while (left < right) {
        midIndex = Math.floor(left + (right - left) / 2);
        if (nums[midIndex] > nums[midIndex - 1] && nums[midIndex] > nums[midIndex + 1])
            return midIndex;
        if (nums[midIndex] < nums[midIndex + 1]) {
            //上坡在右边查找
            left = midIndex + 1;
        } else {
            right = midIndex;
        }
    }
    if(left!=nums.length)return left;
    return -1;
};

Question7:   题目 寻找旋转排序数组中得最小值,假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2]

Answer7:  解答参考  用二分法去做,先判断数组有没有旋转,没有旋转当然就是第一个最小了(升序得情况下啦),有旋转的话也是一部分有序一部分无序,我们在无序那部分找最小值,因为旋转是把大的旋转到前面来了,根据解答参考去思考;

Code7: 平均时间复杂度O(logn)  空间复杂度O(1)  

/**
 * @param {number[]} nums
 * @return {number}
 */
var findMin = function(nums) {
    if(nums.length==1)return nums[0];
    let left=0,right=nums.length-1,midIndex;
    if(nums[left]nums[midIndex])return nums[midIndex];
        if(nums[midIndex]>nums[midIndex+1])return nums[midIndex+1];
        if(nums[left]

2021.01.13

Question8:   在排序数组中查找元素的第一个和最后一个;给出目标值,查找目标值在数组中的开始位置和结束位置;题目

Answer8:   总共是分为两步:使用第三个模板求解 解答参考 

1.先用二分法查找target开始位置;
在判断查找区间向左还是向右之前,先判断中间位置是否符合要求,找target开始位置的时候,如果mid位置==target而且mid前一个位置又不等于target那mid自然就是它的起始位置了;然后再常规判断,mid位置>=target,那起始位置肯定在左边,所以呢向左查找,反之;

2.再用二分法查找target结束位置;
跟第一步的思想一致,先判断中间mid位置是不是结束位置,然后再常规判断向左还是向右查找;如果mid位置<=target那结束位置肯定在右边,向右查找;

Code8: 平均时间复杂度O(logn)  空间复杂度O(1)  

var searchRange = function(nums, target) {
    if (nums.length == 0) return [-1, -1];
    var startIndex = startPosition(nums, target);
    var endIndex = endPosition(nums, target);
    return [startIndex, endIndex];
}

var startPosition = function(nums, target) {
    if (nums[0] == target) return 0;
    var left = 0,
        right = nums.length - 1,
        mid;
    while (left + 1 < right) {
        mid = Math.floor(left + (right - left) / 2);
        if (nums[mid] == target && nums[mid - 1] != target) return mid;
        if (nums[mid] >= target) {
            //向左查找
            right = mid;
        } else {
            left = mid;
        }
    }
    if (nums[left] == target) return left;
    if (nums[right] == target) return right;
    return -1;
};
var endPosition = function(nums, target) {
    if (nums[nums.length - 1] == target) return nums.length - 1;
    var left = 0,
        right = nums.length - 1,
        mid;
    while (left + 1 < right) {
        mid = Math.floor(left + (right - left) / 2);
        if (nums[mid] == target && nums[mid + 1] != target) return mid;
        if (nums[mid] <= target) {
            //向右查找
            left = mid;
        } else {
            right = mid;
        }
    }
    if (nums[left] == target) return left;
    if (nums[right] == target) return right;
    return -1;
}

2021.01.14

Question9:   给定一个排好序的数组arr,两个整数k和x,从数组中找到最靠近x的k个数;返回的结果必须要是按升序排列的。题目

Answer9:   主要采用二分法的思想:综合前面的案例几个模板灵活运用,有自己的思想;不一定按照模板来;一定要自己分析;参考解答  自己题解

  • 确定二分查找的上下限,left=0,right=arr.length-k;
  • 首先是对x小于数组第一个元素或者大于最后一个元素的判断,这两种情况都比较好写,直接取前个或者后k个,因为数组本身就是有顺序的;
  • 这里只找开始位置,所以,mid位置<=mid+k位置的值时向左查找right=mid;mid位置>mid+k位置的值的时候向右查找,left=mid+1;

Code9:  平均时间复杂度O(log(n+k))  n应该是arr.length-k 那个while循坏次数  k是for循坏次数   O(1)

var findClosestElements = function(arr, k, x) {
    var start, j = 0,
        arrs = [];
    if (arr[0] >= x) {
        start = 0;
    } else if (arr[arr.length - 1] <= x) {
        start = arr.length - k
    } else {
        start = startIndex(arr, k, x);
    }
    console.log(start);
    for (var i = start; i < start + k; i++) {
        arrs[j++] = arr[i];
    }
    return arrs;
}
var startIndex = function(arr, k, x) {
    var left = 0,
        right = arr.length - k,
        mid, endIndex = arr.length - k;
    while (left < right) {
        mid = Math.floor(left + (right - left) / 2);
        endIndex = (mid + k) > arr.length - 1 ? arr.length - 1 : mid + k;
        if (Math.abs(arr[mid] - x) <= Math.abs(arr[endIndex] - x)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

Question10:  就是Qusestion6

Answer10:


2021.01.17

Question11:  实现pow(x,n)???  题目 

Answer11:  有两种方法,第一种是分治的思想,解答参考1 解答参考2

分治的思想,就是x可以分解如下:

前端-查找算法系列刷题笔记_第1张图片

第二种思想就是二分的思想:n用二进制表示,然后呢用这个二进制表示的n次方去实现x的n次方;

Code11: 分治思想的平均时间复杂度为O(logn)  空间复杂度为O(logn);  二分法思想平均时间复杂度为O(logn),空间复杂度为O(1);

//分治思想
var myPow = function(x, n) {
    //分治方法-递归方法
    if (n == 0) return 1;
    if (n == 1) return x;
    return n > 0 ? quickMul(x, n) : 1 / quickMul(x, -n);
}
var quickMul = function(x, n) {
    if (n == 0) return 1;
    var y = quickMul(x, n);
    if (n % 2 == 1) {
        y = y * y * x;
    } else {
        y = y * y;
    }
    return y;
}
//二分的思想
var myPow = function(x, n) {
        if (n == 0) return 1;
        if (n == 1) return x;
        return n > 0 ? binary(x, n) : 1 / binary(x, -n);
    }
var binary = function(x, n) {
    var result = 1,
        x_contribute = x;
    while (n > 0) {
        if (n % 2 != 0) {
            result = result * x_contribute;
        }
        x_contribute = x_contribute * x_contribute;
        n = Math.floor(n / 2);
    }
    return result;
}

Question12:  给定一个正整数num,编写一个函数,如果num是一个完全平方数返回true,否则返回false;???题目

Answer12: 平方根不会超过num/2,所以呢在1-num/2之间使用二分法查找;解答

Code12:平均时间复杂度O(logn)  n=num/2,空间复杂度O(1)

var isPerfectSquare = function(num) {
    // console.log(mySqrt(num));
    var mysqrt = mySqrt(num);
    if (mysqrt == -1) {
        return false;
    } else {
        return true;
    }
}
var mySqrt = function(num) {
    if (num < 0) return -1;
    if (num == 0) return 0;
    var left = 1,
        right = Math.floor(num / 2),
        mid;
    while (left < right) {
        mid = Math.floor(left + (right - left) / 2);
        if (mid * mid == num) return mid;
        if (num / mid < mid) {
            //向左侧查找
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    if (left * left == num) return left;
    return -1;
}

Question13:  寻找比目标字母大的最小字母???简单 题目

Answer13:  用二分法去做,属于简单类型的二分思想;

我用的第二种模板,left  解答

Code13:平均时间复杂度O(logn)  n为letters长度  空间复杂度O(1);

var nextGreatestLetter = function(letters, target) {
    var left = 0,
        right = letters.length - 1,
        midIndex;
    while (left < right) {
        midIndex = Math.floor(left + (right - left) / 2);
        if (letters[midIndex] <= target) {
            left = midIndex + 1;
        } else {
            right = midIndex;
        }
    }
    if (letters[left] > target) return letters[left];
    return letters[0];
}

2. 顺序查找

你可能感兴趣的:(前端笔记,javascript,前端)