(算法)LeetCode刷题

LeetCode 56 合并区别

Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

关键就是a[1]>=b[0] 也就是array[i-1][1]>=array[i][0]

const merge = array => {
  array.sort((a, b) => a[0] - b[0])
  for (let i = 1; i < array.length; i++) {
    let minLeft = Math.min(array[i - 1][0], array[i][0]);
    let maxRight = Math.max(array[i - 1][1], array[i][1]);
    if (array[i - 1][1] >= array[i][0]) {
      array[i - 1] = [minLeft, maxRight]
      array.splice(i, 1)
      i--
    }
  }
  return array
}
console.log(merge([[1, 3], [8, 10], [2, 6], [15, 18]]))
//[ [ 1, 6 ], [ 8, 10 ], [ 15, 18 ] ]

Leetcode 459 判断重复的子串

str.length % s.length

const repeated = s => {
    for (let i = 1; i < s.length; i++) {
        //从第一个字符串开始
        let str = s.slice(0, i)
        //他的上限就是两个数相等
      //    if (str.length % s.length) {
         if (!(str.length == s.length)) {
            let emptyStr = ''
            let repeatNum = s.length / str.length
            //算重复的字符,然后判断相等
            for (let j = 0; j < repeatNum; j++) {
                emptyStr += str
            }
            if (emptyStr == s) {
                return true
            }
        }
    }
    return false
}

console.log(repeated('abab'))

走楼梯

//走楼梯 小孩最多走1,2,3个,问总楼梯数n,有多少种走法
Dp f(x,y)=f(x,y-1)+f(x-1,y)
const recursion = n => {
  if (n < 0) return 0
  if (n == 0 || n == 1) return 1
  if (n == 2) return 2
  return recursion(n-1)+recursion(n-2)+recursion(n-3)
}
console.log(recursion(3))  //4

机器人走格子

//f(x,y)=f(x-1,y)+f(x,y-1)
const solve = (x, y) => {
  if (x == 1 || y == 1) return 1
  return solve(x - 1, y) + solve(x, y - 1)
}
console.log(solve(2, 3))

606

题目
[1,2,3,4]
        1
   2        3
4
"1(2(4))(3()())"  两个括号在一起就可以省略
"1(2(4))(3)"

[1,2,3,null,4]
        1
    2       3
       4
"1(2()(4))(3)"

let tree={
  val:1,
  left:{
    val:2,
    left:{
      val:3
    },
    right:{
      val:4
    }
  },
  right:{
    val:5,
    right:{
      val:6
    }
  }
}

const tree2str = t => {
  if (t == null) {
    return ''
  }
  if (t.left == null && t.right == null) {
    return t.val + ''
  }
  if (t.left == null) {
    return t.val + '()' + '(' + tree2str(t.right) + ')'
  }
  if (t.right == null) {
    return t.val + '(' + tree2str(t.left) + ')'
  }
  return t.val + '(' + tree2str(t.left) + ')' + '(' + tree2str(t.right) + ')'
}
console.log(tree2str(tree))

合法括号

n      组合
1       ()
2       ()()      (())
3       ()()()  (()())    ((()))

const printPar = (l, r,s='', result=[]) => {
  if (l == 0 && r == 0) {
    return result.push(s)
  }
  if (l > 0) {
    printPar(l-1,r,s+'(',result)
  }
  if (r > 0 && l < r) {
    printPar(l,r-1,s+')',result)
  }
  return result
}
console.log(printPar(3, 3))

3

// 'abcab'  =>  'abc'
// 'abcabc' =>   'abc'
// 'abcdababab'  =>'abcd'
//计数排序
const solution = (s) => {
  if (s == null || s.length == 0) {
    return 0
  }
  let hash = Array.from({length:256},v=>0);
  let begin = 0,
    end = 0;
  let repeat = 0,
    res = 0;
  while (end < s.length) {
    //a++>0   先执行>再执行后++
    //第一个判断是把重复的放到数组中,repeat是计算重复了多少次
    if (hash[s.charCodeAt(end++)]++ > 0) {
      //s.charCodeAt(end) 查找这个数的索引   放在数组中+1
      //end++   repeat++是计算重复的次数
      repeat++
    }
    while (repeat > 0) {
      //这个是把重复的次数减去
      if (hash[s.charCodeAt(begin++)]-- > 1) {
        repeat--
      }
    }
    //总次数减去不重复的   5-2=3
    res = Math.max(res, end - begin)
  }
  console.log(hash)
  return res
}
console.log(solution('abcab'))

