Merge branch 'youngyangyang04:master' into master

problems/0027.移除元素.md

@@ -144,15 +144,28 @@ class Solution {
 
 Python：
 
-```python
+```python3
 class Solution:
-    def removeElement(self, nums: List[int], val: int) -> int:
+    """双指针法
-        i,n = 0,len(nums)
+    时间复杂度：O(n)
-        for j in range(n):
+    空间复杂度：O(1)
-            if nums[j] != val:
+    """
-                nums[i] = nums[j]
+
-                i += 1
+    @classmethod
-        return i
+    def removeElement(cls, nums: List[int], val: int) -> int:
+        fast = slow = 0
+
+        while fast < len(nums):
+
+            if nums[fast] != val:
+                nums[slow] = nums[fast]
+                slow += 1
+
+            # 当 fast 指针遇到要删除的元素时停止赋值
+            # slow 指针停止移动, fast 指针继续前进
+            fast += 1
+
+        return slow
 ```
 
 

problems/0104.二叉树的最大深度.md

@@ -311,6 +311,35 @@ class solution {
 }
 ```
 
+### 559.n叉树的最大深度 
+```java
+class solution {
+    /**
+     * 迭代法，使用层序遍历
+     */
+    public int maxDepth(Node root) {
+        if (root == null)   return 0;
+        int depth = 0;
+        Queue<Node> que = new LinkedList<>();
+        que.offer(root);
+        while (!que.isEmpty())
+        {
+            depth ++;
+            int len = que.size();
+            while (len > 0)
+            {
+                Node node = que.poll();
+                for (int i = 0; i < node.children.size(); i++)
+                    if (node.children.get(i) != null) 
+                        que.offer(node.children.get(i));
+                len--;
+            }
+        }
+        return depth;
+    }
+}
+```
+
 ## python 
 
 ### 104.二叉树的最大深度

problems/0242.有效的字母异位词.md

@@ -198,6 +198,29 @@ var isAnagram = function(s, t) {
 };
 ```
 
+Swift：
+```Swift
+func isAnagram(_ s: String, _ t: String) -> Bool {
+    if s.count != t.count {
+        return false
+    }
+    var record = Array(repeating: 0, count: 26)
+    let aUnicodeScalar = "a".unicodeScalars.first!.value
+    for c in s.unicodeScalars {
+        record[Int(c.value - aUnicodeScalar)] += 1
+    }
+    for c in t.unicodeScalars {
+        record[Int(c.value - aUnicodeScalar)] -= 1
+    }
+    for value in record {
+        if value != 0 {
+            return false
+        }
+    }
+    return true
+}
+```
+
 ## 相关题目
 
 * 383.赎金信

problems/0454.四数相加II.md

@@ -161,15 +161,9 @@ class Solution(object):
 #         count=0
 #         for x3 in nums3:
 #             for x4 in nums4:
-#                 key = -x3-x4
+#                 key = 0 - x3 - x4
-#                 value = hashmap.get(key)
+#                 value = hashmap[key]  # 若差值(key)不存在，则value被赋值0
-
+#                 count += value                
-                  # dict的get方法会返回None（key不存在）或者key对应的value
-                  # 所以如果value==0，就会继续执行or，count+0，否则就会直接加value
-                  # 这样就不用去写if判断了
-            
-#                 count += value or 0
-                
 #         return count
 
 ```

problems/0649.Dota2参议院.md

@@ -10,6 +10,9 @@
 
 # 649. Dota2 参议院
 
+[力扣题目链接](https://leetcode-cn.com/problems/dota2-senate/)
+
+
 Dota2 的世界里有两个阵营：Radiant(天辉)和 Dire(夜魇)
 
 Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的一项：
@@ -115,16 +118,102 @@ public:
 ## Java
 
 ```java
+class Solution {
+    public String predictPartyVictory(String senateStr) {
+        // R = true表示本轮循环结束后，字符串里依然有R。D同理
+        Boolean R = true, D = true;
+        // 当flag大于0时，R在D前出现，R可以消灭D。当flag小于0时，D在R前出现，D可以消灭R
+        int flag = 0;
+        byte[] senate =  senateStr.getBytes();
+        while (R && D) { // 一旦R或者D为false，就结束循环，说明本轮结束后只剩下R或者D了
+            R = false;
+            D = false;
+            for (int i = 0; i < senate.length; i++) {
+                if (senate[i] == 'R') {
+                    if (flag < 0) senate[i] = 0; // 消灭R，R此时为false
+                    else R = true; // 如果没被消灭，本轮循环结束有R
+                    flag++;
+                }
+                if (senate[i] == 'D') {
+                    if (flag > 0) senate[i] = 0;
+                    else D = true;
+                    flag--;
+                }
+            }
+        }
+        // 循环结束之后，R和D只能有一个为true
+        return R == true ? "Radiant" : "Dire";
+    }
+}
 ```
 
 ## Python
 
 ```python
+class Solution:
+    def predictPartyVictory(self, senate: str) -> str:
+        # R = true表示本轮循环结束后，字符串里依然有R。D同理
+        R , D = True, True
+
+        # 当flag大于0时，R在D前出现，R可以消灭D。当flag小于0时，D在R前出现，D可以消灭R
+        flag = 0
+
+        senate = list(senate)
+        while R and D: # 一旦R或者D为false，就结束循环，说明本轮结束后只剩下R或者D了
+            R = False
+            D = False
+            for i in range(len(senate)) :
+                if senate[i] == 'R' :
+                    if flag < 0: senate[i] = '0' # 消灭R，R此时为false
+                    else: R = True # 如果没被消灭，本轮循环结束有R
+                    flag += 1
+                if senate[i] == 'D':
+                    if flag > 0: senate[i] = '0'
+                    else: D = True
+                    flag -= 1
+        # 循环结束之后，R和D只能有一个为true
+        return "Radiant" if R else "Dire"
 ```
 
 ## Go
 
 ```go
+
+func predictPartyVictory(senateStr string) string {
+	// R = true表示本轮循环结束后，字符串里依然有R。D同理
+	R, D := true, true
+	// 当flag大于0时，R在D前出现，R可以消灭D。当flag小于0时，D在R前出现，D可以消灭R
+	flag := 0
+
+	senate := []byte(senateStr)
+	for R && D { // 一旦R或者D为false，就结束循环，说明本轮结束后只剩下R或者D了
+		R = false
+		D = false
+		for i := 0; i < len(senate); i++ {
+			if senate[i] == 'R' {
+				if flag < 0  {
+					 senate[i] = 0  // 消灭R，R此时为false
+				} else {
+					R = true // 如果没被消灭，本轮循环结束有R
+				}
+				flag++;
+			}
+			if (senate[i] == 'D') {
+				if flag > 0 {
+					senate[i] = 0
+				} else  {
+					D = true
+				}
+				flag--
+			}
+		}
+	}
+	// 循环结束之后，R和D只能有一个为true
+	if R {
+		return "Radiant"
+	}
+	return "Dire";
+}
 ```
 
 ## JavaScript

problems/0704.二分查找.md

@@ -406,6 +406,49 @@ func search(nums: [Int], target: Int) -> Int {
 
 ```
 
+**Rust:**
+
+```rust
+# （版本一）左闭右闭区间
+
+impl Solution {
+    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
+        let mut left:usize = 0;
+        let mut right:usize = nums.len() - 1;
+        while left as i32 <= right as i32{
+            let mid = (left + right) / 2;
+            if nums[mid] < target {
+                left = mid + 1;
+            } else if nums[mid] > target {
+                right = mid - 1;
+            } else {
+                return mid as i32;
+            }
+        }
+        -1
+    }
+}
+
+# （版本二）左闭右开区间
+
+impl Solution {
+    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
+        let mut left:usize = 0;
+        let mut right:usize = nums.len();
+        while left < right {
+            let mid = (left + right) / 2;
+            if nums[mid] < target {
+                left = mid + 1;
+            } else if nums[mid] > target {
+                right = mid;
+            } else {
+                return mid as i32;
+            }
+        }
+        -1
+    }
+}
+```
 
 
 -----------------------