前端算法
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解法一
var twoSum = function (nums,target) {
for(let i =0;i<nums.length;i++){
for(let j = i+1;j<nums.length;j++){
if(nums[i] == target-nums[j]){
return [i,j]
}
}
}
}
解答思路
- 第一遍过滤 nums 数组，标记为 i。
- 第二遍再次过滤 nums 数组，标记为 i + 1，因为我们是对数组中的两个数字相加，所以不能重复使用同一个数字。
- 判断第二次遍历的数字中，它是否等于 target - nums[i]，如果成立就返回两个数字的索引。（并不考虑后面还有可成立的答案）。
解法二
var twoSum = function (nums,target) {
let map = new Map();
for(let i =0;i<nums.length;i++){
if(map.get(nums[i])){
return [map.get(nums[i]),i]
}
else{
map.set(target-nums[i],i)
}
}
}
解答思路
-
首先，我们需要了解 Map 这个对象。
-
它可以通过 set() 的形式，以 [key, value] 的形式保存一组数据。（题目中对应 key 就是存入的 target -
nums[i] 值，value 就是索引） 它可以通过 get() 的形式，获取到传入 key 值对应的 value。 它可以通过
has() 的形式，判断 Map 对象里面是否存储了传入 key 对应的 value。 然后，我们遍历 nums 数组。 -
最后，我们判断 nums[i] 是否存在于 Map 对象中。没有的话，就存入 target - nums[i] 到 Map
中。有的话，因为上次存入的是 target- nums[i]，有点类似于解题的钥匙，既然我们看到 nums[i] 存在于 Map中，它是解题的钥匙，所以我们只需要返回 [map.get(nums[i]), i] 这组值即可。
解法三
var twoSum = function (nums,target) {
for(let i =0;i<nums.length;i++){
if(nums.indexOf(target-nums[i])!=-1 && nums.indexOf(target-nums[i])!=i){
return [i,nums.indexOf(target-nums[i])]
}
}
}
整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123 输出: 321 示例 2:
输入: -123 输出: -321 示例 3:
输入: 120 输出: 21 注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 −
1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
解法一
var reverse = function (x) {
let numberToArray = String(Math.abs(x)).split('');
let result = '';
for (let i = 0; i < numberToArray.length; ) {
result += numberToArray.pop();
}
x<0?-Number(result):Number(result);
if(x > Math.pow(2,31)-1 || x < -Math.pow(2,31)){
result = 0;
}
return result;
}
解答思路
- 首先，将传入的数字 x 转换成字符串，并分割成数组。
- 然后，遍历该数组，将最后一个取出来放到 result 中。
- 最后，判断这个 result 是否超过题目限制，如果超过则变成 0 。
解法二
var reverse = function (x) {
let result = 0;
let y = Math.abs(x);
while(y!=0){
result = result * 10 + y % 10;
y = Math.floor(y/10);
if(result > Math.pow(2,31)-1 || result < -Math.pow(2,31) -1 ){
result = 0;
y = 0;
}
}
return x > 0 ? result : -result
}
回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:
你能不将整数转为字符串来解决这个问题吗？
解法一
var isPalindrome = function(x) {
var arr = String(x).split('');
for(let i = 0;i<arr.length/2;i++){
if(arr[i]!=arr[arr.length-i-1]){
return false;
}
}
return true;
}
解答思路
解法二
var isPalindrome = function(x) {
if(x < 0 || (x % 10 == 0 && x != 0)){
return false;
}
let reverseNumber = 0;
while(x > reverseNumber){
reverseNumber = reverseNumber * 10 + x % 10;
x = Math.floor(x/10);
}
return x === reverseNumber || Math.floor(reverseNumber / 10);
}
解答思路
- 首先，我们可以想象：当一个数的长度为偶数，那么它对折过来应该是相等的；当一个数的长度是奇数，那么它对折过来后，有一个的长度需要去掉一位数（除以
10 并取整），因为奇数长度的那个数，我们不需要判断它中间的数字。 - 我们定义传递过来的参数为：x，对折的数字为：z，而 y 为 x 目前的个位数。
- 然后，我们需要知道如何获取到一个数的个位数：y = x % 10，我们也需要知道如何将单个数字不断添加到一个数的末尾：z = z *
10 + y，例如：z = 1 * 10 + 2 = 12。 - 接着，我们只需要判断 x 是不是小于 z 了，毕竟当它小于的时候，说明数字已经对半或者过半了。
- 最后，我们判断一开始的两种情况，并返回 true 或者 false 即可。
最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
解法一
var longestCommonPrefix = function(strs) {
if(strs.length < 2){
return !strs.length ? '' : strs[0]
}
var result = strs[0];
for(let i = 0; i< result.length; i++){
for(let j = 1;j<strs.length; j++){
if(result[i] != strs[j][i]){
return result.substring(0, i)
}
}
}
return result;
};
var str = longestCommonPrefix(["flower","flow","flight"]);
console.log(str)
解法二
var longestCommonPrefix = function(strs) {
if(strs.length < 2){
return !strs.length ? '' : strs[0]
}
return strs.reduce((prev,next) => {
let i = 0;
while(prev[i] && next[i] && prev[i] === next[i] ){
i++;
}
return prev.slice(0,i);
})
};
var str = longestCommonPrefix(["flower","flow","flight"]);
console.log(str)
去重
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
解法一
var removeDuplicates = function(nums) {
for(let i = 0; i < nums.length; i++){
if(nums[i] == nums[i+1]){
nums.splice(i,1);
i--;
}
}
return nums.length;
}
解法二
var removeDuplicates = function(nums) {
var a = [...new Set(nums)];
for(var i = 0; i < a.length; i++) nums[i] = a[i];
return a.length;
}
有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true
var isValid = function(s) {
let judge = {
'(':')',
'{':'}',
'[':']'
}
var params = s.split('');
var stack = [];
for(let i = 0; i < params.length; i++){
if(judge[stack[stack.length - 1]] == params[i]){
stack.pop()
}
else{
stack.push(params[i]);
}
}
if(stack.length == 0){
return true;
}
return false;
}
最大子串
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:
如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。
解法一
var maxSubArray = function(nums) {
let max = nums[0];
let val = 0;
for(let i = 0; i < nums.length; i++){
val+=nums[i];
max = val > max ? val : max;
val = 0 > val ? 0 : val;
}
return max;
}
寻找比目标字母大的最小字母
给定一个只包含小写字母的有序数组 letters，
和一个目标字母 target，
寻找有序数组里面比目标字母大的最小字母。
数组里字母的顺序是循环的。
举个例子，如果目标字母 target = ‘z’，
并且有序数组为 letters = [‘a’, ‘b’]，
则答案返回 ‘a’。
示例:
输入:
letters = [“c”, “f”, “j”]
target = “a”
输出: “c”
输入:
letters = [“c”, “f”, “j”]
target = “c”
输出: “f”
输入:
letters = [“c”, “f”, “j”]
target = “d”
输出: “f”
输入:
letters = [“c”, “f”, “j”]
target = “g”
输出: “j”
输入:
letters = [“c”, “f”, “j”]
target = “j”
输出: “c”
输入:
letters = [“c”, “f”, “j”]
target = “k”
输出: “c”
注:
letters长度范围在[2, 10000]区间内。
letters 仅由小写字母组成，最少包含两个不同的字母。
目标字母target 是一个小写字母。
解法一
/**
* @name 寻找比目标字母大的最小字母
* @param {character[]} letters
* @param {character} target
* @return {character}
*/
const nextGreatestLetter = (letters, target) => {
// 处理数组中的情况
for(let i = 0; i < letters.length; i++){
if(letters[i] <= target && letters[i+1] > target){
return letters[i+1];
}
}
if(letters[0] > target){
return letters[0];
}
if(letters[letters.length - 1] >= target){
return letters[0];
}
if(letters.length > 1 && letters[0] == target){
return letters[1];
}
}
console.log(nextGreatestLetter(['c', 'f', 'j'], 'a')); // 'c'
解法二
const nextGreatestLetter = (letters, target) => {
for (let i = 0; i < letters.length; i++) {
if (letters[i] > target) {
return letters[i];
}
}
return letters[0];
};
解法三
const nextGreatestLetter = (letters, target) => {
var left = 0;
var right = letters.length;
while(left < right){
let middle = Math.floor((left + right) /2);
if(letters[middle] <= left){
left = middle + 1;
}
else{
right = middle;
}
}
return letters[left % letters.length]
}