leetcode（刷题总结）

1. 字符串查找，字符串比较大小

比较的时候，从字符串左边开始，依次比较每个字符，直接出现差异、或者其中一个串结束为止。（ 比较ASCII码 ）

比如ABC与ACDE比较，第一个字符相同，继续比较第二个字符，由于第二个字符是后面一个串大，所以不再继续比较，结果就是后面个串大。

再如ABC与ABC123比较，比较三个字符后第一个串结束，所以就是后面一个串大

2. 求交集

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
  // 先排序 然后双指针
  var resultArr = []
  var nums1Sort = nums1.sort((a, b) => { return  a - b })
  var nums2Sort = nums2.sort((a, b) => { return a - b })
  // 双指针
  var nums1Point = 0
  var nums2Point = 0
  while (nums1Point < nums1Sort.length && nums2Point < nums2Sort.length) {
    // 如果指针值相等 存入
    if (nums1Sort[nums1Point] === nums2Sort[nums2Point]) {
      resultArr.push(nums1Sort[nums1Point])
      nums1Point++
      nums2Point++
    } else if (nums1Sort[nums1Point] < nums2Sort[nums2Point]) { // 不相等值小的指针向后移
      nums1Point++
    } else {
      nums2Point++
    }
  }
  return resultArr
};

还有一种解法，使用hashmap 记录其中一个数组每个元素出现的次数

再遍历另一个数组，map里存在就说明有，然后存入结果数组，hashmap 对应的值减一

var intersect = function(nums1, nums2) {
   var hashMap = {}
   var resultArr = []
   for (var i = 0; i < nums1.length; i++) {
     if (hashMap[nums1[i]]) { // 存在
        hashMap[nums1[i]]++
     } else {
       hashMap[nums1[i]] = 1 // 不存在
     }
   }
   for (var j = 0; j < nums2.length; j++) {
     if (hashMap[nums2[j]]) { // 存在
        resultArr.push(nums2[j])
        hashMap[nums2[j]]--
     }
   }
   return resultArr
};

3. while 退出循环 继续执行下面的代码 break

4. 旋转数组的套路：

左边的指针与中间元素比较，判断哪半部分是递增的

var search = function(nums, target) {
    var left = 0
    var right = nums.length - 1
    while (left <= right) {
      var mid = parseInt((left + right) / 2)
      if (nums[mid] === target) {
        return true
      }
      if (nums[left] === nums[mid]) { // 相等两侧 判断不出来哪端递增
          left++
      } else if (nums[left] > nums[mid]) { // 左侧大于中间的，说明后半部分是递增的
        // 然后判断要找的值是否在后半部分里面 是就去后半部分里面找
        if (nums[mid] <= target && nums[right] >= target) {
          left = mid + 1
        } else { // 不是去前半部分找
          right = mid - 1
        }
      } else { // 左指针的值小于中间值 说明前半段是递增的
          if (nums[left] <= target && nums[mid] >= target) {
            right = mid - 1
          } else {
            left = mid + 1
          }
      }
    }
    return false
};

5. 字符串修改其中的某个值，不能通过下标修改，基础数据类型（正则修改或者转成数组用下标修改）

6. 判断两个字符是否互为大小写

var test = function(a, b) {
      return (a.charCodeAt() !== b.charCodeAt()) && (a.toLowerCase() === b.toLowerCase())
};

两个字符的编码不相等，但是 他们同转为小写字母相等

7. 删除最外层括号

 

/**
 * @param {string} S
 * @return {string}
 */
var removeOuterParentheses = function(S) {
    var stack = []
    var count = 0
    for (var i = 0; i < S.length; i++) {
        if (S[i] === '(') {
            count ++
            // 根据数量判断
            if (count >= 2) {
                stack.push(S[i])
            }
        } else if (S[i] === ')') {
            count --
            // 根据数量判断
            if (count >= 1) {
                stack.push(S[i])
            }
        }
    }
    return stack.join('')
};