leetcode刷题记录(30)-简单

1.验证外星语词典

题目：

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。

给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

思路：记录每个字符的新顺序，然后依次比较单词中当前字符的顺序即可，如果遇到相等的字符，就比较下一个字符

/**
 * @param {string[]} words
 * @param {string} order
 * @return {boolean}
 */
var isAlienSorted = function(words, order) {
  const map = new Map();
  for (let i = 0; i < 26; i++) {
    map.set(order[i], i);
  }
  const l = words.length;
  const getN = (s1, s2) => {
    const l = s1.length;
    for (let i = 0; i < l; i++) {
      if (!s2[i]) return false;
      if (map.get(s1[i]) > map.get(s2[i])) return false;
      if (map.get(s1[i]) < map.get(s2[i])) return true;
    }
    return true;
  };
  for (let i = 0; i < l - 1; i++) {
    if (!getN(words[i], words[i + 1])) {
      return false;
    }
  }
  return true;
};

2.重复N次的元素

题目：

在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。

返回重复了 N 次的那个元素。

思路：最简单的，就是用map记录次数

/**
 * @param {number[]} A
 * @return {number}
 */
var repeatedNTimes = function(A) {
  const l = A.length;
  const map = new Map();
  for (const n of A) {
    const count = (map.get(n) || 0) + 1;
    if (count == l / 2) return n;
    map.set(n, count);
  }
};

然后，如果想不使用额外空间的话，因为只有一个重复的数字，那么，平均来看，每2个数字至少有一个数字是该数字，放大一倍，平均每4个数字至少有两个数字相同。所以，我们记录某个下标i到i+3的四个数字，找到两个相同的数字即可

/**
 * @param {number[]} A
 * @return {number}
 */
var repeatedNTimes = function(A) {
const l=A.length

    for(let j=0;j<l-3;j++){
        if(A[j]==A[j+1])return A[j]
        if(A[j]==A[j+2])return A[j]
        if(A[j]==A[j+3])return A[j]
        if(A[j+1]==A[j+2])return A[j+1]
        if(A[j+1]==A[j+3])return A[j+1]
        if(A[j+2]==A[j+3])return A[j+2]
}
};

3.单值二叉树

题目：

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

思路：遍历，用set记录节点的值，或者用一个变量记录上一个节点的值都行

遍历：

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isUnivalTree = function(root) {
  if (!root) return true;
  const v = root.val;
  const stack = [root];
  while (stack.length) {
    const item = stack.pop();
    if (item.val !== v) return false;
    if (item.left) {
      stack.push(item.left);
    }
    if (item.right) {
      stack.push(item.right);
    }
  }
  return true;
};

递归：

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isUnivalTree = function(root) {
  if (!root) return true;
  const pre = root.val;
  const search = (root) => {
    if (!root) return true;
    if (root.val !== pre) return false;
    return search(root.left) && search(root.right);
  };
  return search(root);
};

4.强整数

题目：

给定两个正整数 x 和 y，如果某一整数等于 x^i + y^j，其中整数 i >= 0 且 j >= 0，那么我们认为该整数是一个强整数。

返回值小于或等于 bound 的所有强整数组成的列表。

你可以按任何顺序返回答案。在你的回答中，每个值最多出现一次。

思路：双层遍历，用set记录数据，不过，要先处理x或者y为1的情况

/**
 * @param {number} x
 * @param {number} y
 * @param {number} bound
 * @return {number[]}
 */
var powerfulIntegers = function(x, y, bound) {
  if (x == 1 && y == 1) return bound>=2?[2]:[];
  const set = new Set();
  let i = 0;
  let j = 0;
  if (x == 1 || y == 1) {
    const m = x == 1 ? y : x;
    while (Math.pow(m, i) <= bound - 1) {
      set.add(Math.pow(m, i) + 1);

      i++;
    }
  } else {
    while (Math.pow(x, i) <= bound - 1) {
      j = 0;
      const v = Math.pow(x, i);

      while (v + Math.pow(y, j) <= bound) {
        set.add(Math.pow(y, j) + v);
        j++;
      }
      i++;
    }
  }

  return [...set];
};

5.三角形的最大周长

题目：

给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。

如果不能形成任何面积不为零的三角形，返回 0。

思路：连续的三个数就是最大周长，从末尾开始计算

/**
 * @param {number[]} A
 * @return {number}
 */
var largestPerimeter = function(A) {
  A.sort((a, b) => a - b);
  const l = A.length;
  let l0 = l - 3;
  while (l0 >= 0) {
    if (A[l0] + A[l0 + 1] > A[l0 + 2]) return A[l0] + A[l0 + 1] + A[l0 + 2];
    l0--;
  }
  return 0;
};