经典算法题解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_55910050/article/details/127072248

二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function (nums, target) {
    let low = 0;
     const n = nums.length;
    let height = nums.length;
    let ans = n

    while (low <= height) {
        mid = parseInt((low + height) / 2)
    
        if (target <= nums[mid]) {
            ans = mid;
           height =mid-1
        } else if (target > nums[mid]) {
            low = mid + 1
        }
    }
    return ans;
};

第一个错误的版本

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

/**
 * Definition for isBadVersion()
 * 
 * @param {integer} version number
 * @return {boolean} whether the version is bad
 * isBadVersion = function(version) {
 *     ...
 * };
 */

/**
 * @param {function} isBadVersion()
 * @return {function}
 */
var solution = function(isBadVersion) {
    /**
     * @param {integer} n Total versions
     * @return {integer} The first bad version
     */
    return function(n) {
        let low=1;
       let height=n;
       let mid;
        while(low<=height){
            let mid=parseInt((low+height)/2)
            if(isBadVersion(mid)){
                 height=mid-1
            }else{
                 low=mid+1
            }
        
        }  
         return low
        
    };
};

搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var searchInsert = function(nums, target) {
    let low=0,height=nums.length-1,mid;
    while(low<=height){
        let mid=parseInt((low+height)/2)
        if(nums[mid]==target){
            return mid
        }else if(nums[mid]>target){
            height=mid-1
        }else if(nums[mid]<target){
            low=mid+1
        }
    
    }
        return low

};

双指针

有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
//js的高级函数解决
        return nums.map(v => v**2).sort((x, y) => x - y);
//        let newArr= nums.map(v => v**2)
//     //    console.log(newArr)
//        let i,j;
//        let isSwap=true
//        let len=newArr.length-1
//        for(i=0;i<len;i++){
//            isSwap=false;
//            for(j=len;j>i;j--){
//                if(newArr[j]<newArr[j-1]){
                   
//                    Swap(newArr[j],newArr[j-1])
//                    isSwap=true
//                }
//                if(!isSwap){
//                    return
//                }
//            }
//        }
//        console.log(newArr)
  

// };
//     function Swap(a,b){
//         let temp;
//         temp=a;
//         a=b;
//         b=temp
    }

轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    // return nums.reverse()
    let i=k%nums.length
    console.log(i)
    for(let j=0;j<i;j++){
        let num=nums.pop()
        nums.unshift(num)
    }
    return nums
    // newArr.reverse()
};

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function(nums) {
    let len=nums.length
    for(let i=len;i>=0;i--){ 
        if(nums[i]==0){
            nums.push(0)
            nums.splice(i,1)
     
        }
      
    }
};

两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按非递减顺序排列，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

/**
 * @param {number[]} numbers
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(numbers, target) {
    let i,j
    const len=numbers.length
    for(i=0;i<len;i++){
         for(j=i+1;j<len;j++){
             if(numbers[i]+numbers[j]===target){
                 return [i+1,j+1]
             }
         }
    }
};

反转字符串中的单词 III

给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序

/**
 * @param {string} s
 * @return {string}
 */
var reverseWords = function(s) {
 
    return s.split(" ").map(item=>{ // 字符串按空格进行分隔, 每一个单词作为数组一个值
       return item.split('').reverse().join("")  // 遍历数组, 将每个值进行 reverse()
         
    }).join(" ") // 拼接数组, 以空格分隔
   
   

};

最长连续递增序列

给定一个未经排序的整数数组，找到最长且连续递增的子序列，并返回该序列的长度。

连续递增的子序列可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

/**
 * @param {number[]} nums
 * @return {number}
 */
var findLengthOfLCIS = function(nums) {
    let maxNum=1
    let nowNum=1
    for(let i=0;i<nums.length;i++){
        if(nums[i]<nums[i+1]){
            nowNum++
            maxNum= Math.max(maxNum, nowNum)
        }else{
          nowNum=1
        }
       
    }
     return maxNum
};

无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

/**
 * @param {string} s
 * @return {number}
 */
 var lengthOfLongestSubstring = function(s) {
  let res = []
  let max = 0
//   遍历字符串
  for (let str of s) {
    //   判断res里面的值在没有再str中
//     [1, 2, 3].includes(2); // true
//      [1, 2, 3].includes(4); // false
    while (res.includes(str)) {
        // 如果res中的值存在str中就将第一个重复的值删除 shif（）删除数组中的第一个元素
      res.shift()
    }
    res.push(str)
    max = Math.max(max,res.length)
  }
  return max
};

存在重复元素

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

排序后再查重因为排序后他是相邻的

var containsDuplicate = function(nums) {
    //进行排序
        nums.sort();
    for(var i=0;i<nums.length;i++) {
        if(nums[i]==nums[i+1]){
            return true;
        }
    }
    return false

};

利用new set方法数组去重

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {

    //第二种数组去重set方法
    var containsDuplicate = function (nums) {
    return new Set(nums).size < nums.length;
};

};

只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function(nums) {
    nums = nums.sort((a, b) => {
        return a-b
    })
    for (let i = 0; i<nums.length;i+=2){
        if (nums[i] != nums[i+1]) {
            return nums[i]
        }
    }
};

两个数组的交集 II

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    let i=0,j=0
    let newArr=[]
    // 先进行排序
    nums1.sort((a,b)=>{
        return a-b
    })
     nums2.sort((a,b)=>{
        return a-b
    })
    console.log(nums1,nums2)
    while(i<nums1.length&&j<nums2.length){
        if(nums1[i]===nums2[j]){
            newArr.push(nums1[i])
            i++
            j++
        }else{
            nums1[i]>nums2[j]?j++:i++;
        }
    }
    return newArr
};

加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

/**
 * @param {number[]} digits
 * @return {number[]}
 */
//  首先对数组最后一位加一
// 循环遍历，从个位开始，即数组最后一位
// 如果它为10，将它变为0，它的上一个下标的数加一，以此类推
// 当进行到第一位时，如果它为10，同样将它变为0，只不过它没有上一个下标的数，这时候使用unshift()方法在头部插入一个数1

var plusOne = function(digits) {
    let i
    let len=digits.length
    digits[len-1]+=1
    for(i=digits.length-1;i>=0;i--){
        if(digits[i]==10){
            digits[i]=0
            if(i!=0){
                       digits[i-1]+=1
            }else{
           digits.unshift(1)
        }
     
        }
    }
    return digits
};