+
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index fafef1f2..16312d0f 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -129,6 +129,36 @@ class Solution {
}
```
+
+```java
+class Solution {
+ public ListNode removeNthFromEnd(ListNode head, int n) {
+ // 创建一个新的哑节点，指向原链表头
+ ListNode s = new ListNode(-1, head);
+ // 递归调用remove方法，从哑节点开始进行删除操作
+ remove(s, n);
+ // 返回新链表的头（去掉可能的哑节点）
+ return s.next;
+ }
+
+ public int remove(ListNode p, int n) {
+ // 递归结束条件：如果当前节点为空，返回0
+ if (p == null) {
+ return 0;
+ }
+ // 递归深入到下一个节点
+ int net = remove(p.next, n);
+ // 如果当前节点是倒数第n个节点，进行删除操作
+ if (net == n) {
+ p.next = p.next.next;
+ }
+ // 返回当前节点的总深度
+ return net + 1;
+ }
+}
+```
+
+
### Python:
```python
diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index f2f5cdd1..2475138e 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -166,12 +166,35 @@ class Solution {
deque.pop();
}
}
- //最后判断栈中元素是否匹配
+ //遍历结束，如果栈为空，则括号全部匹配
return deque.isEmpty();
}
}
```
+```java
+// 解法二
+// 对应的另一半一定在栈顶
+class Solution {
+ public boolean isValid(String s) {
+ Stack
+
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index c59ec033..94966126 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -715,26 +715,65 @@ object Solution {
### C#：
```csharp
-public class Solution {
- public int[][] GenerateMatrix(int n) {
- int[][] answer = new int[n][];
- for(int i = 0; i < n; i++)
- answer[i] = new int[n];
- int start = 0;
- int end = n - 1;
- int tmp = 1;
- while(tmp < n * n)
- {
- for(int i = start; i < end; i++) answer[start][i] = tmp++;
- for(int i = start; i < end; i++) answer[i][end] = tmp++;
- for(int i = end; i > start; i--) answer[end][i] = tmp++;
- for(int i = end; i > start; i--) answer[i][start] = tmp++;
- start++;
- end--;
- }
- if(n % 2 == 1) answer[n / 2][n / 2] = tmp;
- return answer;
+public int[][] GenerateMatrix(int n)
+{
+ // 参考Carl的代码随想录里面C++的思路
+ // https://www.programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html#%E6%80%9D%E8%B7%AF
+ int startX = 0, startY = 0; // 定义每循环一个圈的起始位置
+ int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
+ int count = 1; // 用来给矩阵每个空格赋值
+ int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
+ int offset = 1;// 需要控制每一条边遍历的长度，每次循环右边界收缩一位
+
+ // 构建result二维数组
+ int[][] result = new int[n][];
+ for (int k = 0; k < n; k++)
+ {
+ result[k] = new int[n];
}
+
+ int i = 0, j = 0; // [i,j]
+ while (loop > 0)
+ {
+ i = startX;
+ j = startY;
+ // 四个For循环模拟转一圈
+ // 第一排，从左往右遍历，不取最右侧的值(左闭右开)
+ for (; j < n - offset; j++)
+ {
+ result[i][j] = count++;
+ }
+ // 右侧的第一列，从上往下遍历，不取最下面的值(左闭右开)
+ for (; i < n - offset; i++)
+ {
+ result[i][j] = count++;
+ }
+
+ // 最下面的第一行，从右往左遍历，不取最左侧的值(左闭右开)
+ for (; j > startY; j--)
+ {
+ result[i][j] = count++;
+ }
+
+ // 左侧第一列，从下往上遍历，不取最左侧的值(左闭右开)
+ for (; i > startX; i--)
+ {
+ result[i][j] = count++;
+ }
+ // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
+ startX++;
+ startY++;
+
+ // offset 控制每一圈里每一条边遍历的长度
+ offset++;
+ loop--;
+ }
+ if (n % 2 == 1)
+ {
+ // n 为奇数
+ result[mid][mid] = count;
+ }
+ return result;
}
```
diff --git a/problems/0070.爬楼梯.md b/problems/0070.爬楼梯.md
index a2f664a4..6a13a21c 100644
--- a/problems/0070.爬楼梯.md
+++ b/problems/0070.爬楼梯.md
@@ -130,8 +130,8 @@ public:
};
```
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
当然依然也可以，优化一下空间复杂度，代码如下：
@@ -154,8 +154,8 @@ public:
};
```
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
后面将讲解的很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化，**但我个人认为面试中能写出版本一就够了哈，清晰明了，如果面试官要求进一步优化空间的话，我们再去优化**。
@@ -524,3 +524,4 @@ impl Solution {
+
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 98e1e98a..ce53e49a 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1231,6 +1231,47 @@ impl Solution {
}
```
+#### C#:
+
+```C# 199.二叉树的右视图
+public class Solution
+{
+ public IList
diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
index 7c0b7cb1..3dbd59b9 100644
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@@ -639,7 +639,46 @@ func reverse(b []byte) {
}
}
```
-
+```go
+//双指针解法。指针逆序遍历，将遍历后得到的单词（间隔为空格，用以区分）顺序放置在额外空间
+//时间复杂度O(n)，空间复杂度O(n)
+func reverseWords(s string) string {
+ strBytes := []byte(s)
+ n := len(strBytes)
+ // 记录有效字符范围的起始和结束位置
+ start, end := 0, n-1
+ // 去除开头空格
+ for start < n && strBytes[start] == 32 {
+ start++
+ }
+ // 处理全是空格或空字符串情况
+ if start == n {
+ return ""
+ }
+ // 去除结尾空格
+ for end >= 0 && strBytes[end] == 32 {
+ end--
+ }
+ // 结果切片，预分配容量
+ res := make([]byte, 0, end-start+1)//这里挺重要的，本人之前没有预分配容量，每次循环都添加单词，导致内存超限（也可能就是我之前的思路有问题）
+ // 从后往前遍历有效字符范围
+ for i := end; i >= start; {
+ // 找单词起始位置，直接通过循环条件判断定位
+ for ; i >= start && strBytes[i] == 32; i-- {
+ }
+ j := i
+ for ; j >= start && strBytes[j]!= 32; j-- {
+ }
+ res = append(res, strBytes[j+1:i+1]...)
+ // 只在不是最后一个单词时添加空格
+ if j > start {
+ res = append(res, 32)
+ }
+ i = j
+ }
+ return string(res)
+}
+```
### JavaScript:
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index f0fe3a3c..73d9db1b 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -1277,6 +1277,95 @@ impl MyStack {
}
```
+### C:
+
+> C：单队列
+
+```c
+typedef struct Node {
+ int val;
+ struct Node *next;
+} Node_t;
+
+// 用单向链表实现queue
+typedef struct {
+ Node_t *head;
+ Node_t *foot;
+ int size;
+} MyStack;
+
+MyStack* myStackCreate() {
+ MyStack *obj = (MyStack *)malloc(sizeof(MyStack));
+ assert(obj);
+ obj->head = NULL;
+ obj->foot = NULL;
+ obj->size = 0;
+ return obj;
+}
+
+void myStackPush(MyStack* obj, int x) {
+
+ Node_t *temp = (Node_t *)malloc(sizeof(Node_t));
+ assert(temp);
+ temp->val = x;
+ temp->next = NULL;
+
+ // 添加至queue末尾
+ if (obj->foot) {
+ obj->foot->next = temp;
+ } else {
+ obj->head = temp;
+ }
+ obj->foot = temp;
+ obj->size++;
+}
+
+int myStackPop(MyStack* obj) {
+
+ // 获取末尾元素
+ int target = obj->foot->val;
+
+ if (obj->head == obj->foot) {
+ free(obj->foot);
+ obj->head = NULL;
+ obj->foot = NULL;
+ } else {
+
+ Node_t *prev = obj->head;
+ // 移动至queue尾部节点前一个节点
+ while (prev->next != obj->foot) {
+ prev = prev->next;
+ }
+
+ free(obj->foot);
+ obj->foot = prev;
+ obj->foot->next = NULL;
+ }
+
+ obj->size--;
+ return target;
+}
+
+int myStackTop(MyStack* obj) {
+ return obj->foot->val;
+}
+
+bool myStackEmpty(MyStack* obj) {
+ return obj->size == 0;
+}
+
+void myStackFree(MyStack* obj) {
+ Node_t *curr = obj->head;
+ while (curr != NULL) {
+ Node_t *temp = curr->next;
+ free(curr);
+ curr = temp;
+ }
+ free(obj);
+}
+
+```
+