Merge branch 'youngyangyang04:master' into master

problems/0222.完全二叉树的节点个数.md

@@ -646,5 +646,68 @@ func countNodes(_ root: TreeNode?) -> Int {
 }
 ```
 
+## Scala
+
+递归:
+```scala
+object Solution {
+  def countNodes(root: TreeNode): Int = {
+    if(root == null) return 0
+    1 + countNodes(root.left) + countNodes(root.right)
+  }
+}
+```
+
+层序遍历:
+```scala
+object Solution {
+  import scala.collection.mutable
+  def countNodes(root: TreeNode): Int = {
+    if (root == null) return 0
+    val queue = mutable.Queue[TreeNode]()
+    var node = 0
+    queue.enqueue(root)
+    while (!queue.isEmpty) {
+      val len = queue.size
+      for (i <- 0 until len) {
+        node += 1
+        val curNode = queue.dequeue()
+        if (curNode.left != null) queue.enqueue(curNode.left)
+        if (curNode.right != null) queue.enqueue(curNode.right)
+      }
+    }
+    node
+  }
+}
+```
+
+利用完全二叉树性质:
+```scala
+object Solution {
+  def countNodes(root: TreeNode): Int = {
+    if (root == null) return 0
+    var leftNode = root.left
+    var rightNode = root.right
+    // 向左向右往下探
+    var leftDepth = 0
+    while (leftNode != null) {
+      leftDepth += 1
+      leftNode = leftNode.left
+    }
+    var rightDepth = 0
+    while (rightNode != null) {
+      rightDepth += 1
+      rightNode = rightNode.right
+    }
+    // 如果相等就是一个满二叉树
+    if (leftDepth == rightDepth) {
+      return (2 << leftDepth) - 1
+    }
+    // 如果不相等就不是一个完全二叉树，继续向下递归
+    countNodes(root.left) + countNodes(root.right) + 1
+  }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0257.二叉树的所有路径.md

@@ -702,5 +702,35 @@ func binaryTreePaths(_ root: TreeNode?) -> [String] {
 }
 ```
 
+Scala:
+
+递归:
+```scala
+object Solution {
+  import scala.collection.mutable.ListBuffer
+  def binaryTreePaths(root: TreeNode): List[String] = {
+    val res = ListBuffer[String]()
+    def traversal(curNode: TreeNode, path: ListBuffer[Int]): Unit = {
+      path.append(curNode.value)
+      if (curNode.left == null && curNode.right == null) {
+        res.append(path.mkString("->")) // mkString函数: 将数组的所有值按照指定字符串拼接
+        return // 处理完可以直接return
+      }
+
+      if (curNode.left != null) {
+        traversal(curNode.left, path)
+        path.remove(path.size - 1)
+      }
+      if (curNode.right != null) {
+        traversal(curNode.right, path)
+        path.remove(path.size - 1)
+      }
+    }
+    traversal(root, ListBuffer[Int]())
+    res.toList
+  }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0416.分割等和子集.md

@@ -417,6 +417,26 @@ var canPartition = function(nums) {
 ```
 
 
+TypeScript:
+
+```ts
+function canPartition(nums: number[]): boolean {
+    const sum: number = nums.reduce((a: number, b: number): number => a + b);
+    if (sum % 2 === 1) return false;
+    const target: number = sum / 2;
+    // dp[j]表示容量（总数和）为j的背包所能装下的数（下标[0, i]之间任意取）的总和（<= 容量）的最大值
+    const dp: number[] = new Array(target + 1).fill(0);
+    const n: number = nums.length;
+    for (let i: number = 0; i < n; i++) {
+        for (let j: number = target; j >= nums[i]; j--) {
+            dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
+        }
+    }
+    return dp[target] === target;
+};
+```
+
+
 C:
 二维dp：
 ```c
@@ -575,6 +595,5 @@ function canPartition(nums: number[]): boolean {
 
 
 
-
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0494.目标和.md

@@ -351,22 +351,26 @@ const findTargetSumWays = (nums, target) => {
 };
 ```
 
-TypeScript：
 
-```typescript
+TypeScript:
+
+```ts
 function findTargetSumWays(nums: number[], target: number): number {
-    const sum: number = nums.reduce((pre, cur) => pre + cur);
+    // 把数组分成两个组合left, right.left + right = sum, left - right = target.
-    if (Math.abs(target) > sum) return 0;
+    const sum: number = nums.reduce((a: number, b: number): number => a + b);
-    if ((target + sum) % 2 === 1) return 0;
+    if ((sum + target) % 2 || Math.abs(target) > sum)  return 0;
-    const bagSize: number = (target + sum) / 2;
+    const left: number = (sum + target) / 2;
-    const dp: number[] = new Array(bagSize + 1).fill(0);
+    
-    dp[0] = 1;
+    // 将问题转化为装满容量为left的背包有多少种方法
-    for (let i = 0; i < nums.length; i++) {
+    // dp[i]表示装满容量为i的背包有多少种方法
-        for (let j = bagSize; j >= nums[i]; j--) {
+    const dp: number[] = new Array(left + 1).fill(0);
+    dp[0] = 1;  // 装满容量为0的背包有1种方法（什么也不装）
+    for (let i: number = 0; i < nums.length; i++) {
+        for (let j: number = left; j >= nums[i]; j--) {
             dp[j] += dp[j - nums[i]];
         }
     }
-    return dp[bagSize];
+    return dp[left];
 };
 ```
 

problems/1049.最后一块石头的重量II.md

@@ -277,26 +277,29 @@ var lastStoneWeightII = function (stones) {
 };
 ```
 
-TypeScript：
 
-```typescript
+TypeScript版本
+
+```ts
 function lastStoneWeightII(stones: number[]): number {
-    const sum: number = stones.reduce((pre, cur) => pre + cur);
+    const sum: number = stones.reduce((a: number, b:number): number => a + b);
-    const bagSize: number = Math.floor(sum / 2);
+    const target: number = Math.floor(sum / 2);
-    const weightArr: number[] = stones;
+    const n: number = stones.length;
-    const valueArr: number[] = stones;
+    // dp[j]表示容量（总数和）为j的背包所能装下的数（下标[0, i]之间任意取）的总和（<= 容量）的最大值
-    const goodsNum: number = weightArr.length;
+    const dp: number[] = new Array(target + 1).fill(0);
-    const dp: number[] = new Array(bagSize + 1).fill(0);
+    for (let i: number = 0; i < n; i++ ) {
-    for (let i = 0; i < goodsNum; i++) {
+        for (let j: number = target; j >= stones[i]; j--) {
-        for (let j = bagSize; j >= weightArr[i]; j--) {
+            dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
-            dp[j] = Math.max(dp[j], dp[j - weightArr[i]] + valueArr[i]);
         }
     }
-    return sum - dp[bagSize] * 2;
+    return sum - dp[target] - dp[target];
 };
 ```
 
 
 
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/1365.有多少小于当前数字的数字.md

@@ -217,6 +217,46 @@ var smallerNumbersThanCurrent = function(nums) {
 };
 ```
 
+TypeScript:
+
+> 暴力法：
+
+```typescript
+function smallerNumbersThanCurrent(nums: number[]): number[] {
+    const length: number = nums.length;
+    const resArr: number[] = [];
+    for (let i = 0; i < length; i++) {
+        let count: number = 0;
+        for (let j = 0; j < length; j++) {
+            if (nums[j] < nums[i]) {
+                count++;
+            }
+        }
+        resArr[i] = count;
+    }
+    return resArr;
+};
+```
+
+> 排序+hash
+
+```typescript
+function smallerNumbersThanCurrent(nums: number[]): number[] {
+    const length: number = nums.length;
+    const sortedArr: number[] = [...nums];
+    sortedArr.sort((a, b) => a - b);
+    const hashMap: Map<number, number> = new Map();
+    for (let i = length - 1; i >= 0; i--) {
+        hashMap.set(sortedArr[i], i);
+    }
+    const resArr: number[] = [];
+    for (let i = 0; i < length; i++) {
+        resArr[i] = hashMap.get(nums[i]);
+    }
+    return resArr;
+};
+```
+
 
 
 -----------------------