leetcode(js)

1.两数之和

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    let arr = new Map()
    for(let i=0;i<nums.length;i++){
        let x = target - nums[i]
        if(!arr.has(nums[i])){
            arr.set(x,i)
        }else{
            return [arr.get(nums[i]),i]
        }
    }
};

map的用法，map.has(key),map.set(key,value),map.get(key)
这题先建立一个map，每次迭代前先判断map中是否含有当前元素num[i],例如第一次判断map中是否有key为2
没有就把7-0传入map，map现在就有(7:0,)，当第二次判断map中是否有7,有，则返回（0,1）

var m = new Map([[‘Michael’, 95], [‘Bob’, 75], [‘Tracy’, 85]]);
由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉

Set和Map类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在Set中，没有重复的key。

对象的成员可以是任意类型

括号匹配

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    let stack = []
    for(let i;i<s.length;i++){
        if(s[i]=='{'||s[i]=='['||s[i]=='('){
            stack.push(s[i])
        }else if(
            (s[i]=='}'&&stack.length-1=='{')||
            (s[i]==']'&&stack.length-1=='[')||
            (s[i]==')'&&stack.length-1=='(')
        ){
            stack.pop()
        }else{
            return false
        }
    }return stack.length==0
};

思路：用一个栈，碰见{[(就往栈里面放，碰见}])就让它与栈中的最后一位进行匹配，直到遍历完s数组后，判断是否栈为空，如果为空，则就是正确的括号匹配，如果不为空，则说明还有括号未完成匹配

爬楼梯.70

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    if(n<=2)return n
    let arr = []
    arr[1] =1
    arr[2] =2
    for(let i=3;i<=n;i++){
        arr[i] = arr[i-1]+arr[i-2]
    }
    return arr[n]
};

94.二叉树中序遍历

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var inorderTraversal = function(root) {
    let stack = []
    let arr = []
    while(root||stack.length){
        if(root){
            stack.push(root)
            root = root.left
        }else{
            root = stack.pop()
            arr.push(root.val)
            root = root.right
        }
    }
    return arr
};

二叉树的思想就是不能走常规，if判断左节点一直到左最深，else则是把root变成右节点，再往左节点if往下遍历，

最长回文子串

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {
    function expand (s,l,r){
        // 这个l,r 相当于求一个中间值，拿到两边的看是否相等
        while(l >=0 && r < s.length && s[l] == s[r]){
            l--;
            r++;
        }
        return s.substring(l+1, r)
    }
    let res = ''
    for(let i = 0; i < s.length; i++){
        let s1 = expand(s, i ,i)
        let s2 = expand(s, i , i + 1)
        res = s1.length > res.length ? s1 : res
        res = s2.length > res.length ? s2 : res
    }
    return res
};