day1打卡

1. day1打卡
   1. 数组基础
      1. 数组是存放在连续内存空间上的相同类型数据的集合。
      2. 通过下标访问，适合读写，不适合插入和删除。
   2. 二分查找
      1. 升序数组，无重复
      2. 根据定义区间的两种不同写法：

      /**
       * @param {number[]} nums
       * @param {number} target
       * @return {number}
       */
      var search = function(nums, target) {
          let mid, left = 0, right = nums.length - 1; // right = nums.length
          while(left <= right) { //left < right
              mid = left + ((right - left) >> 1);
              if(nums[mid] > target) {
                  right = mid - 1; // right = mid
              } else if(nums[mid] < target) {
                  left = mid + 1;
              } else {
                  return mid;
              }
          }
          return -1
      };
      

      3. 总之就是闭区间时，确保下一次循环取到的右边界是有意义的。
   3. 移除元素
      1. 暴力的解法

      /**
       * @param {number[]} nums
       * @param {number} val
       * @return {number}
       */
      var removeElement = function(nums, val) {
          let l = nums.length;
          for(let i = 0; i < nums.length; i++) {
              if(nums[i] == val) {
                  for(let j = i+1; j < nums.length; j++) {
                      nums[j-1] = nums[j];
                  }
                  l--;
                  i--; //下标i以后的数值都向前移动了一位，所以i也向前移动一位
              }
          }
          return l;
      };
      

      2. 快慢指针
         1. 慢指针指向要赋值的地方，快指针指向要操作的地方，整个过程保持不变的性质是：区间 [0,left)中的元素都不等于 val。

      /**
       * @param {number[]} nums
       * @param {number} val
       * @return {number}
       */
      var removeElement = function(nums, val) {
          let left = 0;
          for(let right = 0; right < nums.length; right++) {
              if(nums[right] !== val) {
                  nums[left] = nums[right];
                  left ++; // nums[k++] = nums[i]
              }
          }
          return left;
      };