前端算法题汇总一

因为最近听去面试的朋友说,前端面试有问到算法题.发现自己之前完全没关注过着方面的知识,所以打算每天看一两道积累一下

我的题都是在力扣上看的https://leetcode-cn.com/  这里面大多是Java,Python多,,这里把自己看的一些题记录一下

ps: 题目力扣上都可以搜到,里面也有很多题解,我这里写的解题只是我个人的解法,有的不完善,只是一个思路

1.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

/**
 * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
  你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
//  var twoSum = function(nums, target) {
//   var a = [0]
//   nums.some((item, i) => {
//       if(nums.lastIndexOf(target - item) > i){
//           a = [i, nums.lastIndexOf(target - item)]
//           return true
//       }
//   })
//   return a.sort()
// };

// 其他解法
// var twoSum = function(nums, target) {
//   let len = nums.length;
//   // 创建 MAP
//   const MAP = new Map();
//   // 由于第一个元素在它之前一定没有元素与之匹配，所以先存入哈希表
//   MAP.set(nums[0], 0);
//   for (let i = 1; i < len; i++) {
//       // 提取共用
//       let other = target - nums[i];
//       // 判断是否符合条件，返回对应的下标
//       if (MAP.get(other) !== undefined) return [MAP.get(other), i];
//       // 不符合的存入hash表
//       MAP.set(nums[i], i)
//   }
// }

// console.log(twoSum([3,3,6], 6))

2.给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

/**
 * 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

 * @param {number[]} num
 * @return {number[][]}
 */
var threeSum = function(num) {
  const nums = num.sort((a,b)=>{return a - b})
  let result = []
  let str = []
  const length = nums.length
  for (let i = 0; i < length-2; i++) {
    if (i > 0 && nums[i] === nums[i-1]) continue // 如果重复数据
    const a = nums[i]
    for (let j = i+1; j < length-1; j++) {
      if (j > i+1 && nums[j] === nums[j-1]) continue // 如果重复数据
      const b = nums[j]
      // console.log(str, `${a}${b}`, str.includes(`${a}${b}`))
      if (!nums.includes(-(a + b)) || str.includes(`${a}${b}`)) continue // 不存在和重复队列
      for (let z = j+1; z < length; z++) {
        if (z > j+1 && nums[z] === nums[z-1]) continue // 如果重复数据
        const c = nums[z]
        // console.log(a,b,c)
        if (a + b + c === 0) {
          str.push(`${a}${b}`)
          result.push([a,b,c])
          break // 不能重复
        }
        
      }
      
    }
    
  }
  return result
}

console.log(threeSum([3,0,-6,-1,6,-5,-2, 0, 0,-3])) // [-6,-5,-3,-2,-1,0,0,3,6]

3.删除数组中重复数据

/**
 * 删除数组中重复数据
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
  nums.some((item,i)=>{
    if (nums.indexOf(item) !== i) {
      nums.splice(i, 1, 's')
    }
  })
  return nums.filter(item => item!=='s')
};

console.log(removeDuplicates([0,0,-1,4,-1,4,5,7,7,8]))

4.给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]

/**
 * 给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
 如果数组中不存在目标值 target，返回 [-1, -1]
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
 var searchRange = function(nums, target) {
  if (!nums.length && !nums.includes(target)) return [-1, -1]
  return [nums.indexOf(target), nums.lastIndexOf(target)]
};

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

你可以假设数组中无重复元素

/**
 * 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
  你可以假设数组中无重复元素
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
 var searchInsert = function(nums, target) {
  if (nums.indexOf(target) > -1) {
    return nums.indexOf(target)
  }
  if (target > nums[nums.length-1]) {
    return nums.length
  }
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] > target) return i
  }
};

console.log(searchInsert([1,2,4,6,7], 8))