LeetCode做题记录

1.给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

// var twoSum = function(nums, target) {
//     var result=[];
//     for(var i=0;i<nums.length-1;i++){
//         for(var j=i+1;j<nums.length;j++){
//             if(nums[i]+nums[j]==target){
//                 result.push(i);
//                 result.push(j);
//                 return result;
//             }
//         }   
//     }
//     return false;
// };

var twoSum = function(nums, target) {
    const hash = {};
    for (let n, i = 0, l = nums.length; i < l; ++i) {
        n = nums[i];
        
        if (hash[n] >= 0) {
            return [hash[n], i]
        }
        hash[target - n] = i
    }
};
var testCase = [2, 7, 11, 15];
var result = twoSum(testCase, 9);

console.log(result.toString() === '1,2'); 

一开始就直接用了两个循环，后面百度发现很多人都是用hash，才意识到时间复杂度，对于菜鸡的我第一次意识到数据结构的用处........

7.给定一个 32 位有符号整数，将整数中的数字进行反转。

示例 1:
输入: 123
输出: 321
 示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231,  231 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。

var reverse = function(x) {
   var resultArr = [];
   var str = x.toString();
   for(var i = str.length-1;i > 0;i--){
       resultArr.push(str[i]);
   }
   if(str[0] == "-"){
       resultArr.unshift("-");
   }else{
      resultArr.push(str[0]); 
   }
   
   var resultNum = parseInt(resultArr.join(""));
   if(resultNum <= Math.pow(-2,31) || resultNum >= Math.pow(2,31) - 1 ){
       return 0;
   }
   return resultNum;
};

思路：

1.整数是不能进行反转的，所以一开始要把输入的整数转化成字符串

2.然后从后往前把数据插入数组中

3.如果有符号就把符号固定到最前面

4.再把输出的字符串转化为数字

5.如果超出规定就false，符号就直接输出

 

更新第七题

var reverse = function(x) {
    let result = 0;
    while(x) {
        result = result * 10 + x % 10 ;
        x = ~~(x / 10);
    }
    if(result <= Math.pow(-2,31) || result >= Math.pow(2,31) - 1 ){
       return 0;
    }
    
    return result;
};

整数也是可以直接弄的

两种方法用时差别

第一种：

第二种：

9.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

var isPalindrome = function(x) {
        if(x<0){return false;}
    let result = 0;
    let y = x;                       
    while(x) {
        result = result * 10 + x % 10 ;
        x = ~~(x / 10);
    }
   return y == result;
   
};

就是上一个题的第二种解法

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。

说明:

所有输入只包含小写字母 a-z 

var longestCommonPrefix = function(strs) {
    let result ='';
    if(!strs.length){
       return result;
   }
    let x = strs[0];
    for(let i = 0; i < x.length; i++){
        for(let j = 1;j < strs.length; j++){
            if(x[i] != strs[j][i] )
                return result;
        }
        result += x[i];
    }
    return result;
};

思路：

• 如果字符串数组为空，我们就直接返回一个空字符串。
• 如果字符串数组只有一项，如["java"]，那么就直接返回该字符串即可。
• 如果字符串数组有多项，我们可以先取得第一项，然后再依次将第一项字符串的每个字符与后面每一个字符串的相应位置的字符进行比较；如果有不同，就不再进行后续判断，而是直接返回结果即可；如果在这一轮迭代中相应位置的字符相同，则记录下来。

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1:

输入: "()"
输出: true

示例 2:

输入: "()[]{}"
输出: true

示例 3:

输入: "(]"
输出: false

示例 4:

输入: "([)]"
输出: false

示例 5:

输入: "{[]}"
输出: true

var isValid = function(s) {
    let right = [];
    for (let i = 0; i < s.length; i++){
         if (s[i] == '('){
             right.push(')');
         }else if(s[i] == '['){
             right.push(']');
         }else if(s[i] == '{'){
             right.push('}');
         }else if(right.pop() != s[i]){
             return false;
         }
        }
    return !right.length;
};

思路：

运用栈存储的特点，先进后出，后进先出

先创建一个数组来存储右括号，然后判断输入的字符是不是左括号，如果是左括号就把相应的右括号，压进（push）数组里，

如果输入的字符不是左括号，就把数组里存储的右括号pop出来，与输入的字符相对比，如果一样，则true，否则反之。