669

输入: 
    1
   / \
  0   2

  L = 1
  R = 2

输出: 
    1
      \
       2

输入: 
    3
   / \
  0   4
   \
    2
   /
  1

  L = 1
  R = 3
输出: 
      3
     / 
   2   
  /
 1
二叉搜索树,进行范围限制

const trimBST = (root, l, r) => {
  if (root == null) {
    return null
  }
  if (root.val < l) {
    return trimBST(root.right, l, r)
  }
  if (root.val > r) {
    return trimBST(root.left, l, r)
  }
  root.left = trimBST(root.left, l, r)
  root.right = trimBST(root.right, l, r)
  return root
}

11盛最多水的容器

//双指针
const maxArea = height => {
  let left = 0,
    right = height.length - 1,
    maxVal = 0;
  while (left < right) {
    let contain = (right - left) * Math.min(height[left], height[right])
    maxVal = Math.max(contain, maxVal)
    if (height[left] >= height[right]) {
      right--
    } else {
      left++
    }
  }
  return maxVal
}
console.log(maxArea([1, 2, 3, 4, 5, 5, 1, 2, 3, 4]))

20 合法括号

()    //true
()[]{}  //true
{[]}   //true
逻辑

使用栈遍历输入字符串
如果当前字符串为左括号时,则将压入栈中
如果遇到右括号时:
* 如果栈不为空且为对应的左半括号,则取出栈顶元素,继续循环
* 若此时栈为空,则直接返回false
* 若不为对应的左半括号,直接返回false

const isValid = s => {
  let valid = true;
  const stack = [];
  const mapper = {
    '{': '}',
    '[': ']',
    '(': ')'
  };
  for (let i in s) {
    if (['(', '[', '{'].indexOf(s[i]) > -1) {
      stack.push(s[i])
    } else {
        //stack.pop出栈后,比较是否有反括号
      if (s[i] !== mapper[stack.pop()]) {
        return false
      }
    }
  }
  if(stack.length>0) return false
  return valid
}
console.log(isValid('()'))

26 从排序数组中删除重复项

思路

使用快慢指针来记录遍历的坐标

• 开始时这两个指针都指向第一个数字
• 如果两个指针指的数字相同,则块指针向前走一步
• 如果不同,则两个指针都向前
• 当快指针走完整个数组后,慢指针当前的坐标+1就是数组中不同数字的个数

const removeDuplicates = nums => {
let slow = 0;
for (let i = 0; i < nums.length; i++) {
 if (nums[i] !== nums[slow]) {
   slow++
   nums[slow] = nums[i]
 }
}
return slow+1
}
console.log(removeDuplicates([1, 2,3,4,4,4,4,4,5,6,7,8]))

88 合并两个有序数组

const merge = (num1, num2) => {
  let ret = [];
  while (num1.length || num2.length) {
    if (num1.length == 0) {
      ret.push(num2.shift())
      continue
    }
    if (num2.length == 0) {
      ret.push(num1.shift())
      continue
    }
    if (num1[0] >= num2[0]) {
      ret.push(num2.shift())
    } else {
      ret.push(num1.shift())
    }
  }
  return ret
}

简洁版
const merge = (nums1, m, nums2, n) => {
  let i1 = m - 1,
    i2 = n - 1,
    k = m + n - 1;
  while (i1 >= 0 && i2 >= 0) {
    if (nums1[i1] < nums2[i2]) {
      nums1[k--] = nums2[i2--]
    } else {
      nums1[k--] = nums1[i1--]
    }
  }
  while (i2 >= 0) {
    nums1[k--] = nums[i2--]
  }
  return nums1
}

104二叉树的最大深度

const maxDepth=root=>{
    if(!root) return 0
    if(!root.left&&!root.right) return 1
    return 1+Math.max(maxDepth(root.left),maxDepth(root.right))
}