leetcode刷题记录(2)

1.最长公共前缀

题目：

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

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

思路：以第一个字符串为基准，如果，从第一个字符开始依次和其他成员比较，如果通过则拼接，不通过直接返回当前的结果

var longestCommonPrefix = function(strs) {
  const s1 = strs[0];
  if (!s1) return "";
  const l1 = s1.length,
    l2 = strs.length;
  if (l2 < 2) return s1;
  let res = "";
  for (let i = 0; i < l1; i++) {
    for (let j = l2 - 1; j; j--) {
      if (s1[i] !== strs[j][i]) {
        return res;
      }
    }
    res += s1[i];
  }
  return res
};

问题：每次拼接没有必要，

优化思路：只需要记录下标即可，最后直接用下标截取

  var s1 = strs[0],
    l = strs.length;
  if (!s1) return "";
  if (l < 2) return s1;
  var l1 = s1.length,
    i = 0,
    j,m;
  while (i < l1) {
    j = l - 1;
    m=s1[i]
    while (j) {
      if (m !== strs[j][i]) {
        return s1.substr(0, i);
      }
      j--;
    }
    i++;
  }
  return s1;

2.有效的括号

题目：

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

思路：遍历字符串，区分(、[、{三种情况，找到对应的右边字符的位置，注意嵌套的情况，所以用个计数器来记录相同字符的次数。然后切割当前成对字符中间的字符以及剩余字符，做一个递归处理。如果先遇到右边的字符直接返回false

var isValid = function(s) {
  var l = s.length;
  if (!l) return true;
  if (l % 2) return false;
  var m,
    i = 0;
  var f = (q, v) => {
    var c = 0;
    for (let j = 1; j < l; j++) {
      if (s[j] === v && !c) return j;
      if (s[j] === q) c++;
      if (s[j] === v) c--;
    }
    return false;
  };
  switch (s[0]) {
    case "(":
      m = f("(", ")");
      if (!m || !(m % 2)) return false;
      return isValid(s.slice(1, m)) && isValid(s.slice(m + 1));
    case "{":
      m = f("{", "}");
      if (!m || !(m % 2)) return false;
      return isValid(s.slice(1, m)) && isValid(s.slice(m + 1));
    case "[":
      m = f("[", "]");
      if (!m || !(m % 2)) return false;
      return isValid(s.slice(1, m)) && isValid(s.slice(m + 1));
    default:
      return false;
  }
};

问题：回溯太多，递归次数太多，每个字符都在遍历，并且可能会遍历好几次

优化方向：匹配过程就是相邻匹配，且内部优先。只有知道右边的字符，才能匹配相邻的字符，所以先把左边的字符放进栈里，然后遇到右边的字符，就取最近的一个字符，如果匹配成功则继续往下遍历，否则直接返回false

var isValid = function(s) {
  var l = s.length;
  if (l % 2) return false;
  var a = [],
    item,
    v;
  for (let i = 0; i < l; i++) {
    item = s[i];
    if (item === "(" || item === "[" || item === "{") {
      a.push(item);
    } else {
      if (!a.length) return false;
      v = a.pop();
      if (
        (item === ")" && v !== "(") ||
        (item === "]" && v !== "[") ||
        (item === "}" && v !== "{")
      ) {
        return false;
      }
    }
  }
  return !a.length;

};

3.合并两个有序链表

题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

思路：这个和归并排序的最后一步很像，可以分递归和循环两种方式处理

递归：

递归的思路，就是每次都找到当前的节点，然后将next指向调用剩下两个链表的结果，最终递归处理得到最终的结果

var mergeTwoLists = function(l1, l2) {
  if (!l1 || !l2) {
    return l1 || l2;
  }
  if (l1.val > l2.val) {
    l2.next = mergeTwoLists(l1, l2.next);
    return l2;
  } else {
    l1.next = mergeTwoLists(l1.next, l2);
    return l1;
  }
};

循环：

循环：

循环的思路，是找到每次比较的当前节点，然后用一个变量记录最终的结果，一个变量记录上一次比较的结果，这样在下次得到结果之后把上一次的结果的next指向当前的结果。最后将剩下的节点加入到最后

var mergeTwoLists = function(l1, l2) {
  if (!l1 || !l2) {
    return l1 || l2;
  }
  var res, s;
  while (l1 && l2) {
    if (l1.val > l2.val) {
      s = s || res;
      if (s) {
        s.next = l2;
        s = s.next;
      }
      res = res || l2;
      l2 = l2.next;
    } else {
      s = s || res;
      if (s) {
        s.next = l1;
        s = s.next;
      }
      res = res || l1;
      l1 = l1.next;
    }
  }
  if (s) {
    s.next = l1 || l2;
  } else {
    res.next = l1 || l2;
  }
  return res;
};

4.删除排序数组中的重复项

题目：

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

思路：用双指针的方式，第一个指针就是当前不重复元素的下标，第二个指针是此轮遍历元素的下标，单次遍历，从第二项开始，两个指针上的值比较，如果相等，就进入下一轮循环，如果不相等，就把当前项的值赋值给第一个指针的下一个元素，同时第一个指针加一，进入下一轮循环。

var removeDuplicates = function(nums) {
  var l = nums.length;
  if (l < 2) return l;
  var temp,
    res = 0;
  for (var i = 1; i < l; i++) {
    if (nums[res] !== nums[i]) {
      temp = nums[i];
      nums[i] = nums[res + 1];
      nums[res + 1] = temp;
      res++;
    }
  }
  return res + 1;
};