leetcode刷题记录(19)-中等

1.基本计算器II

题目：

实现一个基本的计算器来计算一个简单的字符串表达式的值。

字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格  。 整数除法仅保留整数部分。

思路：先遍历字符串，用符号将数字分割，得到一个数字+符号的数组。然后两次遍历数组进行计算，第一次遍历计算乘法和除法，第二次遍历计算加法和减法，，用一个栈保存计算过的字符，最后栈内只有一个元素，就是最终的结果

时间复杂度：O(n)，空间复杂度O(n)

/**
 * @param {string} s
 * @return {number}
 */
var calculate = function(s) {
  const va = ["+", "-", "*", "/"];
  const res = [];
  let temp = "";
  for (const n of s) {
    if (va.includes(n)) {
      res.push(temp);
      res.push(n);
      temp = "";
    } else {
      temp += n;
    }
  }
  if (temp) {
    res.push(temp);
  }
  const list = [];
  for (let i = 0, l = res.length; i < l; i++) {
    if (res[i] == "*" || res[i] == "/") {
      const pre = list.pop();
      if (res[i] == "*") {
        list.push(pre * res[i + 1]);
      } else {
        list.push(~~(pre / res[i + 1]));
      }
      i++;
    } else {
      list.push(res[i]);
    }
  }
  let v = +list[0];
  for (let i = 1; i < list.length; i++) {
    if (list[i] == "+") {
      v += +list[i + 1];
      i++;
    } else if (list[i] == "-") {
      v -= list[i + 1];
      i++;
    }
  }
  return v;
};

2.汇总区间

题目：给定一个无重复元素的有序整数数组，返回数组区间范围的汇总。

思路：用数组保存结果，一个变量记录当前的起始数字，一个变量记录结束数字，如果一个数和上一个数的差为1，那么结束变量更新；如果差不为1，就将起始数字和结束数字组合，并初始化变量

时间复杂度：O(n)，空间复杂度O(n)

/**
 * @param {number[]} nums
 * @return {string[]}
 */
var summaryRanges = function(nums) {
  let res = [];
  const l = nums.length;
  if(!l)return res
  let start = nums[0];
  let end = start;
  for (let i = 1; i < l; i++) {
    if (nums[i] - nums[i - 1] == 1) {
      end = nums[i];
    } else {
      if (start == end) {
        res.push(`${start}`);
      } else {
        res.push(`${start}->${end}`);
      }
      start = end = nums[i];
    }
  }
  if (start == end) {
    res.push(`${start}`);
  } else {
    res.push(`${start}->${end}`);
  }
  return res;
};

3.求众数II

题目：

给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。

说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

思路：和之前的投票算法类似，不过现在变成了n/3，且不一定有符合条件的结果。

类似之前的投票算法，因为结果最多为两个，用两个变量记录可能的数字，两个变量记录对应出现的次数。如果一个数等于其中一个，那么这个数字的数量+1，如果都不等于，那么两个数量都-1。如果两个数量都等于0，那么将下个数字记录为可能的结果。最后，为了校验最后的数字是否只是在最后而非出现次数最多，重新遍历数字计算次数。

时间复杂度O(n)，空间复杂度O(1)

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var majorityElement = function(nums) {
  const l = nums.length;
  if (l < 3) return [...new Set(nums)];
  let a = nums[0],
    av = 1;
  let b,
    bv = 0;
  let index;
  for (let i = 1; i < l; i++) {
    if (nums[i] !== a) {
      b = nums[i];
      bv = 1;
      index = i + 1;
      break;
    } else {
      av++;
    }
  }
    if (!bv) return [a];
  for (let i = index; i< l; i++) {
    if (av && bv) {
      if (nums[i] == a) {
        av++;
      } else if (nums[i] == b) {
        bv++;
      } else {
        av--;
        bv--;
      }
    }  else if (!av) {
      if (nums[i] == b) {
        bv++;
      } else {
        a = nums[i];
        av = 1;
      }
    } else {
      if (nums[i] == a) {
        av++;
      } else {
        b = nums[i];
        bv = 1;
      }
    }
  }
  let ac = 0;
  let bc = 0;
  for (const n of nums) {
    if (n == a) ac++;
    if (n == b) bc++;
  }
  if (ac > l / 3 && bc > l / 3) return [a, b];
  if (ac > l / 3) return [a];
  if (bc > l / 3) return [b];
  return [];
};

.4.二叉搜索树中第K小的数

题目：

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

思路：可以中序遍历，将节点存储在数组里，然后用下标获取。

时间复杂度O(n)，空间复杂度O(n)。n为二叉树的总结点数量

/**
 * 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
 * @param {number} k
 * @return {number}
 */
var kthSmallest = function(root, k) {
      const res = [];
  const search = (root) => {
    if (!root) return;
    search(root.left);
    res.push(root.val);
    search(root.right);
  };
  search(root);
  return res[k - 1];
};

也可以用中序遍历的方式，记录遍历过的节点数量，第K个即为结果。

时间复杂度O(n)，空间复杂度O(1)
 

/**
 * 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
 * @param {number} k
 * @return {number}
 */
var kthSmallest = function(root, k) {
  let v = 0;
  let res;
  const search = (root) => {
    if (v == k) return;
    if (!root) return;
    search(root.left);
    v++;
    if (v == k) {
      res = root.val;
      return
    }
    search(root.right);
  };
  search(root)
  return res;
};

5.二叉树的最近公共祖先

题目：

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

题目：可以记录每个节点的遍历顺序，用字符串记录，然后比较p、q两个字符串，找到最后出现的公共字符，这个字符就是最近公共祖先的节点值。然后遍历二叉树，得到结果

时间复杂度：O(n)，空间复杂度O(1)

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
  let ps = "";
  let qs = "";
  const search = (root, s = "") => {
    if (ps && qs) return;
    if (!root) return;
    s += "." + root.val;
    if (root == p) {
      ps = s;
    } else if (root == q) {
      qs = s;
    }
    search(root.left, s);
    search(root.right, s);
  };
  search(root);
  ps = ps.split(".");
  qs = qs.split(".");

  let vn;
  const l = ps.length;
  for (let i = l - 1; i >= 0; i--) {
    if (qs.includes(ps[i])) {
      vn = ps[i];
      break
    }
  }
  const search2 = (root) => {
    if (!root) return false;
    if (root.val == vn) return root;
    return search2(root.left) || search2(root.right);
  };
  return search2(root);
};

也可以递归处理。如果某个节点，左子树有p或者q，右子树也有p或者q,返回该节点。如果只有左节点有p或者q，返回左节点，右节点有p或者q，返回右节点，否则返回null

时间复杂度O(h)，空间复杂度O(1),h是树的高度

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
  if (root == null || root == p || root == q) {
    return root;
  }
  let left = lowestCommonAncestor(root.left, p, q);
  let right = lowestCommonAncestor(root.right, p, q);
  if (left && right) {
    return root;
  } else if (left) {
    return left;
  } else {
    return right;
  }
};