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

Merge branch 'master' of github.com:youngyangyang04/leetcode-master

Browse Source
This commit is contained in:
programmercarl
2023-07-19 10:33:58 +08:00
parent e5d694da4d ca85e56bc7
commit 9b3c2347cc
21 changed files with 485 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
problems/0019.删除链表的倒数第N个节点.md
View File

@ -7,7 +7,7 @@
## 19.删除链表的倒数第N个节点 # 19.删除链表的倒数第N个节点
[力扣题目链接](https://leetcode.cn/problems/remove-nth-node-from-end-of-list/) [力扣题目链接](https://leetcode.cn/problems/remove-nth-node-from-end-of-list/)
@ -31,11 +31,13 @@
输入：head = [1,2], n = 1 输入：head = [1,2], n = 1
输出：[1] 输出：[1]
## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：：[链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点](https://www.bilibili.com/video/BV1vW4y1U7Gf)，相信结合视频再看本篇题解，更有助于大家对链表的理解。**
## 思路 ## 思路
《代码随想录》算法公开课：[链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点](https://www.bilibili.com/video/BV1vW4y1U7Gf)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。 双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
@ -93,7 +95,7 @@ public:
## 其他语言版本 ## 其他语言版本
java: ### Java:
```java ```java
public ListNode removeNthFromEnd(ListNode head, int n){ public ListNode removeNthFromEnd(ListNode head, int n){
@ -120,7 +122,8 @@ public ListNode removeNthFromEnd(ListNode head, int n){
} }
``` ```
Python: ### Python:
```python ```python
# Definition for singly-linked list. # Definition for singly-linked list.
# class ListNode: # class ListNode:
@ -151,7 +154,8 @@ class Solution:
return dummy_head.next return dummy_head.next
``` ```
Go: ### Go:
```Go ```Go
/** /**
* Definition for singly-linked list. * Definition for singly-linked list.
@ -178,7 +182,7 @@ func removeNthFromEnd(head *ListNode, n int) *ListNode {
} }
``` ```
JavaScript: ### JavaScript:
```js ```js
/** /**
@ -198,7 +202,7 @@ var removeNthFromEnd = function(head, n) {
return ret.next; return ret.next;
}; };
``` ```
TypeScript: ### TypeScript:
版本一（快慢指针法）： 版本一（快慢指针法）：
@ -263,7 +267,7 @@ function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
}; };
``` ```
Kotlin: ### Kotlin:
```Kotlin ```Kotlin
fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? { fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
@ -284,7 +288,8 @@ fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
} }
``` ```
Swift： ### Swift：
```swift ```swift
func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? { func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
if head == nil { if head == nil {
@ -309,8 +314,8 @@ func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
} }
``` ```
### PHP:
PHP:
```php ```php
function removeNthFromEnd($head, $n) { function removeNthFromEnd($head, $n) {
// 设置虚拟头节点 // 设置虚拟头节点
@ -332,7 +337,8 @@ function removeNthFromEnd($head, $n) {
} }
``` ```
Scala: ### Scala:
```scala ```scala
object Solution { object Solution {
def removeNthFromEnd(head: ListNode, n: Int): ListNode = { def removeNthFromEnd(head: ListNode, n: Int): ListNode = {
@ -356,7 +362,8 @@ object Solution {
} }
``` ```
Rust: ### Rust:
```rust ```rust
impl Solution { impl Solution {
pub fn remove_nth_from_end(head: Option<Box<ListNode>>, mut n: i32) -> Option<Box<ListNode>> { pub fn remove_nth_from_end(head: Option<Box<ListNode>>, mut n: i32) -> Option<Box<ListNode>> {
@ -377,7 +384,8 @@ impl Solution {
} }
} }
``` ```
C语言 ### C：
```c ```c
/**c语言单链表的定义 /**c语言单链表的定义
* Definition for singly-linked list. * Definition for singly-linked list.
@ -412,7 +420,8 @@ struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
``` ```
C#： ### C#：
```csharp ```csharp
public class Solution { public class Solution {
public ListNode RemoveNthFromEnd(ListNode head, int n) { public ListNode RemoveNthFromEnd(ListNode head, int n) {

61
problems/0024.两两交换链表中的节点.md
View File

@ -5,7 +5,7 @@
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
## 24. 两两交换链表中的节点 # 24. 两两交换链表中的节点
[力扣题目链接](https://leetcode.cn/problems/swap-nodes-in-pairs/) [力扣题目链接](https://leetcode.cn/problems/swap-nodes-in-pairs/)
@ -16,9 +16,11 @@
<img src='https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9-%E9%A2%98%E6%84%8F.jpg' width=600 alt='24.两两交换链表中的节点-题意'> </img></div> <img src='https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9-%E9%A2%98%E6%84%8F.jpg' width=600 alt='24.两两交换链表中的节点-题意'> </img></div>
## 思路 ## 算法公开课
《代码随想录》算法公开课：[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频在看本篇题解，更有助于大家对链表的理解。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路
这道题目正常模拟就可以了。 这道题目正常模拟就可以了。
@ -88,7 +90,8 @@ public:
## 其他语言版本 ## 其他语言版本
C: ### C:
```c ```c
/** /**
* Definition for singly-linked list. * Definition for singly-linked list.
@ -132,7 +135,7 @@ struct ListNode* swapPairs(struct ListNode* head){
} }
``` ```
Java： ### Java：
```Java ```Java
// 递归版本 // 递归版本
@ -176,7 +179,32 @@ class Solution {
} }
``` ```
Python： ### Python：
```python
# 递归版本
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
if head is None or head.next is None:
return head
# 待翻转的两个node分别是pre和cur
pre = head
cur = head.next
next = head.next.next
cur.next = pre # 交换
pre.next = self.swapPairs(next) # 将以next为head的后续链表两两交换
return cur
```
```python ```python
# Definition for singly-linked list. # Definition for singly-linked list.
# class ListNode: # class ListNode:
@ -202,7 +230,8 @@ class Solution:
``` ```
Go： ### Go：
```go ```go
func swapPairs(head *ListNode) *ListNode { func swapPairs(head *ListNode) *ListNode {
dummy := &ListNode{ dummy := &ListNode{
@ -238,7 +267,8 @@ func swapPairs(head *ListNode) *ListNode {
} }
``` ```
Javascript: ### Javascript:
```javascript ```javascript
var swapPairs = function (head) { var swapPairs = function (head) {
let ret = new ListNode(0, head), temp = ret; let ret = new ListNode(0, head), temp = ret;
@ -253,7 +283,7 @@ var swapPairs = function (head) {
}; };
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
function swapPairs(head: ListNode | null): ListNode | null { function swapPairs(head: ListNode | null): ListNode | null {
@ -272,7 +302,7 @@ function swapPairs(head: ListNode | null): ListNode | null {
}; };
``` ```
Kotlin: ### Kotlin:
```kotlin ```kotlin
fun swapPairs(head: ListNode?): ListNode? { fun swapPairs(head: ListNode?): ListNode? {
@ -292,7 +322,8 @@ fun swapPairs(head: ListNode?): ListNode? {
} }
``` ```
Swift: ### Swift:
```swift ```swift
func swapPairs(_ head: ListNode?) -> ListNode? { func swapPairs(_ head: ListNode?) -> ListNode? {
if head == nil || head?.next == nil { if head == nil || head?.next == nil {
@ -313,7 +344,8 @@ func swapPairs(_ head: ListNode?) -> ListNode? {
return dummyHead.next return dummyHead.next
} }
``` ```
Scala: ### Scala:
```scala ```scala
// 虚拟头节点 // 虚拟头节点
object Solution { object Solution {
@ -337,7 +369,8 @@ object Solution {
} }
``` ```
PHP: ### PHP:
```php ```php
//虚拟头结点 //虚拟头结点
function swapPairs($head) { function swapPairs($head) {
@ -380,7 +413,7 @@ function swapPairs($head)
} }
``` ```
Rust: ### Rust:
```rust ```rust
// 虚拟头节点 // 虚拟头节点

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

@ -5,7 +5,7 @@
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
## 27. 移除元素 # 27. 移除元素
[力扣题目链接](https://leetcode.cn/problems/remove-element/) [力扣题目链接](https://leetcode.cn/problems/remove-element/)
@ -159,8 +159,8 @@ public:
## 其他语言版本 ## 其他语言版本
### Java：
Java：
```java ```java
class Solution { class Solution {
public int removeElement(int[] nums, int val) { public int removeElement(int[] nums, int val) {
@ -197,7 +197,7 @@ class Solution {
} }
``` ```
Python： ### Python：
``` python 3 ``` python 3
@ -233,8 +233,8 @@ class Solution:
``` ```
### Go：
Go：
```go ```go
func removeElement(nums []int, val int) int { func removeElement(nums []int, val int) int {
length:=len(nums) length:=len(nums)
@ -275,7 +275,8 @@ func removeElement(nums []int, val int) int {
} }
``` ```
JavaScript: ### JavaScript:
```javascript ```javascript
//时间复杂度：O(n) //时间复杂度：O(n)
//空间复杂度：O(1) //空间复杂度：O(1)
@ -290,7 +291,7 @@ var removeElement = (nums, val) => {
}; };
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
function removeElement(nums: number[], val: number): number { function removeElement(nums: number[], val: number): number {
@ -305,7 +306,7 @@ function removeElement(nums: number[], val: number): number {
}; };
``` ```
Ruby: ### Ruby:
```ruby ```ruby
def remove_element(nums, val) def remove_element(nums, val)
@ -319,7 +320,8 @@ def remove_element(nums, val)
i i
end end
``` ```
Rust: ### Rust:
```rust ```rust
impl Solution { impl Solution {
pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 { pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 {
@ -335,7 +337,7 @@ impl Solution {
} }
``` ```
Swift: ### Swift:
```swift ```swift
func removeElement(_ nums: inout [Int], _ val: Int) -> Int { func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
@ -351,7 +353,8 @@ func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
} }
``` ```
PHP: ### PHP:
```php ```php
class Solution { class Solution {
/** /**
@ -375,7 +378,8 @@ class Solution {
} }
``` ```
C: ### C:
```c ```c
int removeElement(int* nums, int numsSize, int val){ int removeElement(int* nums, int numsSize, int val){
int slow = 0; int slow = 0;
@ -391,7 +395,8 @@ int removeElement(int* nums, int numsSize, int val){
} }
``` ```
Kotlin: ### Kotlin:
```kotlin ```kotlin
fun removeElement(nums: IntArray, `val`: Int): Int { fun removeElement(nums: IntArray, `val`: Int): Int {
var slowIndex = 0 // 初始化慢指针 var slowIndex = 0 // 初始化慢指针
@ -402,7 +407,8 @@ fun removeElement(nums: IntArray, `val`: Int): Int {
} }
``` ```
Scala: ### Scala:
```scala ```scala
object Solution { object Solution {
def removeElement(nums: Array[Int], `val`: Int): Int = { def removeElement(nums: Array[Int], `val`: Int): Int = {
@ -418,7 +424,8 @@ object Solution {
} }
``` ```
C#: ### C#:
```csharp ```csharp
public class Solution { public class Solution {
public int RemoveElement(int[] nums, int val) { public int RemoveElement(int[] nums, int val) {

33
problems/0059.螺旋矩阵II.md
View File

@ -26,7 +26,7 @@
## 算法公开课 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[拿下螺旋矩阵！LeetCode：59.螺旋矩阵II](https://www.bilibili.com/video/BV1SL4y1N7mV)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[拿下螺旋矩阵！LeetCode：59.螺旋矩阵II](https://www.bilibili.com/video/BV1SL4y1N7mV)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
这道题目可以说在面试中出现频率较高的题目，**本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。** 这道题目可以说在面试中出现频率较高的题目，**本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。**
@ -125,15 +125,15 @@ public:
## 类似题目 ## 类似题目
* 54.螺旋矩阵 * [54.螺旋矩阵](https://leetcode.cn/problems/spiral-matrix/)
* 剑指Offer 29.顺时针打印矩阵 * [剑指Offer 29.顺时针打印矩阵](https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/)
## 其他语言版本 ## 其他语言版本
Java： ### Java：
```Java ```Java
class Solution { class Solution {
@ -176,7 +176,7 @@ class Solution {
} }
``` ```
python3: ### python3:
```python ```python
class Solution: class Solution:
@ -207,7 +207,7 @@ class Solution:
return nums return nums
``` ```
javaScript ### JavaScript:
```javascript ```javascript
@ -259,7 +259,7 @@ var generateMatrix = function(n) {
``` ```
TypeScript: ### TypeScript:
```typescript ```typescript
function generateMatrix(n: number): number[][] { function generateMatrix(n: number): number[][] {
@ -304,7 +304,7 @@ function generateMatrix(n: number): number[][] {
}; };
``` ```
Go: ### Go:
```go ```go
package main package main
@ -397,7 +397,7 @@ func generateMatrix(n int) [][]int {
} }
``` ```
Swift: ### Swift:
```swift ```swift
func generateMatrix(_ n: Int) -> [[Int]] { func generateMatrix(_ n: Int) -> [[Int]] {
@ -453,7 +453,7 @@ func generateMatrix(_ n: Int) -> [[Int]] {
} }
``` ```
Rust: ### Rust:
```rust ```rust
impl Solution { impl Solution {
@ -506,7 +506,8 @@ impl Solution {
} }
``` ```
PHP: ### PHP:
```php ```php
class Solution { class Solution {
/** /**
@ -548,7 +549,8 @@ class Solution {
} }
``` ```
C: ### C:
```c ```c
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){ int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
//初始化返回的结果数组的大小 //初始化返回的结果数组的大小
@ -607,7 +609,8 @@ int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
return ans; return ans;
} }
``` ```
Scala: ### Scala:
```scala ```scala
object Solution { object Solution {
def generateMatrix(n: Int): Array[Array[Int]] = { def generateMatrix(n: Int): Array[Array[Int]] = {
@ -659,7 +662,8 @@ object Solution {
} }
} }
``` ```
C#： ### C#：
```csharp ```csharp
public class Solution { public class Solution {
public int[][] GenerateMatrix(int n) { public int[][] GenerateMatrix(int n) {
@ -688,3 +692,4 @@ public class Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

45
problems/0123.买卖股票的最佳时机III.md
View File

@ -413,7 +413,52 @@ function maxProfit(prices: number[]): number {
}; };
``` ```
Rust：
> 版本一
```rust
impl Solution {
pub fn max_profit(prices: Vec<i32>) -> i32 {
/*
* 定义 5 种状态:
* 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出
*/
let mut dp = vec![vec![0; 5]; prices.len()];
dp[0][1] = -prices[0];
dp[0][3] = -prices[0];
for (i, &p) in prices.iter().enumerate().skip(1) {
// 不操作
// dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1].max(-p);
dp[i][2] = dp[i - 1][2].max(dp[i - 1][1] + p);
dp[i][3] = dp[i - 1][3].max(dp[i - 1][2] - p);
dp[i][4] = dp[i - 1][4].max(dp[i - 1][3] + p);
}
dp[prices.len() - 1][4]
}
}
```
> 版本二（绕）
```rust
impl Solution {
pub fn max_profit(prices: Vec<i32>) -> i32 {
let (mut one_buy, mut one_sale, mut two_buy, mut two_sale) = (-prices[0], 0, -prices[0], 0);
for p in prices {
one_buy = one_buy.max(-p);
one_sale = one_sale.max(p + one_buy);
two_buy = two_buy.max(one_sale - p);
two_sale = two_sale.max(two_buy + p);
}
two_sale
}
}
```
<p align="center"> <p align="center">

11
problems/0141.环形链表.md
View File

@ -70,7 +70,7 @@ public:
## 其他语言版本 ## 其他语言版本
### Java ### Java:
```java ```java
public class Solution { public class Solution {
@ -90,7 +90,7 @@ public class Solution {
} }
``` ```
### Python ### Python:
```python ```python
class Solution: class Solution:
@ -105,7 +105,7 @@ class Solution:
return False return False
``` ```
### Go ### Go:
```go ```go
func hasCycle(head *ListNode) bool { func hasCycle(head *ListNode) bool {
@ -125,7 +125,7 @@ func hasCycle(head *ListNode) bool {
} }
``` ```
### JavaScript ### JavaScript:
```js ```js
var hasCycle = function(head) { var hasCycle = function(head) {
@ -141,7 +141,7 @@ var hasCycle = function(head) {
}; };
``` ```
### TypeScript ### TypeScript:
```typescript ```typescript
function hasCycle(head: ListNode | null): boolean { function hasCycle(head: ListNode | null): boolean {
@ -163,3 +163,4 @@ function hasCycle(head: ListNode | null): boolean {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

30
problems/0142.环形链表II.md
View File

@ -11,7 +11,7 @@
> 找到有没有环已经很不容易了，还要让我找到环的入口? > 找到有没有环已经很不容易了，还要让我找到环的入口?
## 142.环形链表II # 142.环形链表II
[力扣题目链接](https://leetcode.cn/problems/linked-list-cycle-ii/) [力扣题目链接](https://leetcode.cn/problems/linked-list-cycle-ii/)
@ -24,9 +24,11 @@
![循环链表](https://code-thinking-1253855093.file.myqcloud.com/pics/20200816110112704.png) ![循环链表](https://code-thinking-1253855093.file.myqcloud.com/pics/20200816110112704.png)
## 思路 ## 算法公开课
《代码随想录》算法公开课：[把环形链表讲清楚！| LeetCode:142.环形链表II](https://www.bilibili.com/video/BV1if4y1d7ob)，相信结合视频在看本篇题解，更有助于大家对链表的理解。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[把环形链表讲清楚！| LeetCode:142.环形链表II](https://www.bilibili.com/video/BV1if4y1d7ob)，相信结合视频在看本篇题解，更有助于大家对链表的理解。**
## 思路
这道题目，不仅考察对链表的操作，而且还需要一些数学运算。 这道题目，不仅考察对链表的操作，而且还需要一些数学运算。
@ -148,7 +150,7 @@ public:
* 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n * 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
* 空间复杂度: O(1) * 空间复杂度: O(1)
## 补充 ### 补充
在推理过程中，大家可能有一个疑问就是：**为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢？** 在推理过程中，大家可能有一个疑问就是：**为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢？**
@ -190,8 +192,7 @@ public:
## 其他语言版本 ## 其他语言版本
### Java：
Java：
```java ```java
public class Solution { public class Solution {
@ -217,8 +218,7 @@ public class Solution {
} }
``` ```
### Python：
Python：
```python ```python
（版本一）快慢指针法 （版本一）快慢指针法
@ -270,7 +270,7 @@ class Solution:
return None return None
``` ```
Go： ### Go：
```go ```go
func detectCycle(head *ListNode) *ListNode { func detectCycle(head *ListNode) *ListNode {
@ -290,7 +290,7 @@ func detectCycle(head *ListNode) *ListNode {
} }
``` ```
javaScript ### JavaScript
```js ```js
// 两种循环实现方式 // 两种循环实现方式
@ -334,7 +334,7 @@ var detectCycle = function(head) {
}; };
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
function detectCycle(head: ListNode | null): ListNode | null { function detectCycle(head: ListNode | null): ListNode | null {
@ -356,7 +356,7 @@ function detectCycle(head: ListNode | null): ListNode | null {
}; };
``` ```
Swift: ### Swift:
```swift ```swift
class Solution { class Solution {
@ -391,7 +391,7 @@ extension ListNode: Equatable {
} }
``` ```
C： ### C：
```c ```c
ListNode *detectCycle(ListNode *head) { ListNode *detectCycle(ListNode *head) {
@ -410,7 +410,7 @@ ListNode *detectCycle(ListNode *head) {
} }
``` ```
Scala: ### Scala:
```scala ```scala
object Solution { object Solution {
@ -437,7 +437,7 @@ object Solution {
} }
``` ```
C#: ### C#:
```CSharp ```CSharp
public class Solution public class Solution
{ {

49
problems/0188.买卖股票的最佳时机IV.md
View File

@ -474,6 +474,55 @@ function maxProfit(k: number, prices: number[]): number {
}; };
``` ```
Rust：
```rust
impl Solution {
pub fn max_profit(k: i32, prices: Vec<i32>) -> i32 {
let mut dp = vec![vec![0; 2 * k as usize + 1]; prices.len()];
for v in dp[0].iter_mut().skip(1).step_by(2) {
*v = -prices[0];
}
for (i, &p) in prices.iter().enumerate().skip(1) {
for j in (0..2 * k as usize - 1).step_by(2) {
dp[i][j + 1] = dp[i - 1][j + 1].max(dp[i - 1][j] - p);
dp[i][j + 2] = dp[i - 1][j + 2].max(dp[i - 1][j + 1] + p);
}
}
dp[prices.len() - 1][2 * k as usize]
}
}
```
空间优化：
```rust
impl Solution {
pub fn max_profit(k: i32, prices: Vec<i32>) -> i32 {
let mut dp = vec![0; 2 * k as usize + 1];
for v in dp.iter_mut().skip(1).step_by(2) {
*v = -prices[0];
}
for p in prices {
for i in 1..=2 * k as usize {
if i % 2 == 1 {
// 买入
dp[i] = dp[i].max(dp[i - 1] - p);
continue;
}
// 卖出
dp[i] = dp[i].max(dp[i - 1] + p);
}
}
dp[2 * k as usize]
}
}
```
<p align="center"> <p align="center">

44
problems/0200.岛屿数量.广搜版.md
View File

@ -196,7 +196,51 @@ class Solution {
} }
} }
``` ```
## 其他语言版本
### Python
BFS solution
```python
class Solution:
def __init__(self):
self.dirs = [[0, 1], [1, 0], [-1, 0], [0, -1]]
def numIslands(self, grid: List[List[str]]) -> int:
m = len(grid)
n = len(grid[0])
visited = [[False]*n for _ in range(m)]
res = 0
for i in range(m):
for j in range(n):
if visited[i][j] == False and grid[i][j] == '1':
res += 1
self.bfs(grid, i, j, visited) # Call bfs within this condition
return res
def bfs(self, grid, i, j, visited):
q = deque()
q.append((i,j))
visited[i][j] = True
while q:
x, y = q.popleft()
for k in range(4):
next_i = x + self.dirs[k][0]
next_j = y + self.dirs[k][1]
if next_i < 0 or next_i >= len(grid):
continue
if next_j < 0 or next_j >= len(grid[0]):
continue
if visited[next_i][next_j]:
continue
if grid[next_i][next_j] == '0':
continue
q.append((next_i, next_j))
visited[next_i][next_j] = True
```
<p align="center"> <p align="center">
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>
```

35
problems/0203.移除链表元素.md
View File

@ -27,14 +27,12 @@
输入：head = [7,7,7,7], val = 7 输入：head = [7,7,7,7], val = 7
输出：[] 输出：[]
# 算法公开课 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[链表基础操作| LeetCode：203.移除链表元素](https://www.bilibili.com/video/BV18B4y1s7R9)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[链表基础操作| LeetCode：203.移除链表元素](https://www.bilibili.com/video/BV18B4y1s7R9)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
# 思路 ## 思路
为了方便大家理解，我特意录制了视频：[链表基础操作| LeetCode：203.移除链表元素](https://www.bilibili.com/video/BV18B4y1s7R9)，结合视频在看本题解，事半功倍。
这里以链表 1 4 2 4 来举例，移除元素4。 这里以链表 1 4 2 4 来举例，移除元素4。
@ -90,9 +88,6 @@
最后呢在题目中，return 头结点的时候，别忘了 `return dummyNode->next;`， 这才是新的头结点 最后呢在题目中，return 头结点的时候，别忘了 `return dummyNode->next;`， 这才是新的头结点
# C++代码
**直接使用原来的链表来进行移除节点操作：** **直接使用原来的链表来进行移除节点操作：**
```CPP ```CPP
@ -159,7 +154,7 @@ public:
## 其他语言版本 ## 其他语言版本
C: ### C:
用原来的链表操作： 用原来的链表操作：
```c ```c
@ -227,7 +222,7 @@ struct ListNode* removeElements(struct ListNode* head, int val){
} }
``` ```
Java： ### Java：
```java ```java
/** /**
@ -308,7 +303,7 @@ public ListNode removeElements(ListNode head, int val) {
} }
``` ```
Python： ### Python：
```python ```python
（版本一）虚拟头节点法 （版本一）虚拟头节点法
@ -334,7 +329,7 @@ class Solution:
``` ```
Go： ### Go：
```go ```go
/** /**
@ -359,7 +354,7 @@ func removeElements(head *ListNode, val int) *ListNode {
} }
``` ```
javaScript: ### JavaScript:
```js ```js
/** /**
@ -381,7 +376,7 @@ var removeElements = function(head, val) {
}; };
``` ```
TypeScript: ### TypeScript:
版本一（在原链表上直接删除）： 版本一（在原链表上直接删除）：
@ -437,7 +432,7 @@ function removeElements(head: ListNode | null, val: number): ListNode | null {
}; };
``` ```
Swift： ### Swift：
```swift ```swift
/** /**
@ -465,7 +460,7 @@ func removeElements(_ head: ListNode?, _ val: Int) -> ListNode? {
} }
``` ```
PHP: ### PHP:
```php ```php
/** /**
@ -493,7 +488,7 @@ func removeElements(head *ListNode, val int) *ListNode {
} }
``` ```
RUST: ### Rust:
```rust ```rust
// Definition for singly-linked list. // Definition for singly-linked list.
@ -531,7 +526,7 @@ impl Solution {
} }
``` ```
Scala: ### Scala:
```scala ```scala
/** /**
@ -564,7 +559,7 @@ object Solution {
} }
``` ```
Kotlin: ### Kotlin:
```kotlin ```kotlin
/** /**
@ -600,7 +595,8 @@ class Solution {
} }
``` ```
C# ### C#
```CSharp ```CSharp
/** /**
* Definition for singly-linked list. * Definition for singly-linked list.
@ -639,3 +635,4 @@ public class Solution
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

55
problems/0206.翻转链表.md
View File

@ -17,14 +17,12 @@
输入: 1->2->3->4->5->NULL 输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL 输出: 5->4->3->2->1->NULL
# 算法公开课 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[帮你拿下反转链表 | LeetCode：206.反转链表](https://www.bilibili.com/video/BV1nB4y1i7eL)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[帮你拿下反转链表 | LeetCode：206.反转链表](https://www.bilibili.com/video/BV1nB4y1i7eL)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
# 思路 ## 思路
本题我录制了B站视频，[帮你拿下反转链表 | LeetCode：206.反转链表](https://www.bilibili.com/video/BV1nB4y1i7eL)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。 如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。
@ -51,9 +49,7 @@
最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点。 最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点。
# C++代码 ### 双指针法
## 双指针法
```CPP ```CPP
class Solution { class Solution {
public: public:
@ -76,7 +72,7 @@ public:
* 时间复杂度: O(n) * 时间复杂度: O(n)
* 空间复杂度: O(1) * 空间复杂度: O(1)
## 递归法 ### 递归法
递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。 递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。
@ -137,8 +133,8 @@ public:
## 其他语言版本 ## 其他语言版本
### Java：
Java：
```java ```java
// 双指针 // 双指针
class Solution { class Solution {
@ -198,7 +194,8 @@ class Solution {
} }
``` ```
Python ### Python：
```python ```python
（版本一）双指针法 （版本一）双指针法
# Definition for singly-linked list. # Definition for singly-linked list.
@ -219,8 +216,6 @@ class Solution:
return pre return pre
``` ```
Python递归法：
```python ```python
（版本二）递归法 （版本二）递归法
# Definition for singly-linked list. # Definition for singly-linked list.
@ -242,7 +237,7 @@ class Solution:
Go： ### Go：
```go ```go
//双指针 //双指针
@ -273,7 +268,7 @@ func help(pre, head *ListNode)*ListNode{
} }
``` ```
javaScript: ### JavaScript:
```js ```js
/** /**
@ -328,7 +323,7 @@ var reverseList = function(head) {
}; };
``` ```
TypeScript: ### TypeScript:
```typescript ```typescript
// 双指针法 // 双指针法
@ -376,7 +371,7 @@ function reverseList(head: ListNode | null): ListNode | null {
}; };
``` ```
Ruby: ### Ruby:
```ruby ```ruby
# 双指针 # 双指针
@ -421,7 +416,8 @@ def reverse(pre, cur)
end end
``` ```
Kotlin: ### Kotlin:
```Kotlin ```Kotlin
fun reverseList(head: ListNode?): ListNode? { fun reverseList(head: ListNode?): ListNode? {
var pre: ListNode? = null var pre: ListNode? = null
@ -471,7 +467,8 @@ class Solution {
} }
``` ```
Swift： ### Swift：
```swift ```swift
/// 双指针法 (迭代) /// 双指针法 (迭代)
/// - Parameter head: 头结点 /// - Parameter head: 头结点
@ -508,8 +505,9 @@ func reverse(pre: ListNode?, cur: ListNode?) -> ListNode? {
} }
``` ```
C: ### C:
双指针法： 双指针法：
```c ```c
struct ListNode* reverseList(struct ListNode* head){ struct ListNode* reverseList(struct ListNode* head){
//保存cur的下一个结点 //保存cur的下一个结点
@ -549,7 +547,8 @@ struct ListNode* reverseList(struct ListNode* head){
PHP: ### PHP:
```php ```php
// 双指针法： // 双指针法：
function reverseList($head) { function reverseList($head) {
@ -565,8 +564,9 @@ function reverseList($head) {
} }
``` ```
Scala: ### Scala:
双指针法： 双指针法：
```scala ```scala
object Solution { object Solution {
def reverseList(head: ListNode): ListNode = { def reverseList(head: ListNode): ListNode = {
@ -601,7 +601,7 @@ object Solution {
} }
``` ```
Rust: ### Rust:
双指针法： 双指针法：
```rust ```rust
@ -640,7 +640,7 @@ impl Solution {
} }
} }
``` ```
C#: ### C#:
三指针法， 感觉会更直观： 三指针法， 感觉会更直观：
```cs ```cs
@ -677,11 +677,11 @@ public class LinkNumbers
} }
``` ```
## 其他解法
### 使用虚拟头结点解决链表反转
## 使用虚拟头结点解决链表翻转 > 使用虚拟头结点，通过头插法实现链表的反转（不需要栈）
> 使用虚拟头结点，通过头插法实现链表的翻转（不需要栈）
```java ```java
// 迭代方法：增加虚头结点，使用头插法实现链表翻转 // 迭代方法：增加虚头结点，使用头插法实现链表翻转
@ -704,7 +704,7 @@ public static ListNode reverseList1(ListNode head) {
## 使用栈解决反转链表的问题 ### 使用栈解决反转链表的问题
* 首先将所有的结点入栈 * 首先将所有的结点入栈
* 然后创建一个虚拟虚拟头结点，让cur指向虚拟头结点。然后开始循环出栈，每出来一个元素，就把它加入到以虚拟头结点为头结点的链表当中，最后返回即可。 * 然后创建一个虚拟虚拟头结点，让cur指向虚拟头结点。然后开始循环出栈，每出来一个元素，就把它加入到以虚拟头结点为头结点的链表当中，最后返回即可。
@ -743,4 +743,3 @@ public ListNode reverseList(ListNode head) {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

41
problems/0209.长度最小的子数组.md
View File

@ -23,14 +23,14 @@
* 1 <= nums.length <= 10^5 * 1 <= nums.length <= 10^5
* 1 <= nums[i] <= 10^5 * 1 <= nums[i] <= 10^5
# 算法公开课 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[拿下滑动窗口！ | LeetCode 209 长度最小的子数组](https://www.bilibili.com/video/BV1tZ4y1q7XE)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[拿下滑动窗口！ | LeetCode 209 长度最小的子数组](https://www.bilibili.com/video/BV1tZ4y1q7XE)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
# 思路 ## 思路
## 暴力解法 ### 暴力解法
这道题目暴力解法当然是 两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)。 这道题目暴力解法当然是 两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)。
@ -64,7 +64,7 @@ public:
后面力扣更新了数据，暴力解法已经超时了。 后面力扣更新了数据，暴力解法已经超时了。
## 滑动窗口 ### 滑动窗口
接下来就开始介绍数组操作中另一个重要的方法：**滑动窗口**。 接下来就开始介绍数组操作中另一个重要的方法：**滑动窗口**。
@ -151,8 +151,8 @@ public:
## 其他语言版本 ## 其他语言版本
### Java：
Java：
```java ```java
class Solution { class Solution {
@ -173,7 +173,7 @@ class Solution {
} }
``` ```
Python： ### Python：
```python ```python
（版本一）滑动窗口法 （版本一）滑动窗口法
@ -216,7 +216,8 @@ class Solution:
return min_len if min_len != float('inf') else 0 return min_len if min_len != float('inf') else 0
``` ```
Go： ### Go：
```go ```go
func minSubArrayLen(target int, nums []int) int { func minSubArrayLen(target int, nums []int) int {
i := 0 i := 0
@ -242,8 +243,7 @@ func minSubArrayLen(target int, nums []int) int {
} }
``` ```
### JavaScript:
JavaScript:
```js ```js
var minSubArrayLen = function(target, nums) { var minSubArrayLen = function(target, nums) {
@ -266,7 +266,7 @@ var minSubArrayLen = function(target, nums) {
}; };
``` ```
Typescript： ### Typescript：
```typescript ```typescript
function minSubArrayLen(target: number, nums: number[]): number { function minSubArrayLen(target: number, nums: number[]): number {
@ -288,7 +288,7 @@ function minSubArrayLen(target: number, nums: number[]): number {
}; };
``` ```
Swift: ### Swift:
```swift ```swift
func minSubArrayLen(_ target: Int, _ nums: [Int]) -> Int { func minSubArrayLen(_ target: Int, _ nums: [Int]) -> Int {
@ -309,7 +309,7 @@ func minSubArrayLen(_ target: Int, _ nums: [Int]) -> Int {
} }
``` ```
Rust: ### Rust:
```rust ```rust
impl Solution { impl Solution {
@ -336,7 +336,8 @@ impl Solution {
} }
``` ```
PHP: ### PHP:
```php ```php
// 双指针 - 滑动窗口 // 双指针 - 滑动窗口
class Solution { class Solution {
@ -365,7 +366,7 @@ class Solution {
} }
``` ```
Ruby: ### Ruby:
```ruby ```ruby
def min_sub_array_len(target, nums) def min_sub_array_len(target, nums)
@ -383,8 +384,9 @@ def min_sub_array_len(target, nums)
end end
``` ```
C: ### C:
暴力解法: 暴力解法:
```c ```c
int minSubArrayLen(int target, int* nums, int numsSize){ int minSubArrayLen(int target, int* nums, int numsSize){
//初始化最小长度为INT_MAX //初始化最小长度为INT_MAX
@ -433,7 +435,8 @@ int minSubArrayLen(int target, int* nums, int numsSize){
} }
``` ```
Kotlin: ### Kotlin:
```kotlin ```kotlin
class Solution { class Solution {
fun minSubArrayLen(target: Int, nums: IntArray): Int { fun minSubArrayLen(target: Int, nums: IntArray): Int {
@ -485,7 +488,7 @@ class Solution {
} }
} }
``` ```
Scala: ### Scala:
滑动窗口: 滑动窗口:
```scala ```scala
@ -533,7 +536,8 @@ object Solution {
} }
} }
``` ```
C#: ### C#:
```csharp ```csharp
public class Solution { public class Solution {
public int MinSubArrayLen(int s, int[] nums) { public int MinSubArrayLen(int s, int[] nums) {
@ -559,3 +563,4 @@ public class Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

47
problems/0463.岛屿的周长.md
View File

@ -142,6 +142,53 @@ class Solution {
return landSum * 4 - cover * 2; return landSum * 4 - cover * 2;
} }
} }
// 延伸 - 傳統DFS解法(使用visited數組)（遇到邊界 或是 海水 就edge ++）
class Solution {
int dir[][] ={
{0, 1},
{0, -1},
{1, 0},
{-1, 0}
};
boolean visited[][];
int res = 0;
public int islandPerimeter(int[][] grid) {
int row = grid.length;
int col = grid[0].length;
visited = new boolean[row][col];
int result = 0;
for(int i = 0; i < row; i++){
for(int j = 0; j < col; j++){
if(visited[i][j] == false && grid[i][j] == 1)
result += dfs(grid, i, j);
}
}
return result;
}
private int dfs(int[][] grid, int x, int y){
//如果遇到 邊界（x < 0 || y < 0 || x >= grid.length || y >= grid[0].length）或是 遇到海水(grid[x][y] == 0)就return 1（edge + 1）
if(x < 0 || y < 0 || x >= grid.length || y >= grid[0].length || grid[x][y] == 0)
return 1;
//如果該地已經拜訪過，就return 0 避免重複計算
if(visited[x][y])
return 0;
int temp = 0;
visited[x][y] = true;
for(int i = 0; i < 4; i++){
int nextX = x + dir[i][0];
int nextY = y + dir[i][1];
//用temp 把edge存起來
temp +=dfs(grid, nextX, nextY);
}
return temp;
}
}
``` ```
Python： Python：

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

@ -5,7 +5,7 @@
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
## 704. 二分查找 # 704. 二分查找
[力扣题目链接](https://leetcode.cn/problems/binary-search/) [力扣题目链接](https://leetcode.cn/problems/binary-search/)
@ -35,7 +35,7 @@
## 算法公开课 ## 算法公开课
***[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[手把手带你撕出正确的二分法](https://www.bilibili.com/video/BV1fA4y1o715)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[手把手带你撕出正确的二分法](https://www.bilibili.com/video/BV1fA4y1o715)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
@ -160,7 +160,7 @@ public:
## 其他语言版本 ## 其他语言版本
**Java：** ### **Java：**
（版本一）左闭右闭区间 （版本一）左闭右闭区间
@ -206,7 +206,7 @@ class Solution {
} }
``` ```
**Python：** ### **Python：**
（版本一）左闭右闭区间 （版本一）左闭右闭区间
@ -246,7 +246,7 @@ class Solution:
return -1 # 未找到目标值 return -1 # 未找到目标值
``` ```
**Go：** ### **Go：**
（版本一）左闭右闭区间 （版本一）左闭右闭区间
@ -288,7 +288,7 @@ func search(nums []int, target int) int {
} }
``` ```
**JavaScript:** ### **JavaScript:**
（版本一）左闭右闭区间 [left, right] （版本一）左闭右闭区间 [left, right]
```js ```js
@ -345,7 +345,7 @@ var search = function(nums, target) {
}; };
``` ```
**TypeScript** ### **TypeScript**
（版本一）左闭右闭区间 （版本一）左闭右闭区间
@ -387,7 +387,7 @@ function search(nums: number[], target: number): number {
}; };
``` ```
**Ruby:** ### **Ruby:**
```ruby ```ruby
# （版本一）左闭右闭区间 # （版本一）左闭右闭区间
@ -425,7 +425,7 @@ def search(nums, target)
end end
``` ```
**Swift:** ### **Swift:**
```swift ```swift
// （版本一）左闭右闭区间 // （版本一）左闭右闭区间
@ -479,7 +479,7 @@ func search(nums: [Int], target: Int) -> Int {
``` ```
**Rust:** ### **Rust:**
```rust ```rust
# （版本一）左闭右闭区间 # （版本一）左闭右闭区间
@ -523,7 +523,8 @@ impl Solution {
} }
``` ```
**C:** ### **C:**
```c ```c
// (版本一) 左闭右闭区间 [left, right] // (版本一) 左闭右闭区间 [left, right]
int search(int* nums, int numsSize, int target){ int search(int* nums, int numsSize, int target){
@ -575,7 +576,8 @@ int search(int* nums, int numsSize, int target){
} }
``` ```
**PHP:** ### **PHP:**
```php ```php
// 左闭右闭区间 // 左闭右闭区间
class Solution { class Solution {
@ -607,7 +609,8 @@ class Solution {
} }
``` ```
**C#:** ### **C#:**
```csharp ```csharp
//左闭右闭 //左闭右闭
public class Solution { public class Solution {
@ -652,7 +655,8 @@ public class Solution{
} }
``` ```
**Kotlin:** ### **Kotlin:**
```kotlin ```kotlin
class Solution { class Solution {
fun search(nums: IntArray, target: Int): Int { fun search(nums: IntArray, target: Int): Int {
@ -682,9 +686,8 @@ class Solution {
} }
``` ```
### **Kotlin:**
**Kotlin:**
```Kotlin ```Kotlin
// （版本一）左闭右开区间 // （版本一）左闭右开区间
class Solution { class Solution {
@ -715,7 +718,7 @@ class Solution {
} }
} }
``` ```
**Scala:** ### **Scala:**
（版本一）左闭右闭区间 （版本一）左闭右闭区间
```scala ```scala

34
problems/0707.设计链表.md
View File

@ -25,12 +25,12 @@
![707示例](https://code-thinking-1253855093.file.myqcloud.com/pics/20200814200558953.png) ![707示例](https://code-thinking-1253855093.file.myqcloud.com/pics/20200814200558953.png)
# 算法公开课 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[帮你把链表操作学个通透！LeetCode：707.设计链表](https://www.bilibili.com/video/BV1FU4y1X7WD)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[帮你把链表操作学个通透！LeetCode：707.设计链表](https://www.bilibili.com/video/BV1FU4y1X7WD)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
# 思路 ## 思路
如果对链表的基础知识还不太懂，可以看这篇文章：[关于链表，你该了解这些！](https://programmercarl.com/链表理论基础.html) 如果对链表的基础知识还不太懂，可以看这篇文章：[关于链表，你该了解这些！](https://programmercarl.com/链表理论基础.html)
@ -58,8 +58,6 @@
下面采用的设置一个虚拟头结点（这样更方便一些，大家看代码就会感受出来）。 下面采用的设置一个虚拟头结点（这样更方便一些，大家看代码就会感受出来）。
## 代码
```CPP ```CPP
class MyLinkedList { class MyLinkedList {
public: public:
@ -167,7 +165,8 @@ private:
## 其他语言版本 ## 其他语言版本
C: ### C:
```C ```C
typedef struct MyLinkedList { typedef struct MyLinkedList {
int val; int val;
@ -291,7 +290,8 @@ void myLinkedListFree(MyLinkedList* obj) {
*/ */
``` ```
Java： ### Java：
```Java ```Java
//单链表 //单链表
class ListNode { class ListNode {
@ -487,7 +487,8 @@ class MyLinkedList {
*/ */
``` ```
Python： ### Python：
```python ```python
（版本一）单链表法 （版本一）单链表法
class ListNode: class ListNode:
@ -661,7 +662,7 @@ class MyLinkedList:
# obj.deleteAtIndex(index) # obj.deleteAtIndex(index)
``` ```
Go： ### Go：
```go ```go
//单链表实现 //单链表实现
@ -915,7 +916,7 @@ func (this *MyLinkedList) DeleteAtIndex(index int) {
} }
``` ```
javaScript: ### JavaScript:
```js ```js
@ -1055,7 +1056,8 @@ MyLinkedList.prototype.deleteAtIndex = function(index) {
*/ */
``` ```
TypeScript: ### TypeScript:
```TypeScript ```TypeScript
class ListNode { class ListNode {
public val: number; public val: number;
@ -1173,7 +1175,8 @@ class MyLinkedList {
} }
``` ```
Kotlin: ### Kotlin:
```kotlin ```kotlin
class MyLinkedList { class MyLinkedList {
@ -1241,8 +1244,7 @@ class MyLinkedList {
} }
``` ```
### Swift:
Swift:
```swift ```swift
class MyLinkedList { class MyLinkedList {
@ -1323,7 +1325,8 @@ class MyLinkedList {
} }
``` ```
Scala: ### Scala:
```scala ```scala
class ListNode(_x: Int = 0, _next: ListNode = null) { class ListNode(_x: Int = 0, _next: ListNode = null) {
var next: ListNode = _next var next: ListNode = _next
@ -1393,7 +1396,7 @@ class MyLinkedList() {
} }
``` ```
Rust: ### Rust:
```rust ```rust
#[derive(Debug)] #[derive(Debug)]
@ -1486,4 +1489,3 @@ impl MyLinkedList {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

42
problems/0977.有序数组的平方.md
View File

@ -21,14 +21,14 @@
* 输入：nums = [-7,-3,2,3,11] * 输入：nums = [-7,-3,2,3,11]
* 输出：[4,9,9,49,121] * 输出：[4,9,9,49,121]
# 算法公开课 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[双指针法经典题目!LeetCode:977.有序数组的平方](https://www.bilibili.com/video/BV1QB4y1D7ep)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[双指针法经典题目!LeetCode:977.有序数组的平方](https://www.bilibili.com/video/BV1QB4y1D7ep)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
# 思路 ## 思路
## 暴力排序 ### 暴力排序
最直观的想法，莫过于：每个数平方之后，排个序，美滋滋，代码如下： 最直观的想法，莫过于：每个数平方之后，排个序，美滋滋，代码如下：
@ -47,7 +47,7 @@ public:
这个时间复杂度是 O(n + nlogn)， 可以说是O(nlogn)的时间复杂度，但为了和下面双指针法算法时间复杂度有鲜明对比，我记为 O(n + nlog n)。 这个时间复杂度是 O(n + nlogn)， 可以说是O(nlogn)的时间复杂度，但为了和下面双指针法算法时间复杂度有鲜明对比，我记为 O(n + nlog n)。
## 双指针法 ### 双指针法
数组其实是有序的， 只不过负数平方之后可能成为最大数了。 数组其实是有序的， 只不过负数平方之后可能成为最大数了。
@ -99,7 +99,8 @@ public:
## 其他语言版本 ## 其他语言版本
Java： ### Java：
```Java ```Java
class Solution { class Solution {
public int[] sortedSquares(int[] nums) { public int[] sortedSquares(int[] nums) {
@ -141,7 +142,8 @@ class Solution {
} }
``` ```
Python： ### Python：
```Python ```Python
（版本一）双指针法 （版本一）双指针法
class Solution: class Solution:
@ -176,7 +178,8 @@ class Solution:
return sorted(x*x for x in nums) return sorted(x*x for x in nums)
``` ```
Go： ### Go：
```Go ```Go
func sortedSquares(nums []int) []int { func sortedSquares(nums []int) []int {
n := len(nums) n := len(nums)
@ -196,7 +199,8 @@ func sortedSquares(nums []int) []int {
return ans return ans
} }
``` ```
Rust ### Rust:
```rust ```rust
impl Solution { impl Solution {
pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> { pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> {
@ -217,7 +221,8 @@ impl Solution {
} }
} }
``` ```
Javascript： ### Javascript：
```Javascript ```Javascript
/** /**
* @param {number[]} nums * @param {number[]} nums
@ -242,7 +247,7 @@ var sortedSquares = function(nums) {
}; };
``` ```
Typescript： ### Typescript：
双指针法： 双指针法：
@ -277,7 +282,7 @@ function sortedSquares(nums: number[]): number[] {
}; };
``` ```
Swift: ### Swift:
```swift ```swift
func sortedSquares(_ nums: [Int]) -> [Int] { func sortedSquares(_ nums: [Int]) -> [Int] {
@ -305,7 +310,7 @@ func sortedSquares(_ nums: [Int]) -> [Int] {
} }
``` ```
Ruby: ### Ruby:
```ruby ```ruby
def sorted_squares(nums) def sorted_squares(nums)
@ -323,8 +328,8 @@ def sorted_squares(nums)
end end
``` ```
### C:
C:
```c ```c
int* sortedSquares(int* nums, int numsSize, int* returnSize){ int* sortedSquares(int* nums, int numsSize, int* returnSize){
//返回的数组大小就是原数组大小 //返回的数组大小就是原数组大小
@ -357,7 +362,8 @@ int* sortedSquares(int* nums, int numsSize, int* returnSize){
} }
``` ```
PHP: ### PHP:
```php ```php
class Solution { class Solution {
/** /**
@ -386,7 +392,7 @@ class Solution {
} }
``` ```
Kotlin: ### Kotlin:
双指针法 双指针法
```kotlin ```kotlin
@ -437,7 +443,7 @@ class Solution {
} }
``` ```
Scala: ### Scala:
双指针: 双指针:
```scala ```scala
@ -473,7 +479,8 @@ object Solution {
} }
``` ```
C#： ### C#：
```csharp ```csharp
public class Solution { public class Solution {
public int[] SortedSquares(int[] nums) { public int[] SortedSquares(int[] nums) {
@ -504,3 +511,4 @@ public class Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

16
problems/数组总结篇.md
View File

@ -4,9 +4,9 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 数组总结篇
## 数组理论基础
# 数组理论基础
数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力 数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力
@ -51,7 +51,7 @@
所以**Java的二维数组在内存中不是 `3*4` 的连续地址空间，而是四条连续的地址空间组成！** 所以**Java的二维数组在内存中不是 `3*4` 的连续地址空间，而是四条连续的地址空间组成！**
# 数组的经典题目 ## 数组的经典题目
在面试中，数组是必考的基础数据结构。 在面试中，数组是必考的基础数据结构。
@ -59,7 +59,7 @@
我们之前一共讲解了四道经典数组题目，每一道题目都代表一个类型，一种思想。 我们之前一共讲解了四道经典数组题目，每一道题目都代表一个类型，一种思想。
## 二分法 ### 二分法
[数组：每次遇到二分法，都是一看就会，一写就废](https://programmercarl.com/0704.二分查找.html) [数组：每次遇到二分法，都是一看就会，一写就废](https://programmercarl.com/0704.二分查找.html)
@ -75,7 +75,7 @@
**二分法是算法面试中的常考题，建议通过这道题目，锻炼自己手撕二分的能力**。 **二分法是算法面试中的常考题，建议通过这道题目，锻炼自己手撕二分的能力**。
## 双指针法 ### 双指针法
* [数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html) * [数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)
@ -91,7 +91,7 @@
双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组和链表操作的面试题，都使用双指针法。 双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组和链表操作的面试题，都使用双指针法。
## 滑动窗口 ### 滑动窗口
* [数组：滑动窗口拯救了你](https://programmercarl.com/0209.长度最小的子数组.html) * [数组：滑动窗口拯救了你](https://programmercarl.com/0209.长度最小的子数组.html)
@ -107,7 +107,7 @@
如果没有接触过这一类的方法，很难想到类似的解题思路，滑动窗口方法还是很巧妙的。 如果没有接触过这一类的方法，很难想到类似的解题思路，滑动窗口方法还是很巧妙的。
## 模拟行为 ### 模拟行为
* [数组：这个循环可以转懵很多人！](https://programmercarl.com/0059.螺旋矩阵II.html) * [数组：这个循环可以转懵很多人！](https://programmercarl.com/0059.螺旋矩阵II.html)
@ -118,7 +118,7 @@
相信大家有遇到过这种情况： 感觉题目的边界调节超多，一波接着一波的判断，找边界，拆了东墙补西墙，好不容易运行通过了，代码写的十分冗余，毫无章法，其实**真正解决题目的代码都是简洁的，或者有原则性的**，大家可以在这道题目中体会到这一点。 相信大家有遇到过这种情况： 感觉题目的边界调节超多，一波接着一波的判断，找边界，拆了东墙补西墙，好不容易运行通过了，代码写的十分冗余，毫无章法，其实**真正解决题目的代码都是简洁的，或者有原则性的**，大家可以在这道题目中体会到这一点。
# 总结 ## 总结
![](https://code-thinking-1253855093.file.myqcloud.com/pics/数组总结.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/数组总结.png)

2
problems/数组理论基础.md
View File

@ -6,7 +6,7 @@
## 数组理论基础 # 数组理论基础
数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力 数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力

5
problems/链表总结篇.md
View File

@ -3,7 +3,7 @@
<img src="../pics/训练营.png" width="1000"/> <img src="../pics/训练营.png" width="1000"/>
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 链表总结篇
## 链表的理论基础 ## 链表的理论基础
@ -68,7 +68,7 @@
[链表：链表相交](https://programmercarl.com/面试题02.07.链表相交.html)使用双指针来找到两个链表的交点（引用完全相同，即：内存地址完全相同的交点） [链表：链表相交](https://programmercarl.com/面试题02.07.链表相交.html)使用双指针来找到两个链表的交点（引用完全相同，即：内存地址完全相同的交点）
## 环形链表 ### 环形链表
在[链表：环找到了，那入口呢？](https://programmercarl.com/0142.环形链表II.html)中，讲解了在链表如何找环，以及如何找环的入口位置。 在[链表：环找到了，那入口呢？](https://programmercarl.com/0142.环形链表II.html)中，讲解了在链表如何找环，以及如何找环的入口位置。
@ -100,3 +100,4 @@
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

36
problems/链表理论基础.md
View File

@ -16,15 +16,15 @@
如图所示： 如图所示：
![链表1](https://code-thinking-1253855093.file.myqcloud.com/pics/20200806194529815.png) ![链表1](https://code-thinking-1253855093.file.myqcloud.com/pics/20200806194529815.png)
# 链表的类型 ## 链表的类型
接下来说一下链表的几种类型: 接下来说一下链表的几种类型:
## 单链表 ### 单链表
刚刚说的就是单链表。 刚刚说的就是单链表。
## 双链表 ### 双链表
单链表中的指针域只能指向节点的下一个节点。 单链表中的指针域只能指向节点的下一个节点。
@ -35,7 +35,7 @@
如图所示： 如图所示：
![链表2](https://code-thinking-1253855093.file.myqcloud.com/pics/20200806194559317.png) ![链表2](https://code-thinking-1253855093.file.myqcloud.com/pics/20200806194559317.png)
## 循环链表 ### 循环链表
循环链表，顾名思义，就是链表首尾相连。 循环链表，顾名思义，就是链表首尾相连。
@ -44,7 +44,7 @@
![链表4](https://code-thinking-1253855093.file.myqcloud.com/pics/20200806194629603.png) ![链表4](https://code-thinking-1253855093.file.myqcloud.com/pics/20200806194629603.png)
# 链表的存储方式 ## 链表的存储方式
了解完链表的类型，再来说一说链表在内存中的存储方式。 了解完链表的类型，再来说一说链表在内存中的存储方式。
@ -60,7 +60,7 @@
这个链表起始节点为2， 终止节点为7， 各个节点分布在内存的不同地址空间上，通过指针串联在一起。 这个链表起始节点为2， 终止节点为7， 各个节点分布在内存的不同地址空间上，通过指针串联在一起。
# 链表的定义 ## 链表的定义
接下来说一说链表的定义。 接下来说一说链表的定义。
@ -100,9 +100,9 @@ head->val = 5;
所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！ 所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！
# 链表的操作 ## 链表的操作
## 删除节点 ### 删除节点
删除D节点，如图所示： 删除D节点，如图所示：
@ -116,7 +116,7 @@ head->val = 5;
其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。 其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。
## 添加节点 ### 添加节点
如图所示： 如图所示：
@ -126,7 +126,7 @@ head->val = 5;
但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。 但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。
# 性能分析 ## 性能分析
再把链表的特性和数组的特性进行一个对比，如图所示： 再把链表的特性和数组的特性进行一个对比，如图所示：
@ -143,8 +143,7 @@ head->val = 5;
## 其他语言版本 ## 其他语言版本
### Java：
Java：
```java ```java
public class ListNode { public class ListNode {
@ -171,7 +170,7 @@ public class ListNode {
} }
``` ```
JavaScript: ### JavaScript:
```javascript ```javascript
class ListNode { class ListNode {
@ -184,7 +183,7 @@ class ListNode {
} }
``` ```
TypeScript: ### TypeScript:
```typescript ```typescript
class ListNode { class ListNode {
@ -197,7 +196,7 @@ class ListNode {
} }
``` ```
Python： ### Python：
```python ```python
class ListNode: class ListNode:
@ -206,7 +205,7 @@ class ListNode:
self.next = next self.next = next
``` ```
Go： ### Go：
```go ```go
type ListNode struct { type ListNode struct {
@ -215,7 +214,7 @@ type ListNode struct {
} }
``` ```
Scala: ### Scala:
```scala ```scala
class ListNode(_x: Int = 0, _next: ListNode = null) { class ListNode(_x: Int = 0, _next: ListNode = null) {
@ -224,7 +223,7 @@ class ListNode(_x: Int = 0, _next: ListNode = null) {
} }
``` ```
Rust: ### Rust:
```rust ```rust
#[derive(PartialEq, Eq, Clone, Debug)] #[derive(PartialEq, Eq, Clone, Debug)]
@ -246,3 +245,4 @@ impl<T> ListNode<T> {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

17
problems/面试题02.07.链表相交.md
View File

@ -34,6 +34,7 @@
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20211219221812.png)![](https://code-thinking-1253855093.file.myqcloud.com/pics/20211219221812.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20211219221812.png)![](https://code-thinking-1253855093.file.myqcloud.com/pics/20211219221812.png)
## 思路 ## 思路
@ -101,7 +102,7 @@ public:
## 其他语言版本 ## 其他语言版本
Java： ### Java：
```Java ```Java
public class Solution { public class Solution {
@ -150,8 +151,7 @@ public class Solution {
} }
``` ```
### Python：
Python：
```python ```python
@ -280,7 +280,7 @@ class Solution:
return pointerA return pointerA
``` ```
Go: ### Go:
```go ```go
func getIntersectionNode(headA, headB *ListNode) *ListNode { func getIntersectionNode(headA, headB *ListNode) *ListNode {
@ -341,7 +341,7 @@ func getIntersectionNode(headA, headB *ListNode) *ListNode {
} }
``` ```
JavaScript： ### JavaScript：
```js ```js
var getListLen = function(head) { var getListLen = function(head) {
@ -376,7 +376,7 @@ var getIntersectionNode = function(headA, headB) {
}; };
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
function getIntersectionNode(headA: ListNode | null, headB: ListNode | null): ListNode | null { function getIntersectionNode(headA: ListNode | null, headB: ListNode | null): ListNode | null {
@ -413,7 +413,7 @@ function getIntersectionNode(headA: ListNode | null, headB: ListNode | null): Li
}; };
``` ```
C： ### C：
```c ```c
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
@ -452,7 +452,7 @@ ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
} }
``` ```
Scala: ### Scala:
```scala ```scala
object Solution { object Solution {
@ -508,3 +508,4 @@ object Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>