Merge branch 'main' of github.com:ldtech007/leetcode

Author: ldtech007

README.md

@@ -39,12 +39,13 @@
 |[leetcode 242.有效的字母异位词](./leetcode%20blind75/字符串/LeetCode%200242.%20有效的字母异位词.md)| ✔ | ✔ | ✔ | [有效的字母异位词](https://www.bilibili.com/video/BV1db421J7qK/) |
 |[leetcode 424.替换后的最长重复字符](./leetcode%20blind75/字符串/LeetCode%200424.%20替换后的最长重复字符.md)| ✔ | ✔ | ✔ | [替换后的最长重复字符](https://www.bilibili.com/video/BV1zf421d7Ui/) |
 |[leetcode 647.回文子串](./leetcode%20blind75/字符串/LeetCode%200647.%20回文子串.md)| ✔ | ✔ | ✔ | [回文子串](https://www.bilibili.com/video/BV1Bs421w7iw/) |
-|[leetcode 19.删除链表的倒数第N个结点](./leetcode%20blind75/链表/LeetCode%200019.%20删除链表的倒数第%20N%20个结点.md)| ✔ | ✔ | ✔ | 录制中 |
-|[leetcode 21.合并两个有序链表](./leetcode%20blind75/链表/LeetCode%200021.%20%E5%90%88%E5%B9%B6%E4%B8%A4%E4%B8%AA%E6%9C%89%E5%BA%8F%E9%93%BE%E8%A1%A8.md)| ✔ | ✘ | ✘ | 录制中 |
-|[leetcode 23.合并 K 个升序链表](./leetcode%20blind75/链表/LeetCode%200023.%20%E5%90%88%E5%B9%B6%20K%20%E4%B8%AA%E5%8D%87%E5%BA%8F%E9%93%BE%E8%A1%A8.md)| ✔ | ✘ | ✘ | 录制中 |
-|[leetcode 141.环形链表](./leetcode%20blind75/链表/LeetCode%200141.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8.md)| ✔ | ✘ | ✘ | 录制中 |
-|[leetcode 143.重排链表](./leetcode%20blind75/链表/LeetCode%200143.%20%E9%87%8D%E6%8E%92%E9%93%BE%E8%A1%A8.md)| ✔ | ✘ | ✘ | 录制中 |
+|[leetcode 19.删除链表的倒数第N个结点](./leetcode%20blind75/链表/LeetCode%200019.%20删除链表的倒数第%20N%20个结点.md)| ✔ | ✔ | ✔ | [删除链表的倒数第N个结点](https://www.bilibili.com/video/BV1hs421M7Ke/) |
+|[leetcode 21.合并两个有序链表](./leetcode%20blind75/链表/LeetCode%200021.%20%E5%90%88%E5%B9%B6%E4%B8%A4%E4%B8%AA%E6%9C%89%E5%BA%8F%E9%93%BE%E8%A1%A8.md)| ✔ | ✔ | ✔ | [合并两个有序链表](https://www.bilibili.com/video/BV17w4m1Y7CJ/) |
+|[leetcode 23.合并 K 个升序链表](./leetcode%20blind75/链表/LeetCode%200023.%20%E5%90%88%E5%B9%B6%20K%20%E4%B8%AA%E5%8D%87%E5%BA%8F%E9%93%BE%E8%A1%A8.md)| ✔ | ✔ | ✔ | [合并 K 个升序链表](https://www.bilibili.com/video/BV136421f7hR/)] |
+|[leetcode 141.环形链表](./leetcode%20blind75/链表/LeetCode%200141.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8.md)| ✔ | ✔ | ✔ | [环形链表](https://www.bilibili.com/video/BV18z421q78k/) |
+|[leetcode 143.重排链表](./leetcode%20blind75/链表/LeetCode%200143.%20%E9%87%8D%E6%8E%92%E9%93%BE%E8%A1%A8.md)| ✔ | ✔ | ✔ | [重排链表](https://www.bilibili.com/video/BV1tx4y1t7YB/) |
 |[leetcode 206.反转链表](./leetcode%20blind75/链表/LeetCode%200206.%20%E5%8F%8D%E8%BD%AC%E9%93%BE%E8%A1%A8.md)| ✔ | ✔ | ✔ | [反转链表](https://www.bilibili.com/video/BV1gE421N7W2/) |
+|[leetcode 190.颠倒二进制位](./leetcode%20blind75/%E4%BD%8D%E8%BF%90%E7%AE%97/LeetCode%200190.%E9%A2%A0%E5%80%92%E4%BA%8C%E8%BF%9B%E5%88%B6%E4%BD%8D.md)| ✔ | ✘ | ✘ | 录制中 |
 
 所有的文章都是我利用工作之余的时间写的，尽可能使用最简洁易懂的方式，由浅入深，还画了一些帮助理解的图片。每写完一篇我都会以小白的姿态去反复阅读，反复修改。 也获得了一些同学的认可，还有一些同学在力扣的题解评论区给我提建议，我也会根据同学们的建议去不断调整。我始终认为个人的思路是有局限性的，因为每个人对基础知识的掌握程度是不一样的，一个人认为理所当然的结论，另一个人可能想破脑袋都不理解，所以需要我们共同去不断完善。非常欢迎大家通过力扣评论、公众号「编程网事」后台给我提建议，或者直接提给我你的合并请求。
 

leetcode blind75/位运算/LeetCode 0190.颠倒二进制位.md

@@ -62,6 +62,41 @@ public:
     }
 };
 ```
+
+### java代码
+
+```java
+public class Solution {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        int res = 0;
+        for (int i = 0; i < 32; ++i) {
+            // 原串的第i位
+            int bit = n & 1;
+            // 将原串的第i位放到res的第31-i位
+            res |= (bit << (31 - i));
+            n >>= 1;
+        }
+        return res;
+    }
+}
+```
+
+### python代码
+
+```python
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        res = 0
+        for i in range(32):
+            # 原串的第i位
+            bit = n & 1
+            # 将原串的第i位放到res的第31-i位
+            res |= (bit << (31 - i))
+            n >>= 1
+        return res
+```
+
 ### 方法二 分治
 
 下面介绍另一种分治方法，对一些刚刷题的同学来说可能比较难理解。
@@ -106,6 +141,46 @@ public:
     }
 };
 ```
+
+### java代码
+
+```java
+public class Solution {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        // 左右16位交换
+        n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000);
+        // 左右8位交换
+        n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00);
+        // 左右4位交换
+        n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0);
+        // 左右2位交换
+        n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc);
+        // 左右1位交换
+        n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa);
+        return n;
+    }
+}
+```
+
+### python代码
+
+```python
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        # 左右16位交换
+        n = (n >> 16) | (n << 16)
+        # 左右8位交换
+        n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8)
+        # 左右4位交换
+        n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4)
+        # 左右2位交换
+        n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2)
+        # 左右1位交换
+        n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1)
+        return n
+```
+
 ## 复杂度分析
 
 **时间复杂度：** 两种方法都是 *O(1)*，最多处理`32`位，分治是`log32`位，都是常量时间。

leetcode blind75/位运算/LeetCode 0191.位1的个数.md

@@ -48,6 +48,41 @@ public:
     } 
 };
 ```
+
+### java代码
+
+```java
+class Solution {
+    public int hammingWeight(int n) {
+        int res = 0;
+        while (n != 0) {
+            // 获取n对应二进制最右边一位
+            if (n % 2 == 1) {
+                res++;
+            }
+            // n对应的二进制右移一位
+            n = n / 2;
+        }
+        return res;
+    }
+}
+```
+
+### python代码
+
+```python
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        res = 0
+        while n:
+            # 获取n对应二进制最右边一位
+            if n % 2:
+                res += 1
+            # n对应的二进制右移一位
+            n = n // 2
+        return res
+```
+
 ### 方法二
 
 定义`res`保存`1`的个数。对于无符号整数`n`，统计其中`1`的个数步骤如下：
@@ -77,6 +112,35 @@ public:
 };
 ```
 
+### java代码
+
+```java
+class Solution {
+    public int hammingWeight(int n) {
+        int res = 0;
+        while (n != 0) {
+            res++;
+            // n对应二进制最右边不为零的bit位置为零
+            n = n & (n - 1);
+        }
+        return res;
+    }
+}
+```
+
+### python代码
+
+```python
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        res = 0
+        while n:
+            res += 1
+            # n对应二进制最右边不为零的bit位置为零
+            n = n & (n - 1)
+        return res
+```
+
 ## 复杂度分析
 
 **时间复杂度：** 两种方法都是*O(1)*，因为二进制最长为`32`位。

leetcode blind75/位运算/LeetCode 0268.丢失的数字.md

@@ -47,6 +47,36 @@ public:
     }
 };
 ```
+
+### java代码
+
+```java
+class Solution {
+    public int missingNumber(int[] nums) {
+        int nums_len = nums.length;
+        int res = nums_len;
+        for (int i = 0; i < nums_len; ++i) {
+            //[0,n]和nums中的元素做异或操作
+            res ^= (i ^ nums[i]);
+        }
+        return res;
+    }
+}
+```
+
+### python 代码
+
+```python
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        nums_len = len(nums)
+        res = nums_len
+        for i in range(nums_len):
+            #[0,n]和nums中的元素做异或操作
+            res ^= (i ^ nums[i])
+        return res
+```
+
 ### 方法二 数学运算
 
 因为区间`[0, n]`上有`n + 1`个元素，数组`nums`中只有`n`个元素，假设缺失的元素为`X`，我们可以得到如下公式：
@@ -73,6 +103,35 @@ public:
 };
 ```
 
+### java代码
+
+```java
+class Solution {
+    public int missingNumber(int[] nums) {
+        int nums_len = nums.length;
+        int res = nums_len;
+        for (int i = 0; i < nums_len; ++i) {
+            //[0,n]的和减去nums中所有元素的和
+            res += (i - nums[i]);
+        }
+        return res;
+    }
+}
+```
+
+### python代码
+
+```python
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        nums_len = len(nums)
+        res = nums_len
+        for i in range(nums_len):
+            #[0,n]的和减去nums中所有元素的和
+            res += (i - nums[i])
+        return res
+```
+
 ## 复杂度分析
 
 **时间复杂度：** 两种方法的整个过程都是只遍历了一遍数组，所以时间复杂度为*O(n)*，`n`为数组`nums`的长度。

leetcode blind75/位运算/LeetCode 0338. 比特位计数.md

@@ -90,6 +90,42 @@ public:
 };
 ```
 
+### java代码
+
+```java
+class Solution {
+    public int[] countBits(int n) {
+        int[] dp = new int[n + 1];
+        for (int i = 1; i <= n; ++i) {
+            if (i % 2 == 0) {
+                // i为偶数
+                dp[i] = dp[i / 2];
+            } else {
+                // i为奇数
+                dp[i] = dp[i / 2] + 1;
+            }
+        }
+        return dp;
+    }
+}
+```
+
+### python代码
+
+```python
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        dp = [0] * (n + 1)
+        for i in range(1, n + 1):
+            if i % 2 == 0:
+                # i为偶数
+                dp[i] = dp[i // 2]
+            else:
+                # i为奇数
+                dp[i] = dp[i // 2] + 1
+        return dp
+```
+
 ### 方法二
 
 我们先介绍一个骚操作，对于一个整数`n`，`n & (n - 1)`可以将`n`的二进制最右边值为`1`的`bit位`置为`0`。
@@ -121,7 +157,32 @@ public:
     }   
 };
 ```
+### java代码
+
+```java
+class Solution {
+    public int[] countBits(int n) {
+        int[] dp = new int[n + 1];
+        for (int i = 1; i <= n; ++i) {
+            // 状态转移公式
+            dp[i] = dp[i & (i - 1)] + 1;
+        }
+        return dp;
+    }
+}
+```
 
+### python 代码
+
+```python
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        dp = [0] * (n + 1)
+        for i in range(1, n + 1):
+            # 状态转移公式
+            dp[i] = dp[i & (i - 1)] + 1
+        return dp
+```
 
 ## 复杂度分析
 

leetcode blind75/位运算/LeetCode 0371.两整数之和.md

@@ -92,6 +92,37 @@ public:
 };
 ```
 
+## java代码
+
+```java
+class Solution {
+    public int getSum(int a, int b) {
+        while (b != 0) {
+            int temp_add = a ^ b; // 不包含进位a、b每位的和
+            // a、b每位和的进位，左移有符号值会溢出，赋给无符号的会自动取模
+            int temp_carry = (a & b) << 1;
+            a = temp_add; // a、b每位的和赋值给a
+            b = temp_carry; // a、b每位的进位赋值给b
+        }
+        return a;
+    }
+}
+```
+
+## python代码
+
+```python
+class Solution:
+    def getSum(self, a: int, b: int) -> int:
+        while b:
+            temp_add = a ^ b  # 不包含进位a、b每位的和
+            # a、b每位和的进位，左移有符号值会溢出，赋给无符号的会自动取模
+            temp_carry = (a & b) << 1
+            a = temp_add  # a、b每位的和赋值给a
+            b = temp_carry  # a、b每位的进位赋值给b
+        return a
+```
+
 ## 复杂度分析
 
 **时间复杂度：** *O(1)*，因为整数在`32`位操作系统上占`32`位，最多计算`32`次`temp_carry`，故为常数的时间复杂度。

leetcode blind75/链表/LeetCode 0019. 删除链表的倒数第 N 个结点.md

@@ -1,4 +1,6 @@
 > *题目链接：* https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
+>
+>*视频题解：* https://www.bilibili.com/video/BV1hs421M7Ke/
 
 # LeetCode 19. 删除链表的倒数第 N 个结点