algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-08 16:54:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'youngyangyang04:master' into master

Browse Source
This commit is contained in:
ironartisan
2021-08-27 15:48:52 +08:00
committed by GitHub
parent 0de0f77934 fad7fd35d1
commit 2561c74c24
6 changed files with 208 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
problems/0027.移除元素.md
View File

@ -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)
for j in range(n):
if nums[j] != val:
nums[i] = nums[j]
i += 1
return i
"""双指针法
时间复杂度：O(n)
空间复杂度：O(1)
"""
@classmethod
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
```

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

@ -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.二叉树的最大深度

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

@ -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.赎金信

12
problems/0454.四数相加II.md
View File

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

89
problems/0649.Dota2参议院.md
View File

@ -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

43
problems/0704.二分查找.md
View File

@ -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
}
}
```
-----------------------