update 5 leetcode

Author: kyriejoshua

leetcode/101.symmetric-tree.js

@@ -0,0 +1,73 @@
+/*
+ * @lc app=leetcode id=101 lang=javascript
+ *
+ * [101] Symmetric Tree
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * 深度优先，使用递归的方式
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric = function(root) {
+ if (!root) {
+ return false;
+ }
+ const check = (p, q) => {
+ // 判断是否有一级子节点，如果没有则只有根节点，就是对称的
+ if (!p && !q) {
+ return true;
+ }
+ // 如果一边有，另一边没有，那肯定是不对称的
+ if (!p || !q) {
+ return false;
+ }
+ // 当前节点的值相等，并且往下也是相等的
+ // 是两棵树往对称的方向行走下去比较
+ return p.val === q.val && check(p.left, q.right) && check(q.left, p.right);
+ }
+
+ // 注意是传入两个根节点，但是判断的方向是一左一右,这样就形成了左右对称的效果
+ return check(root, root);
+};
+
+/**
+ * 广度优先的写法，使用迭代
+ * 思路和上面是一样的
+ * 传入两个相同的树，但是判断顺序是左右相反的
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric2 = function(root) {
+ let queue1 = [root];
+ let queue2 = [root];
+
+ while (queue1.length) {
+ const cur1 = queue1.shift();
+ const cur2 = queue2.shift();
+ if (!cur1 && !cur2) {
+ // 不做任何处理，但是要放在第二个判断前面
+ // 先排除两个都不存在的情况，再判断有一个节点有，另一个节点没有的情况
+ } else if (!cur1 || !cur2) {
+ return false;
+ } else if (cur1.val !== cur2.val) {
+ return false;
+ } else {
+ queue1.push(cur1.left);
+ queue1.push(cur1.right);
+ queue2.push(cur2.right);
+ queue2.push(cur2.left);
+ }
+ }
+ return true;
+};
+// @lc code=end

leetcode/112.path-sum.js

@@ -0,0 +1,32 @@
+
+/*
+ * @lc app=leetcode id=112 lang=javascript
+ *
+ * [112] Path Sum
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * 递归的思路，如果总和相等，那么递减节点之后最后一个节点的值和递减的值必然相等
+ * @param {TreeNode} root
+ * @param {number} targetSum
+ * @return {boolean}
+ */
+var hasPathSum = function(root, targetSum) {
+ if (root === null) {
+ return false;
+ }
+ if (root.left === null && root.right === null) {
+ return root.val === targetSum;
+ }
+ return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
+};
+// @lc code=end

leetcode/1528.shuffle-string.js

@@ -0,0 +1,21 @@
+/*
+ * @lc app=leetcode id=1528 lang=javascript
+ *
+ * [1528] Shuffle String
+ */
+
+// @lc code=start
+/**
+ * @param {string} s
+ * @param {number[]} indices
+ * @return {string}
+ */
+var restoreString = function(s, indices) {
+ let arr = []
+ for (let i = 0; i < indices.length; i++) {
+ let index = indices[i];
+ arr[index] = s.charAt(i);
+ }
+ return arr.join('');
+};
+// @lc code=end

leetcode/1556.thousand-separator.js

@@ -0,0 +1,37 @@
+/*
+ * @lc app=leetcode id=1556 lang=javascript
+ *
+ * [1556] Thousand Separator
+ */
+
+// @lc code=start
+/**
+ * 转成数组再依次插入，因为是从后面插入的，而索引是从前往后的，所以每次插入对索引不影响，直接依次插入即可
+ * @param {number} n
+ * @return {string}
+ */
+var thousandSeparator = function(n) {
+ let s = n + '';
+ let arr = s.split('');
+ if (s.length <= 3) {
+ return s;
+ }
+ let len = s.length;
+ while (len > 3) {
+ len -= 3;
+ arr.splice(len, 0, '.');
+ }
+ return arr.join('');
+};
+
+/**
+ * 转成字符串，直接使用字符串的格式化，这个方式比较 hack
+ * 正则去替代 ','
+ * @param {*} n
+ * @returns
+ */
+var thousandSeparator2 = function(n) {
+ let s = n.toLocaleString();
+ return s.replace(/,/g, '.');
+};
+// @lc code=end

leetcode/35.search-insert-position.js

@@ -16,7 +16,7 @@ var searchInsert = function(nums, target) {
  // 二分法向中间查找
  // 不是两边往中间找，而是不断更新中间值
  while (left <= right) {
- // 二进制右移一位，等同于对半取整，因为向左一位是乘以 2， 向右一位是除以 2
+ // 二进制右移一位，等同于对半而且取整，因为向左一位是乘以 2， 向右一位是除以 2
  let mid = ((right - left) >> 1) + left;
  if (target <= nums[mid]) {
  ans = mid;