leetcode刷题记录(18)-简单

1.数组的度

题目：

给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

思路：首先，用三个map记录数据，第一个map记录每个字符出现的次数，用来记录哪个字符出现次数最多；第二个map记录每个字符的第一次出现的下标，第三个map记录每个字符最后出现的下标。然后，知道哪些字符出现次数最多之后（因为可能出现多个字符出现一样的次数），依次找到这些字符，计算这些字符的第一次出现和最后一次出现的差，即长度，记得+1.

/**
 * @param {number[]} nums
 * @return {number}
 */
var findShortestSubArray = function(nums) {
  const l = nums.length;
  if (l < 2) return l;
  const map1 = new Map();
  const map2 = new Map();
  const map3 = new Map();
  let max = 0;
  let maxV = [];
  for (let i = 0; i < l; i++) {
    map1.set(nums[i], (map1.get(nums[i]) || 0) + 1);
 map2.set(nums[i], map2.get(nums[i]) === undefined ? i : map2.get(nums[i]));
    map3.set(nums[i], i);
    if (map1.get(nums[i]) > max) {
      max = map1.get(nums[i]);
      maxV = [nums[i]];
    } else if (map1.get(nums[i]) == max) {
      maxV.push(nums[i]);
    }
  }
  return Math.min(...maxV.map((i) => map3.get(i) - map2.get(i) + 1));
};

2.二叉搜索树中的搜索

题目：给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

思路：既然是二叉搜索树，那么就类似二分法

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} val
 * @return {TreeNode}
 */
var searchBST = function(root, val) {
  if (!root) return null;
  if (val === root.val) return root;
  if (val > root.val) {
    return searchBST(root.right, val);
  } else {
    return searchBST(root.left, val);
  }
};

3.数据流中的第K大的元素

题目：

设计一个找到数据流中第K大元素的类（class）。注意是排序后的第K大元素，不是第K个不同的元素。

你的 KthLargest 类需要一个同时接收整数 k 和整数数组nums 的构造器，它包含数据流中的初始元素。每次调用 KthLargest.add，返回当前数据流中第K大的元素。

思路：维护一个长度为K的有序数组即可，每次加入元素的时候，就按照顺序插入，然后删除最小的元素。

/**
 * @param {number} k
 * @param {number[]} nums
 */
var KthLargest = function(k, nums) {
  this.index = k;
  nums.sort((a, b) => b - a);
  this.data = nums.slice(0, k);
};

/** 
 * @param {number} val
 * @return {number}
 */
KthLargest.prototype.add = function(val) {
  for (let i = 0; i < this.index; i++) {
    if (val >= this.data[i]) {
      this.data.splice(i, 0, val);
        if(this.data.length>this.index){
            this.data.pop()
        }
      break;
    }
  }
        if(this.data.length<this.index){
            this.data.push(val)
        }
  return this.data[this.index - 1];
};

/**
 * Your KthLargest object will be instantiated and called as such:
 * var obj = new KthLargest(k, nums)
 * var param_1 = obj.add(val)
 */

4.二分查找

题目：

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

思路：二分查找，没啥好说的

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
  let end = nums.length - 1;
  let start = 0;
  if (nums[end] === target) return end;
  if (nums[start] === target) return start;
  while (start <= end) {
    const middle = ~~((start + end) / 2);
    if (middle === start) return -1;
    if (nums[middle] === target) return middle;
    if (nums[middle] < target) {
      start = middle;
    } else {
      end = middle;
    }
  }
  return -1;
};

5.转换成小写字母

题目：实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。

思路：也没啥好说的

/**
 * @param {string} str
 * @return {string}
 */
var toLowerCase = function(str) {
  let res = "";
  for (const s of str) {
    const code = s.charCodeAt();
    if(code>=65&&code<=91) {
      res += String.fromCharCode(code + 32);
    }else{
      res += s;
    }
  }
  return res;
};

/**
 * @param {string} str
 * @return {string}
 */
var toLowerCase = function(str) {
return str.toLowerCase()
};