From 6d826271dc78b310dc17f107915707115a5bd544 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Tue, 24 May 2022 11:11:51 +0800
Subject: [PATCH 01/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880941.=E6=9C=89?=
 =?UTF-8?q?=E6=95=88=E7=9A=84=E5=B1=B1=E8=84=89=E6=95=B0=E7=BB=84.md?=
 =?UTF-8?q?=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript=E7=89=88?=
 =?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0941.有效的山脉数组.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/problems/0941.有效的山脉数组.md b/problems/0941.有效的山脉数组.md
index 4b7a978c..7004e84c 100644
--- a/problems/0941.有效的山脉数组.md
+++ b/problems/0941.有效的山脉数组.md
@@ -157,6 +157,26 @@ var validMountainArray = function(arr) {
 };
 ```
 
+## TypeScript
+
+```typescript
+function validMountainArray(arr: number[]): boolean {
+    const length: number = arr.length;
+    if (length < 3) return false;
+    let left: number = 0,
+        right: number = length - 1;
+    while (left < (length - 1) && arr[left] < arr[left + 1]) {
+        left++;
+    }
+    while (right > 0 && arr[right] < arr[right - 1]) {
+        right--;
+    }
+    if (left === right && left !== 0 && right !== length - 1)
+        return true;
+    return false;
+};
+```
+
 
 
 

From 211f9f28dd6ed9f9540cd5feac9c8e9bd9f80568 Mon Sep 17 00:00:00 2001
From: SevenMonths <qinwen_shuai@163.com>
Date: Tue, 24 May 2022 14:39:04 +0800
Subject: [PATCH 02/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880344.=E5=8F=8D?=
 =?UTF-8?q?=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2.md=EF=BC=89=EF=BC=9APHP?=
 =?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0344.反转字符串.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/problems/0344.反转字符串.md b/problems/0344.反转字符串.md
index 58bada05..583d4f78 100644
--- a/problems/0344.反转字符串.md
+++ b/problems/0344.反转字符串.md
@@ -267,5 +267,34 @@ public class Solution
 }
 ```
 
+PHP：
+```php
+// 双指针
+// 一：
+function reverseString(&$s) {
+    $left = 0;
+    $right = count($s)-1;
+    while($left<$right){
+        $temp = $s[$left];
+        $s[$left] = $s[$right];
+        $s[$right] = $temp;
+        $left++;
+        $right--;
+    }
+}
+
+// 二：
+function reverseString(&$s) {
+    $this->reverse($s,0,count($s)-1);
+}
+// 按指定位置交换元素
+function reverse(&$s, $start, $end) {
+    for ($i = $start, $j = $end; $i < $j; $i++, $j--) {
+        $tmp = $s[$i];
+        $s[$i] = $s[$j];
+        $s[$j] = $tmp;
+    }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From ded66cf2f18df921edccfbfbf0325635c4fb04ad Mon Sep 17 00:00:00 2001
From: wang2jun <91008685+wang2jun@users.noreply.github.com>
Date: Tue, 24 May 2022 14:53:33 +0800
Subject: [PATCH 03/15] =?UTF-8?q?Update=200052.N=E7=9A=87=E5=90=8EII.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改错别字：想-》详
---
 problems/0052.N皇后II.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/problems/0052.N皇后II.md b/problems/0052.N皇后II.md
index 67e439ca..1c45a7f1 100644
--- a/problems/0052.N皇后II.md
+++ b/problems/0052.N皇后II.md
@@ -44,7 +44,7 @@ n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并
 # 思路
 
 
-想看：[51.N皇后](https://mp.weixin.qq.com/s/lU_QwCMj6g60nh8m98GAWg) ，基本没有区别
+详看：[51.N皇后](https://mp.weixin.qq.com/s/lU_QwCMj6g60nh8m98GAWg) ，基本没有区别
 
 # C++代码
 

From 3665c051d794a3abc3b350c8cc5cdb897ef54f76 Mon Sep 17 00:00:00 2001
From: SevenMonths <qinwen_shuai@163.com>
Date: Tue, 24 May 2022 16:53:39 +0800
Subject: [PATCH 04/15] =?UTF-8?q?=E5=A2=9E=E5=8A=A0(=E5=89=91=E6=8C=87Offe?=
 =?UTF-8?q?r05.=E6=9B=BF=E6=8D=A2=E7=A9=BA=E6=A0=BC.md)=EF=BC=9Aphp?=
 =?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/剑指Offer05.替换空格.md | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/problems/剑指Offer05.替换空格.md b/problems/剑指Offer05.替换空格.md
index 037bd427..63fb021a 100644
--- a/problems/剑指Offer05.替换空格.md
+++ b/problems/剑指Offer05.替换空格.md
@@ -415,6 +415,40 @@ func replaceSpace(_ s: String) -> String {
 
 
 
+PHP：
+```php
+function replaceSpace($s){
+    $sLen = strlen($s);
+    $moreLen = $this->spaceLen($s) * 2;
+
+    $head = $sLen - 1;
+    $tail = $sLen + $moreLen - 1;
+
+    $s = $s . str_repeat(' ', $moreLen);
+    while ($head != $tail) {
+        if ($s[$head] == ' ') {
+            $s[$tail--] = '0';
+            $s[$tail--] = '2';
+            $s[$tail] = '%';
+        } else {
+            $s[$tail] = $s[$head];
+        }
+        $head--;
+        $tail--;
+    }
+    return $s;
+}
+// 统计空格个数
+function spaceLen($s){
+    $count = 0;
+    for ($i = 0; $i < strlen($s); $i++) {
+        if ($s[$i] == ' ') {
+            $count++;
+        }
+    }
+    return $count;
+}
+```
 
 
 -----------------------

From a69ee03b3eea09f7e2bb113b631462eadd313482 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Tue, 24 May 2022 18:59:17 +0800
Subject: [PATCH 05/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200404.=E5=B7=A6?=
 =?UTF-8?q?=E5=8F=B6=E5=AD=90=E4=B9=8B=E5=92=8C.md=20Scala=E7=89=88?=
 =?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0404.左叶子之和.md | 38 ++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
index d7fd629e..78fc58f3 100644
--- a/problems/0404.左叶子之和.md
+++ b/problems/0404.左叶子之和.md
@@ -516,6 +516,44 @@ int sumOfLeftLeaves(struct TreeNode* root){
 }
 ```
 
+## Scala
+
+**递归:**
+```scala
+object Solution {
+  def sumOfLeftLeaves(root: TreeNode): Int = {
+    if(root == null) return 0
+    var midValue = 0
+    if(root.left != null && root.left.left == null && root.left.right == null){
+      midValue = root.left.value
+    }
+    // return关键字可以省略
+    midValue + sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right)
+  }
+}
+```
+
+**迭代:**
+```scala
+object Solution {
+  import scala.collection.mutable
+  def sumOfLeftLeaves(root: TreeNode): Int = {
+    val stack = mutable.Stack[TreeNode]()
+    if (root == null) return 0
+    stack.push(root)
+    var sum = 0
+    while (!stack.isEmpty) {
+      val curNode = stack.pop()
+      if (curNode.left != null && curNode.left.left == null && curNode.left.right == null) {
+        sum += curNode.left.value // 如果满足条件就累加
+      }
+      if (curNode.right != null) stack.push(curNode.right)
+      if (curNode.left != null) stack.push(curNode.left)
+    }
+    sum
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From 591cf193b0effd7606a4a50860804a25f06dea7c Mon Sep 17 00:00:00 2001
From: SevenMonths <qinwen_shuai@163.com>
Date: Tue, 24 May 2022 19:06:30 +0800
Subject: [PATCH 06/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0(0151.=E7=BF=BB?=
 =?UTF-8?q?=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2=E9=87=8C=E7=9A=84=E5=8D=95?=
 =?UTF-8?q?=E8=AF=8D.md)=EF=BC=9APHP=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0151.翻转字符串里的单词.md | 47 ++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
index d03de421..e76e05dd 100644
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@@ -761,6 +761,53 @@ func reverseWord(_ s: inout [Character]) {
 
 
 
+PHP:
+```php
+function reverseWords($s) {
+    $this->removeExtraSpaces($s); 
+    $this->reverseString($s, 0, strlen($s)-1);
+    // 将每个单词反转
+    $start = 0; 
+    for ($i = 0; $i <= strlen($s); $i++) {
+        // 到达空格或者串尾，说明一个单词结束。进行翻转。
+        if ($i == strlen($s) || $s[$i] == ' ') { 
+            // 翻转，注意是左闭右闭 []的翻转。
+            $this->reverseString($s, $start, $i-1);
+            // +1: 单词与单词直接有个空格
+            $start = $i + 1; 
+        }
+    }
+    return $s;
+}
+
+// 移除多余空格
+function removeExtraSpaces(&$s){
+    $slow = 0;   
+    for ($i = 0; $i < strlen($s); $i++) {
+        if ($s[$i] != ' ') { 
+            if ($slow != 0){
+                $s[$slow++] = ' ';
+            } 
+            while ($i < strlen($s) && $s[$i] != ' ') { 
+                $s[$slow++] = $s[$i++];
+            }
+        }
+    }
+    // 移动覆盖处理，丢弃多余的脏数据。
+    $s = substr($s,0,$slow);
+    return ;
+}
+
+// 翻转字符串
+function reverseString(&$s, $start, $end) {
+    for ($i = $start, $j = $end; $i < $j; $i++, $j--) {
+        $tmp = $s[$i];
+        $s[$i] = $s[$j];
+        $s[$j] = $tmp;
+    }
+    return ;
+}
+```
 
 
 -----------------------

From 17a2ea3c435677f9b7b21a413bac1939208fae22 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Tue, 24 May 2022 19:21:53 +0800
Subject: [PATCH 07/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200513.=E6=89=BE?=
 =?UTF-8?q?=E6=A0=91=E5=B7=A6=E4=B8=8B=E8=A7=92=E7=9A=84=E5=80=BC.md=20Sca?=
 =?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0513.找树左下角的值.md | 43 ++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
index 12c62c70..296fe478 100644
--- a/problems/0513.找树左下角的值.md
+++ b/problems/0513.找树左下角的值.md
@@ -546,7 +546,50 @@ func findBottomLeftValue(_ root: TreeNode?) -> Int {
 }
 ```
 
+## Scala
 
+递归版本:
+```scala
+object Solution {
+  def findBottomLeftValue(root: TreeNode): Int = {
+    var maxLeftValue = 0
+    var maxLen = Int.MinValue
+    // 递归方法
+    def traversal(node: TreeNode, leftLen: Int): Unit = {
+      // 如果左右都为空并且当前深度大于最大深度，记录最左节点的值
+      if (node.left == null && node.right == null && leftLen > maxLen) {
+        maxLen = leftLen
+        maxLeftValue = node.value
+      }
+      if (node.left != null) traversal(node.left, leftLen + 1)
+      if (node.right != null) traversal(node.right, leftLen + 1)
+    }
+    traversal(root, 0)  // 调用方法
+    maxLeftValue    // return关键字可以省略
+  }
+}
+```
+
+层序遍历:
+```scala
+  import scala.collection.mutable
+
+  def findBottomLeftValue(root: TreeNode): Int = {
+    val queue = mutable.Queue[TreeNode]()
+    queue.enqueue(root)
+    var res = 0   // 记录每层最左侧结果
+    while (!queue.isEmpty) {
+      val len = queue.size
+      for (i <- 0 until len) {
+        val curNode = queue.dequeue()
+        if (i == 0) res = curNode.value // 记录最最左侧的节点
+        if (curNode.left != null) queue.enqueue(curNode.left)
+        if (curNode.right != null) queue.enqueue(curNode.right)
+      }
+    }
+    res // 最终返回结果，return关键字可以省略
+  }
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From 4405be238d0041b3cd2719df2945e00fe114c030 Mon Sep 17 00:00:00 2001
From: SevenMonths <qinwen_shuai@163.com>
Date: Tue, 24 May 2022 19:56:37 +0800
Subject: [PATCH 08/15] =?UTF-8?q?=E5=A2=9E=E5=8A=A0(0206.=E7=BF=BB?=
 =?UTF-8?q?=E8=BD=AC=E9=93=BE=E8=A1=A8.md)=EF=BC=9Aphp=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0206.翻转链表.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index 941928ba..2e80972c 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -497,5 +497,20 @@ struct ListNode* reverseList(struct ListNode* head){
 }
 ```
 
+PHP:
+```php
+// 双指针法：
+function reverseList($head) {
+    $cur = $head;
+    $pre = NULL;
+    while($cur){
+        $temp = $cur->next; 
+        $cur->next = $pre;
+        $pre = $cur;
+        $cur = $temp;
+    }
+    return $pre;
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From 5e0a01c9f3129b822c17ec33c6e46296df6ccfeb Mon Sep 17 00:00:00 2001
From: SevenMonths <qinwen_shuai@163.com>
Date: Tue, 24 May 2022 20:21:22 +0800
Subject: [PATCH 09/15] =?UTF-8?q?=E5=A2=9E=E5=8A=A0(0019.=E5=88=A0?=
 =?UTF-8?q?=E9=99=A4=E9=93=BE=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=AC?=
 =?UTF-8?q?N=E4=B8=AA=E8=8A=82=E7=82=B9.md)=EF=BC=9APHP=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...0019.删除链表的倒数第N个节点.md | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 813e9b02..b0669697 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -290,5 +290,26 @@ func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
 }
 ```
 
+PHP:
+```php
+function removeNthFromEnd($head, $n) {
+    // 设置虚拟头节点
+    $dummyHead = new ListNode();
+    $dummyHead->next = $head;
+
+    $slow = $fast = $dummyHead;
+    while($n-- && $fast != null){
+        $fast = $fast->next;
+    }
+    // fast 再走一步，让 slow 指向删除节点的上一个节点
+    $fast = $fast->next; 
+    while ($fast != NULL) {
+        $fast = $fast->next;
+        $slow = $slow->next;
+    }
+    $slow->next = $slow->next->next;
+    return $dummyHead->next;
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From 1a01fe3237e1b05d955daff920874f1386d1d1a0 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Tue, 24 May 2022 20:58:07 +0800
Subject: [PATCH 10/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200112.=E8=B7=AF?=
 =?UTF-8?q?=E5=BE=84=E6=80=BB=E5=92=8C.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0112.路径总和.md | 107 ++++++++++++++++++++++++++++++----
 1 file changed, 95 insertions(+), 12 deletions(-)

diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 41463ec1..6bf32ae9 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -300,7 +300,7 @@ public:
 
 ## java
 
-lc112
+### 0112.路径总和
 ```java
 class solution {
    public boolean haspathsum(treenode root, int targetsum) {
@@ -373,7 +373,7 @@ class solution {
 
 ```
 
-0113.路径总和-ii
+### 0113.路径总和-ii
 
 ```java
 class solution {
@@ -436,7 +436,7 @@ class Solution {
 
 ## python
 
-0112.路径总和
+### 0112.路径总和
 
 **递归**
 ```python
@@ -488,7 +488,7 @@ class solution:
         return false
 ```
 
-0113.路径总和-ii 
+### 0113.路径总和-ii 
 
 **递归**
 ```python
@@ -545,7 +545,7 @@ class Solution:
 
 ## go
 
-112. 路径总和
+### 112. 路径总和
 
 ```go
 //递归法
@@ -570,7 +570,7 @@ func hasPathSum(root *TreeNode, targetSum int) bool {
 }
 ```
 
-113. 路径总和 II
+### 113. 路径总和 II
 
 ```go
 /**
@@ -612,7 +612,7 @@ func traverse(node *TreeNode, result *[][]int, currPath *[]int, targetSum int) {
 
 ## javascript
 
-0112.路径总和
+### 0112.路径总和
 
 **递归**
 ```javascript
@@ -673,7 +673,7 @@ let hasPathSum = function(root, targetSum) {
 };
 ```
 
-0113.路径总和-ii 
+### 0113.路径总和-ii 
 
 **递归**
 ```javascript
@@ -768,7 +768,7 @@ let pathSum = function(root, targetSum) {
 
 ## TypeScript
 
-> 0112.路径总和
+### 0112.路径总和
 
 **递归法：**
 
@@ -850,7 +850,7 @@ function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
 };
 ```
 
-> 0112.路径总和 ii
+### 0112.路径总和 ii
 
 **递归法：**
 
@@ -888,7 +888,7 @@ function pathSum(root: TreeNode | null, targetSum: number): number[][] {
 
 ## Swift
 
-0112.路径总和
+### 0112.路径总和
 
 **递归**
 
@@ -955,7 +955,7 @@ func hasPathSum(_ root: TreeNode?, _ targetSum: Int) -> Bool {
 }
 ```
 
-0113.路径总和 II
+### 0113.路径总和 II
 
 **递归**
 
@@ -1006,7 +1006,90 @@ func traversal(_ cur: TreeNode?, count: Int) {
 }
 ```
 
+## Scala
 
+### 0112.路径总和
+
+**递归:**
+```scala
+object Solution {
+  def hasPathSum(root: TreeNode, targetSum: Int): Boolean = {
+    if(root == null) return false
+    var res = false
+
+    def traversal(curNode: TreeNode, sum: Int): Unit = {
+      if (res) return // 如果直接标记为true了，就没有往下递归的必要了
+      if (curNode.left == null && curNode.right == null && sum == targetSum) {
+        res = true
+        return
+      }
+      // 往下递归
+      if (curNode.left != null) traversal(curNode.left, sum + curNode.left.value)
+      if (curNode.right != null) traversal(curNode.right, sum + curNode.right.value)
+    }
+
+    traversal(root, root.value)
+    res // return关键字可以省略
+  }
+}
+```
+
+**迭代:**
+```scala
+object Solution {
+  import scala.collection.mutable
+  def hasPathSum(root: TreeNode, targetSum: Int): Boolean = {
+    if (root == null) return false
+    val stack = mutable.Stack[(TreeNode, Int)]()
+    stack.push((root, root.value)) // 将根节点元素放入stack
+    while (!stack.isEmpty) {
+      val curNode = stack.pop() // 取出栈顶元素
+      // 如果遇到叶子节点，看当前的值是否等于targetSum，等于则返回true
+      if (curNode._1.left == null && curNode._1.right == null && curNode._2 == targetSum) {
+        return true
+      }
+      if (curNode._1.right != null) stack.push((curNode._1.right, curNode._2 + curNode._1.right.value))
+      if (curNode._1.left != null) stack.push((curNode._1.left, curNode._2 + curNode._1.left.value))
+    }
+    false //如果没有返回true，即可返回false，return关键字可以省略
+  }
+}
+```
+
+### 0113.路径总和 II
+
+**递归:**
+```scala
+object Solution {
+  import scala.collection.mutable.ListBuffer
+  def pathSum(root: TreeNode, targetSum: Int): List[List[Int]] = {
+    val res = ListBuffer[List[Int]]()
+    if (root == null) return res.toList
+    val path = ListBuffer[Int]();
+
+    def traversal(cur: TreeNode, count: Int): Unit = {
+      if (cur.left == null && cur.right == null && count == 0) {
+        res.append(path.toList)
+        return
+      }
+      if (cur.left != null) {
+        path.append(cur.left.value)
+        traversal(cur.left, count - cur.left.value)
+        path.remove(path.size - 1)
+      }
+      if (cur.right != null) {
+        path.append(cur.right.value)
+        traversal(cur.right, count - cur.right.value)
+        path.remove(path.size - 1)
+      }
+    }
+
+    path.append(root.value)
+    traversal(root, targetSum - root.value)
+    res.toList
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From e28c733f758adc362095299a73b7f4dacd76be6e Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 25 May 2022 11:19:33 +0800
Subject: [PATCH 11/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=881207.=E7=8B=AC?=
 =?UTF-8?q?=E4=B8=80=E6=97=A0=E4=BA=8C=E7=9A=84=E5=87=BA=E7=8E=B0=E6=AC=A1?=
 =?UTF-8?q?=E6=95=B0.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
 =?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/1207.独一无二的出现次数.md | 34 ++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/problems/1207.独一无二的出现次数.md b/problems/1207.独一无二的出现次数.md
index ba92552a..fc51dfd4 100644
--- a/problems/1207.独一无二的出现次数.md
+++ b/problems/1207.独一无二的出现次数.md
@@ -150,5 +150,39 @@ var uniqueOccurrences = function(arr) {
 };
 ```
 
+TypeScript：
+
+> 借用数组：
+
+```typescript
+function uniqueOccurrences(arr: number[]): boolean {
+    const countArr: number[] = new Array(2001).fill(0);
+    for (let i = 0, length = arr.length; i < length; i++) {
+        countArr[arr[i] + 1000]++;
+    }
+    const flagArr: boolean[] = new Array(1001).fill(false);
+    for (let count of countArr) {
+        if (count === 0) continue;
+        if (flagArr[count] === true) return false;
+        flagArr[count] = true;
+    }
+    return true;
+};
+```
+
+> 借用map、set
+
+```typescript
+function uniqueOccurrences(arr: number[]): boolean {
+    const countMap: Map<number, number> = new Map();
+    arr.forEach(val => {
+        countMap.set(val, (countMap.get(val) || 0) + 1);
+    })
+    return countMap.size === new Set(countMap.values()).size;
+};
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From 0fe499ac4142d87634d43c8e447de48091b803c3 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 25 May 2022 21:01:54 +0800
Subject: [PATCH 12/15] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200106.=E4=BB=8E?=
 =?UTF-8?q?=E4=B8=AD=E5=BA=8F=E4=B8=8E=E5=90=8E=E5=BA=8F=E9=81=8D=E5=8E=86?=
 =?UTF-8?q?=E5=BA=8F=E5=88=97=E6=9E=84=E9=80=A0=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...序与后序遍历序列构造二叉树.md | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
index 188ad3cb..37a702b7 100644
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -1091,7 +1091,53 @@ class Solution_0106 {
 }
 ```
 
+## Scala
 
+106 从中序与后序遍历序列构造二叉树
+
+```scala
+object Solution {
+  def buildTree(inorder: Array[Int], postorder: Array[Int]): TreeNode = {
+    // 1、如果长度为0，则直接返回null
+    var len = inorder.size
+    if (len == 0) return null
+    // 2、后序数组的最后一个元素是当前根元素
+    var rootValue = postorder(len - 1)
+    var root: TreeNode = new TreeNode(rootValue, null, null)
+    if (len == 1) return root   // 如果数组只有一个节点，就直接返回
+    // 3、在中序数组中找到切割点的索引
+    var delimiterIndex: Int = inorder.indexOf(rootValue)
+    // 4、切分数组往下迭代
+    root.left = buildTree(inorder.slice(0, delimiterIndex), postorder.slice(0, delimiterIndex))
+    root.right = buildTree(inorder.slice(delimiterIndex + 1, len), postorder.slice(delimiterIndex, len - 1))
+    root   // 返回root，return关键字可以省略
+  }
+}
+```
+
+105 从前序与中序遍历序列构造二叉树
+
+```scala
+object Solution {
+  def buildTree(preorder: Array[Int], inorder: Array[Int]): TreeNode = {
+    // 1、如果长度为0，直接返回空
+    var len = inorder.size
+    if (len == 0) return null
+    // 2、前序数组的第一个元素是当前子树根节点
+    var rootValue = preorder(0)
+    var root = new TreeNode(rootValue, null, null)
+    if (len == 1) return root // 如果数组元素只有一个，那么返回根节点
+    // 3、在中序数组中，找到切割点
+    var delimiterIndex = inorder.indexOf(rootValue)
+
+    // 4、切分数组往下迭代
+    root.left = buildTree(preorder.slice(1, delimiterIndex + 1), inorder.slice(0, delimiterIndex))
+    root.right = buildTree(preorder.slice(delimiterIndex + 1, preorder.size), inorder.slice(delimiterIndex + 1, len))
+
+    root
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

From fdd646e0e168aff1cd2772c0bca76cb062cd265c Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Fri, 17 Jun 2022 16:55:39 +0800
Subject: [PATCH 13/15] Update

---
 problems/0059.螺旋矩阵II.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index 22229302..bec5be08 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -24,6 +24,8 @@
 
 ## 思路
 
+为了利于录友们理解，我特意录制了视频，[拿下螺旋矩阵，《代码随想录》第五题！](https://www.bilibili.com/video/BV1SL4y1N7mV)，结合本篇文章一起看，效果更佳。
+
 这道题目可以说在面试中出现频率较高的题目，**本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。**
 
 要如何画出这个螺旋排列的正方形矩阵呢？
@@ -74,7 +76,7 @@ public:
         int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
         int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
         int count = 1; // 用来给矩阵中每一个空格赋值
-        int offset = 1; // 每一圈循环，需要控制每一条边遍历的长度
+        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
         int i,j;
         while (loop --) {
             i = startx;
@@ -82,11 +84,11 @@ public:
 
             // 下面开始的四个for就是模拟转了一圈
             // 模拟填充上行从左到右(左闭右开)
-            for (j = starty; j < starty + n - offset; j++) {
+            for (j = starty; j < n - offset; j++) {
                 res[startx][j] = count++;
             }
             // 模拟填充右列从上到下(左闭右开)
-            for (i = startx; i < startx + n - offset; i++) {
+            for (i = startx; i < n - offset; i++) {
                 res[i][j] = count++;
             }
             // 模拟填充下行从右到左(左闭右开)
@@ -103,7 +105,7 @@ public:
             starty++;
 
             // offset 控制每一圈里每一条边遍历的长度
-            offset += 2;
+            offset += 1;
         }
 
         // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值

From 812aeeda30f36c9dfecd16c405b8d8ad8674d865 Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Mon, 27 Jun 2022 09:54:38 +0800
Subject: [PATCH 14/15] Update

---
 problems/0001.两数之和.md       | 2 +-
 problems/0059.螺旋矩阵II.md     | 2 +-
 problems/0203.移除链表元素.md | 2 ++
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/problems/0001.两数之和.md b/problems/0001.两数之和.md
index 6969c2e2..fb3c1d45 100644
--- a/problems/0001.两数之和.md
+++ b/problems/0001.两数之和.md
@@ -7,7 +7,7 @@
 
 ## 1. 两数之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/two-sum/)
+[力扣题目链接](https://leetcode.cn/problems/two-sum/)
 
 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index bec5be08..bf0a279e 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -8,7 +8,7 @@
 
 ## 59.螺旋矩阵II
 
-[力扣题目链接](https://leetcode-cn.com/problems/spiral-matrix-ii/)
+[力扣题目链接](https://leetcode.cn/problems/spiral-matrix-ii/)
 
 给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
 
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index fe78ddab..975ca429 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -28,6 +28,8 @@
 
 # 思路
 
+为了方便大家理解，我特意录制了视频：[手把手带你学会操作链表，移除链表元素](https://www.bilibili.com/video/BV18B4y1s7R9)，结合视频在看本题解，事半功倍。
+
 这里以链表 1 4 2 4  来举例，移除元素4。
 
 ![203_链表删除元素1](https://img-blog.csdnimg.cn/20210316095351161.png)

From 1b16a934d662b73403dfb8b8036189a62a60c2eb Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Mon, 27 Jun 2022 09:58:45 +0800
Subject: [PATCH 15/15] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=8A=9B=E6=89=A3?=
 =?UTF-8?q?=E9=93=BE=E6=8E=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0005.最长回文子串.md           |  2 +-
 problems/0015.三数之和.md                 |  2 +-
 problems/0017.电话号码的字母组合.md  |  2 +-
 problems/0018.四数之和.md                 |  2 +-
 ...0019.删除链表的倒数第N个节点.md |  2 +-
 problems/0020.有效的括号.md              |  2 +-
 .../0024.两两交换链表中的节点.md    |  2 +-
 problems/0027.移除元素.md                 |  2 +-
 problems/0028.实现strStr.md                 |  2 +-
 problems/0031.下一个排列.md              |  2 +-
 problems/0035.搜索插入位置.md           |  2 +-
 problems/0037.解数独.md                    |  2 +-
 problems/0039.组合总和.md                 |  2 +-
 problems/0040.组合总和II.md               |  2 +-
 problems/0042.接雨水.md                    |  2 +-
 problems/0045.跳跃游戏II.md               |  2 +-
 problems/0046.全排列.md                    |  2 +-
 problems/0047.全排列II.md                  |  2 +-
 problems/0051.N皇后.md                      |  2 +-
 problems/0052.N皇后II.md                    |  2 +-
 problems/0053.最大子序和.md              |  2 +-
 .../0053.最大子序和（动态规划）.md |  2 +-
 problems/0054.螺旋矩阵.md                 |  6 +++---
 problems/0055.跳跃游戏.md                 |  2 +-
 problems/0056.合并区间.md                 |  2 +-
 problems/0062.不同路径.md                 |  2 +-
 problems/0063.不同路径II.md               |  2 +-
 problems/0070.爬楼梯.md                    |  2 +-
 problems/0070.爬楼梯完全背包版本.md  |  2 +-
 problems/0072.编辑距离.md                 |  2 +-
 problems/0077.组合.md                       |  2 +-
 problems/0077.组合优化.md                 |  2 +-
 problems/0078.子集.md                       |  2 +-
 problems/0084.柱状图中最大的矩形.md  |  2 +-
 problems/0090.子集II.md                     |  2 +-
 problems/0093.复原IP地址.md               |  2 +-
 problems/0096.不同的二叉搜索树.md     |  2 +-
 problems/0098.验证二叉搜索树.md        |  2 +-
 problems/0100.相同的树.md                 |  2 +-
 problems/0101.对称二叉树.md              |  2 +-
 problems/0102.二叉树的层序遍历.md     | 20 +++++++++----------
 problems/0104.二叉树的最大深度.md     |  4 ++--
 ...序与后序遍历序列构造二叉树.md |  4 ++--
 ...将有序数组转换为二叉搜索树.md |  2 +-
 problems/0110.平衡二叉树.md              |  2 +-
 problems/0111.二叉树的最小深度.md     |  2 +-
 problems/0112.路径总和.md                 |  4 ++--
 problems/0115.不同的子序列.md           |  2 +-
 ...个节点的下一个右侧节点指针.md |  2 +-
 problems/0121.买卖股票的最佳时机.md  |  2 +-
 .../0122.买卖股票的最佳时机II.md     |  2 +-
 ...�票的最佳时机II（动态规划）.md |  2 +-
 .../0123.买卖股票的最佳时机III.md    |  2 +-
 problems/0127.单词接龙.md                 |  2 +-
 .../0129.求根到叶子节点数字之和.md |  2 +-
 problems/0131.分割回文串.md              |  2 +-
 problems/0132.分割回文串II.md            |  2 +-
 problems/0134.加油站.md                    |  2 +-
 problems/0135.分发糖果.md                 |  2 +-
 problems/0139.单词拆分.md                 |  2 +-
 problems/0142.环形链表II.md               |  2 +-
 problems/0150.逆波兰表达式求值.md     |  2 +-
 problems/0151.翻转字符串里的单词.md  |  4 ++--
 .../0188.买卖股票的最佳时机IV.md     |  2 +-
 problems/0198.打家劫舍.md                 |  2 +-
 problems/0202.快乐数.md                    |  2 +-
 problems/0203.移除链表元素.md           |  2 +-
 problems/0205.同构字符串.md              |  2 +-
 problems/0206.翻转链表.md                 |  2 +-
 problems/0209.长度最小的子数组.md     |  6 +++---
 problems/0213.打家劫舍II.md               |  2 +-
 problems/0216.组合总和III.md              |  2 +-
 .../0222.完全二叉树的节点个数.md    |  2 +-
 problems/0225.用队列实现栈.md           |  2 +-
 problems/0226.翻转二叉树.md              |  2 +-
 problems/0232.用栈实现队列.md           |  2 +-
 problems/0234.回文链表.md                 |  2 +-
 ...35.二叉搜索树的最近公共祖先.md |  2 +-
 .../0236.二叉树的最近公共祖先.md    |  2 +-
 problems/0239.滑动窗口最大值.md        |  2 +-
 problems/0242.有效的字母异位词.md     |  2 +-
 problems/0257.二叉树的所有路径.md     |  2 +-
 problems/0279.完全平方数.md              |  2 +-
 problems/0283.移动零.md                    |  2 +-
 problems/0300.最长上升子序列.md        |  2 +-
 ...09.最佳买卖股票时机含冷冻期.md |  2 +-
 problems/0322.零钱兑换.md                 |  2 +-
 problems/0332.重新安排行程.md           |  2 +-
 problems/0337.打家劫舍III.md              |  2 +-
 problems/0343.整数拆分.md                 |  2 +-
 problems/0344.反转字符串.md              |  2 +-
 problems/0347.前K个高频元素.md          |  2 +-
 problems/0349.两个数组的交集.md        |  2 +-
 problems/0376.摆动序列.md                 |  2 +-
 problems/0377.组合总和Ⅳ.md              |  2 +-
 problems/0383.赎金信.md                    |  2 +-
 problems/0392.判断子序列.md              |  2 +-
 problems/0404.左叶子之和.md              |  2 +-
 problems/0406.根据身高重建队列.md     |  2 +-
 problems/0416.分割等和子集.md           |  2 +-
 problems/0435.无重叠区间.md              |  2 +-
 .../0450.删除二叉搜索树中的节点.md |  2 +-
 .../0452.用最少数量的箭引爆气球.md |  2 +-
 problems/0454.四数相加II.md               |  2 +-
 problems/0455.分发饼干.md                 |  2 +-
 problems/0459.重复的子字符串.md        |  2 +-
 problems/0463.岛屿的周长.md              |  2 +-
 problems/0474.一和零.md                    |  2 +-
 problems/0491.递增子序列.md              |  2 +-
 problems/0494.目标和.md                    |  2 +-
 problems/0496.下一个更大元素I.md       |  2 +-
 problems/0501.二叉搜索树中的众数.md  |  2 +-
 problems/0503.下一个更大元素II.md      |  2 +-
 problems/0509.斐波那契数.md              |  2 +-
 problems/0513.找树左下角的值.md        |  2 +-
 problems/0516.最长回文子序列.md        |  2 +-
 problems/0518.零钱兑换II.md               |  2 +-
 .../0530.二叉搜索树的最小绝对差.md |  2 +-
 ...38.把二叉搜索树转换为累加树.md |  2 +-
 problems/0541.反转字符串II.md            |  2 +-
 .../0583.两个字符串的删除操作.md    |  2 +-
 problems/0617.合并二叉树.md              |  2 +-
 problems/0647.回文子串.md                 |  2 +-
 problems/0649.Dota2参议院.md               |  2 +-
 problems/0654.最大二叉树.md              |  2 +-
 problems/0657.机器人能否返回原点.md  |  2 +-
 problems/0669.修剪二叉搜索树.md        |  2 +-
 .../0673.最长递增子序列的个数.md    |  2 +-
 problems/0674.最长连续递增序列.md     |  2 +-
 problems/0684.冗余连接.md                 |  2 +-
 problems/0685.冗余连接II.md               |  2 +-
 problems/0700.二叉搜索树中的搜索.md  |  2 +-
 .../0701.二叉搜索树中的插入操作.md |  2 +-
 problems/0704.二分查找.md                 |  2 +-
 problems/0707.设计链表.md                 |  2 +-
 ...买卖股票的最佳时机含手续费.md |  2 +-
 ...佳时机含手续费（动态规划）.md |  2 +-
 problems/0718.最长重复子数组.md        |  2 +-
 problems/0724.寻找数组的中心索引.md  |  2 +-
 problems/0738.单调递增的数字.md        |  2 +-
 problems/0739.每日温度.md                 |  2 +-
 problems/0746.使用最小花费爬楼梯.md  |  2 +-
 problems/0763.划分字母区间.md           |  2 +-
 problems/0841.钥匙和房间.md              |  2 +-
 problems/0844.比较含退格的字符串.md  |  2 +-
 problems/0860.柠檬水找零.md              |  2 +-
 problems/0922.按奇偶排序数组II.md      |  2 +-
 problems/0925.长按键入.md                 |  2 +-
 problems/0941.有效的山脉数组.md        |  2 +-
 problems/0968.监控二叉树.md              |  2 +-
 problems/0977.有序数组的平方.md        |  2 +-
 problems/1002.查找常用字符.md           |  2 +-
 ...1005.K次取反后最大化的数组和.md |  2 +-
 problems/1035.不相交的线.md              |  2 +-
 ...除字符串中的所有相邻重复项.md |  2 +-
 .../1049.最后一块石头的重量II.md     |  2 +-
 problems/1143.最长公共子序列.md        |  2 +-
 problems/1207.独一无二的出现次数.md  |  2 +-
 problems/1221.分割平衡字符串.md        |  2 +-
 ...��据数字二进制下1的数目排序.md |  4 ++--
 ...65.有多少小于当前数字的数字.md |  2 +-
 problems/1382.将二叉搜索树变平衡.md  |  2 +-
 problems/二叉树的迭代遍历.md          |  6 +++---
 problems/二叉树的递归遍历.md          |  6 +++---
 problems/剑指Offer05.替换空格.md        |  2 +-
 .../剑指Offer58-II.左旋转字符串.md    |  2 +-
 problems/面试题02.07.链表相交.md       |  2 +-
 167 files changed, 189 insertions(+), 189 deletions(-)

diff --git a/problems/0005.最长回文子串.md b/problems/0005.最长回文子串.md
index eaebb5ab..d53acf63 100644
--- a/problems/0005.最长回文子串.md
+++ b/problems/0005.最长回文子串.md
@@ -8,7 +8,7 @@
 
 # 5.最长回文子串
 
-[力扣题目链接](https://leetcode-cn.com/problems/longest-palindromic-substring/)
+[力扣题目链接](https://leetcode.cn/problems/longest-palindromic-substring/)
 
 给你一个字符串 s，找到 s 中最长的回文子串。
 
diff --git a/problems/0015.三数之和.md b/problems/0015.三数之和.md
index 1764d244..e6dc82dd 100644
--- a/problems/0015.三数之和.md
+++ b/problems/0015.三数之和.md
@@ -10,7 +10,7 @@
 
 # 第15题. 三数之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/3sum/)
+[力扣题目链接](https://leetcode.cn/problems/3sum/)
 
 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
 
diff --git a/problems/0017.电话号码的字母组合.md b/problems/0017.电话号码的字母组合.md
index 94136565..2b5cb978 100644
--- a/problems/0017.电话号码的字母组合.md
+++ b/problems/0017.电话号码的字母组合.md
@@ -7,7 +7,7 @@
 
 # 17.电话号码的字母组合
 
-[力扣题目链接](https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)
+[力扣题目链接](https://leetcode.cn/problems/letter-combinations-of-a-phone-number/)
 
 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
 
diff --git a/problems/0018.四数之和.md b/problems/0018.四数之和.md
index 6cbd40c2..2146a114 100644
--- a/problems/0018.四数之和.md
+++ b/problems/0018.四数之和.md
@@ -10,7 +10,7 @@
 
 # 第18题. 四数之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/4sum/)
+[力扣题目链接](https://leetcode.cn/problems/4sum/)
 
 题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
 
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index c36900bc..9278ff1a 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -9,7 +9,7 @@
 
 ## 19.删除链表的倒数第N个节点
 
-[力扣题目链接](https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)
+[力扣题目链接](https://leetcode.cn/problems/remove-nth-node-from-end-of-list/)
 
 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
 
diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index a0df0d07..b44d21ed 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -10,7 +10,7 @@
 
 # 20. 有效的括号
 
-[力扣题目链接](https://leetcode-cn.com/problems/valid-parentheses/)
+[力扣题目链接](https://leetcode.cn/problems/valid-parentheses/)
 
 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
 
diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index 2289c229..e636bfff 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -7,7 +7,7 @@
 
 ## 24. 两两交换链表中的节点
 
-[力扣题目链接](https://leetcode-cn.com/problems/swap-nodes-in-pairs/)
+[力扣题目链接](https://leetcode.cn/problems/swap-nodes-in-pairs/)
 
 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
 
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index f7142bad..03c58b43 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -7,7 +7,7 @@
 
 ## 27. 移除元素
 
-[力扣题目链接](https://leetcode-cn.com/problems/remove-element/)
+[力扣题目链接](https://leetcode.cn/problems/remove-element/)
 
 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
 
diff --git a/problems/0028.实现strStr.md b/problems/0028.实现strStr.md
index 1cdd5292..a95a52f8 100644
--- a/problems/0028.实现strStr.md
+++ b/problems/0028.实现strStr.md
@@ -9,7 +9,7 @@
 
 # 28. 实现 strStr()
 
-[力扣题目链接](https://leetcode-cn.com/problems/implement-strstr/)
+[力扣题目链接](https://leetcode.cn/problems/implement-strstr/)
 
 实现 strStr() 函数。
 
diff --git a/problems/0031.下一个排列.md b/problems/0031.下一个排列.md
index 2219e24d..bce8adef 100644
--- a/problems/0031.下一个排列.md
+++ b/problems/0031.下一个排列.md
@@ -9,7 +9,7 @@
 
 # 31.下一个排列
 
-[力扣题目链接](https://leetcode-cn.com/problems/next-permutation/)
+[力扣题目链接](https://leetcode.cn/problems/next-permutation/)
 
 实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
 
diff --git a/problems/0035.搜索插入位置.md b/problems/0035.搜索插入位置.md
index 5cf44ded..ed7c49b4 100644
--- a/problems/0035.搜索插入位置.md
+++ b/problems/0035.搜索插入位置.md
@@ -9,7 +9,7 @@
 
 # 35.搜索插入位置
 
-[力扣题目链接](https://leetcode-cn.com/problems/search-insert-position/)
+[力扣题目链接](https://leetcode.cn/problems/search-insert-position/)
 
 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
 
diff --git a/problems/0037.解数独.md b/problems/0037.解数独.md
index c1ac15af..b074b98f 100644
--- a/problems/0037.解数独.md
+++ b/problems/0037.解数独.md
@@ -9,7 +9,7 @@
 
 # 37. 解数独
 
-[力扣题目链接](https://leetcode-cn.com/problems/sudoku-solver/)
+[力扣题目链接](https://leetcode.cn/problems/sudoku-solver/)
 
 编写一个程序，通过填充空格来解决数独问题。
 
diff --git a/problems/0039.组合总和.md b/problems/0039.组合总和.md
index e10a827f..fef9b676 100644
--- a/problems/0039.组合总和.md
+++ b/problems/0039.组合总和.md
@@ -7,7 +7,7 @@
 
 # 39. 组合总和
 
-[力扣题目链接](https://leetcode-cn.com/problems/combination-sum/)
+[力扣题目链接](https://leetcode.cn/problems/combination-sum/)
 
 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 
diff --git a/problems/0040.组合总和II.md b/problems/0040.组合总和II.md
index 34ac64e6..ee4371cd 100644
--- a/problems/0040.组合总和II.md
+++ b/problems/0040.组合总和II.md
@@ -9,7 +9,7 @@
 
 # 40.组合总和II
 
-[力扣题目链接](https://leetcode-cn.com/problems/combination-sum-ii/)
+[力扣题目链接](https://leetcode.cn/problems/combination-sum-ii/)
 
 给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 
diff --git a/problems/0042.接雨水.md b/problems/0042.接雨水.md
index b232ce22..a2d6f044 100644
--- a/problems/0042.接雨水.md
+++ b/problems/0042.接雨水.md
@@ -9,7 +9,7 @@
 
 # 42. 接雨水  
 
-[力扣题目链接](https://leetcode-cn.com/problems/trapping-rain-water/)
+[力扣题目链接](https://leetcode.cn/problems/trapping-rain-water/)
 
 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
 
diff --git a/problems/0045.跳跃游戏II.md b/problems/0045.跳跃游戏II.md
index 4e3ab24a..9e61fbb8 100644
--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@@ -9,7 +9,7 @@
 
 # 45.跳跃游戏II
 
-[力扣题目链接](https://leetcode-cn.com/problems/jump-game-ii/)
+[力扣题目链接](https://leetcode.cn/problems/jump-game-ii/)
 
 给定一个非负整数数组，你最初位于数组的第一个位置。
 
diff --git a/problems/0046.全排列.md b/problems/0046.全排列.md
index 836c3646..70ab21d3 100644
--- a/problems/0046.全排列.md
+++ b/problems/0046.全排列.md
@@ -7,7 +7,7 @@
 
 # 46.全排列
 
-[力扣题目链接](https://leetcode-cn.com/problems/permutations/)
+[力扣题目链接](https://leetcode.cn/problems/permutations/)
 
 给定一个 没有重复 数字的序列，返回其所有可能的全排列。
 
diff --git a/problems/0047.全排列II.md b/problems/0047.全排列II.md
index cce25cd9..bb8610d7 100644
--- a/problems/0047.全排列II.md
+++ b/problems/0047.全排列II.md
@@ -8,7 +8,7 @@
 
 ## 47.全排列 II
 
-[力扣题目链接](https://leetcode-cn.com/problems/permutations-ii/)
+[力扣题目链接](https://leetcode.cn/problems/permutations-ii/)
 
 给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
 
diff --git a/problems/0051.N皇后.md b/problems/0051.N皇后.md
index c03e48c2..798902ae 100644
--- a/problems/0051.N皇后.md
+++ b/problems/0051.N皇后.md
@@ -7,7 +7,7 @@
 
 # 第51题. N皇后
 
-[力扣题目链接](https://leetcode-cn.com/problems/n-queens/)
+[力扣题目链接](https://leetcode.cn/problems/n-queens/)
 
 n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
 
diff --git a/problems/0052.N皇后II.md b/problems/0052.N皇后II.md
index 67e439ca..48634075 100644
--- a/problems/0052.N皇后II.md
+++ b/problems/0052.N皇后II.md
@@ -8,7 +8,7 @@
 
 # 52. N皇后II
 
-题目链接：https://leetcode-cn.com/problems/n-queens-ii/
+题目链接：https://leetcode.cn/problems/n-queens-ii/
 
 n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
 
diff --git a/problems/0053.最大子序和.md b/problems/0053.最大子序和.md
index 73cac244..cbc91481 100644
--- a/problems/0053.最大子序和.md
+++ b/problems/0053.最大子序和.md
@@ -7,7 +7,7 @@
 
 # 53. 最大子序和
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximum-subarray/)
+[力扣题目链接](https://leetcode.cn/problems/maximum-subarray/)
 
 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
 
diff --git a/problems/0053.最大子序和（动态规划）.md b/problems/0053.最大子序和（动态规划）.md
index 99aa7acf..345abc27 100644
--- a/problems/0053.最大子序和（动态规划）.md
+++ b/problems/0053.最大子序和（动态规划）.md
@@ -6,7 +6,7 @@
 
 ## 53. 最大子序和
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximum-subarray/)
+[力扣题目链接](https://leetcode.cn/problems/maximum-subarray/)
 
 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
 
diff --git a/problems/0054.螺旋矩阵.md b/problems/0054.螺旋矩阵.md
index ccf6f471..0d79fdf9 100644
--- a/problems/0054.螺旋矩阵.md
+++ b/problems/0054.螺旋矩阵.md
@@ -8,7 +8,7 @@
 
 ## 54.螺旋矩阵
 
-[力扣题目链接](https://leetcode-cn.com/problems/spiral-matrix/)
+[力扣题目链接](https://leetcode.cn/problems/spiral-matrix/)
 
 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
 
@@ -128,8 +128,8 @@ public:
 
 ## 类似题目
 
-* [59.螺旋矩阵II](https://leetcode-cn.com/problems/spiral-matrix-ii/)
-* [剑指Offer 29.顺时针打印矩阵](https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/)
+* [59.螺旋矩阵II](https://leetcode.cn/problems/spiral-matrix-ii/)
+* [剑指Offer 29.顺时针打印矩阵](https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/)
 
 ## 其他语言版本
 Python:
diff --git a/problems/0055.跳跃游戏.md b/problems/0055.跳跃游戏.md
index 17a3b4f4..6fa83495 100644
--- a/problems/0055.跳跃游戏.md
+++ b/problems/0055.跳跃游戏.md
@@ -7,7 +7,7 @@
 
 # 55. 跳跃游戏
 
-[力扣题目链接](https://leetcode-cn.com/problems/jump-game/)
+[力扣题目链接](https://leetcode.cn/problems/jump-game/)
 
 给定一个非负整数数组，你最初位于数组的第一个位置。
 
diff --git a/problems/0056.合并区间.md b/problems/0056.合并区间.md
index e444a221..34d8dd82 100644
--- a/problems/0056.合并区间.md
+++ b/problems/0056.合并区间.md
@@ -7,7 +7,7 @@
 
 # 56. 合并区间
 
-[力扣题目链接](https://leetcode-cn.com/problems/merge-intervals/)
+[力扣题目链接](https://leetcode.cn/problems/merge-intervals/)
 
 给出一个区间的集合，请合并所有重叠的区间。
 
diff --git a/problems/0062.不同路径.md b/problems/0062.不同路径.md
index f59b7be8..02bcc2ae 100644
--- a/problems/0062.不同路径.md
+++ b/problems/0062.不同路径.md
@@ -6,7 +6,7 @@
 
 # 62.不同路径
 
-[力扣题目链接](https://leetcode-cn.com/problems/unique-paths/)
+[力扣题目链接](https://leetcode.cn/problems/unique-paths/)
 
 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
 
diff --git a/problems/0063.不同路径II.md b/problems/0063.不同路径II.md
index 59c60156..ca34055a 100644
--- a/problems/0063.不同路径II.md
+++ b/problems/0063.不同路径II.md
@@ -6,7 +6,7 @@
 
 # 63. 不同路径 II
 
-[力扣题目链接](https://leetcode-cn.com/problems/unique-paths-ii/)
+[力扣题目链接](https://leetcode.cn/problems/unique-paths-ii/)
 
 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
 
diff --git a/problems/0070.爬楼梯.md b/problems/0070.爬楼梯.md
index 34d41441..c92c581c 100644
--- a/problems/0070.爬楼梯.md
+++ b/problems/0070.爬楼梯.md
@@ -5,7 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 # 70. 爬楼梯
-[力扣题目链接](https://leetcode-cn.com/problems/climbing-stairs/)
+[力扣题目链接](https://leetcode.cn/problems/climbing-stairs/)
 
 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
 
diff --git a/problems/0070.爬楼梯完全背包版本.md b/problems/0070.爬楼梯完全背包版本.md
index 0f482bb7..ec019e57 100644
--- a/problems/0070.爬楼梯完全背包版本.md
+++ b/problems/0070.爬楼梯完全背包版本.md
@@ -11,7 +11,7 @@
 
 ## 70. 爬楼梯
 
-[力扣题目链接](https://leetcode-cn.com/problems/climbing-stairs/)
+[力扣题目链接](https://leetcode.cn/problems/climbing-stairs/)
 
 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
 
diff --git a/problems/0072.编辑距离.md b/problems/0072.编辑距离.md
index 530774ee..641d3128 100644
--- a/problems/0072.编辑距离.md
+++ b/problems/0072.编辑距离.md
@@ -6,7 +6,7 @@
 
 ## 72. 编辑距离
 
-[力扣题目链接](https://leetcode-cn.com/problems/edit-distance/)
+[力扣题目链接](https://leetcode.cn/problems/edit-distance/)
 
 给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
 
diff --git a/problems/0077.组合.md b/problems/0077.组合.md
index 9e0398ab..8d22d018 100644
--- a/problems/0077.组合.md
+++ b/problems/0077.组合.md
@@ -9,7 +9,7 @@
 
 # 第77题. 组合
 
-[力扣题目链接](https://leetcode-cn.com/problems/combinations/ )
+[力扣题目链接](https://leetcode.cn/problems/combinations/ )
 
 给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。   
 
diff --git a/problems/0077.组合优化.md b/problems/0077.组合优化.md
index 94608ec1..a6767047 100644
--- a/problems/0077.组合优化.md
+++ b/problems/0077.组合优化.md
@@ -14,7 +14,7 @@
 
 文中的回溯法是可以剪枝优化的，本篇我们继续来看一下题目77. 组合。
 
-链接：https://leetcode-cn.com/problems/combinations/
+链接：https://leetcode.cn/problems/combinations/
 
 **看本篇之前，需要先看[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)**。
 
diff --git a/problems/0078.子集.md b/problems/0078.子集.md
index e1c52b5b..2c7c1974 100644
--- a/problems/0078.子集.md
+++ b/problems/0078.子集.md
@@ -7,7 +7,7 @@
 
 # 78.子集
 
-[力扣题目链接](https://leetcode-cn.com/problems/subsets/)
+[力扣题目链接](https://leetcode.cn/problems/subsets/)
 
 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
 
diff --git a/problems/0084.柱状图中最大的矩形.md b/problems/0084.柱状图中最大的矩形.md
index 439a3bc5..8463d8d0 100644
--- a/problems/0084.柱状图中最大的矩形.md
+++ b/problems/0084.柱状图中最大的矩形.md
@@ -7,7 +7,7 @@
 
 # 84.柱状图中最大的矩形 
 
-[力扣题目链接](https://leetcode-cn.com/problems/largest-rectangle-in-histogram/)
+[力扣题目链接](https://leetcode.cn/problems/largest-rectangle-in-histogram/)
 
 给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
 
diff --git a/problems/0090.子集II.md b/problems/0090.子集II.md
index 74ce000b..b5bae53f 100644
--- a/problems/0090.子集II.md
+++ b/problems/0090.子集II.md
@@ -8,7 +8,7 @@
 
 ## 90.子集II
 
-[力扣题目链接](https://leetcode-cn.com/problems/subsets-ii/)
+[力扣题目链接](https://leetcode.cn/problems/subsets-ii/)
 
 给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
 
diff --git a/problems/0093.复原IP地址.md b/problems/0093.复原IP地址.md
index 6401824b..e4e16a22 100644
--- a/problems/0093.复原IP地址.md
+++ b/problems/0093.复原IP地址.md
@@ -8,7 +8,7 @@
 
 # 93.复原IP地址
 
-[力扣题目链接](https://leetcode-cn.com/problems/restore-ip-addresses/)
+[力扣题目链接](https://leetcode.cn/problems/restore-ip-addresses/)
 
 给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
 
diff --git a/problems/0096.不同的二叉搜索树.md b/problems/0096.不同的二叉搜索树.md
index 25561b50..9d98c62d 100644
--- a/problems/0096.不同的二叉搜索树.md
+++ b/problems/0096.不同的二叉搜索树.md
@@ -6,7 +6,7 @@
 
 # 96.不同的二叉搜索树
 
-[力扣题目链接](https://leetcode-cn.com/problems/unique-binary-search-trees/)
+[力扣题目链接](https://leetcode.cn/problems/unique-binary-search-trees/)
 
 给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？
 
diff --git a/problems/0098.验证二叉搜索树.md b/problems/0098.验证二叉搜索树.md
index a8f3c324..61dd5427 100644
--- a/problems/0098.验证二叉搜索树.md
+++ b/problems/0098.验证二叉搜索树.md
@@ -7,7 +7,7 @@
 
 # 98.验证二叉搜索树
 
-[力扣题目链接](https://leetcode-cn.com/problems/validate-binary-search-tree/)
+[力扣题目链接](https://leetcode.cn/problems/validate-binary-search-tree/)
 
 
 给定一个二叉树，判断其是否是一个有效的二叉搜索树。
diff --git a/problems/0100.相同的树.md b/problems/0100.相同的树.md
index 5e805d01..5288779b 100644
--- a/problems/0100.相同的树.md
+++ b/problems/0100.相同的树.md
@@ -8,7 +8,7 @@
 
 # 100. 相同的树
 
-[力扣题目链接](https://leetcode-cn.com/problems/same-tree/)
+[力扣题目链接](https://leetcode.cn/problems/same-tree/)
 
 给定两个二叉树，编写一个函数来检验它们是否相同。
 
diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index c79fde0e..40249bb7 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -7,7 +7,7 @@
 
 # 101. 对称二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/symmetric-tree/)
+[力扣题目链接](https://leetcode.cn/problems/symmetric-tree/)
 
 给定一个二叉树，检查它是否是镜像对称的。
 
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 3aa17699..a2717d09 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -26,7 +26,7 @@
 
 # 102.二叉树的层序遍历
 
-[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-level-order-traversal/)
+[力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
 
 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
 
@@ -379,7 +379,7 @@ pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
 
 # 107.二叉树的层次遍历 II
 
-[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/)
+[力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
 
 给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
 
@@ -660,7 +660,7 @@ pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
 
 # 199.二叉树的右视图
 
-[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-right-side-view/)
+[力扣题目链接](https://leetcode.cn/problems/binary-tree-right-side-view/)
 
 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
 
@@ -907,7 +907,7 @@ object Solution {
 
 # 637.二叉树的层平均值
 
-[力扣题目链接](https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/average-of-levels-in-binary-tree/)
 
 给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
 
@@ -1163,7 +1163,7 @@ object Solution {
 
 # 429.N叉树的层序遍历
 
-[力扣题目链接](https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/)
+[力扣题目链接](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
 
 给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。
 
@@ -1434,7 +1434,7 @@ object Solution {
 
 # 515.在每个树行中找最大值
 
-[力扣题目链接](https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/)
+[力扣题目链接](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
 
 您需要在二叉树的每一行中找到最大的值。
 
@@ -1668,7 +1668,7 @@ object Solution {
 
 # 116.填充每个节点的下一个右侧节点指针
 
-[力扣题目链接](https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/)
+[力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
 
 给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
 
@@ -1956,7 +1956,7 @@ object Solution {
 ```
 # 117.填充每个节点的下一个右侧节点指针II
 
-[力扣题目链接](https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/)
+[力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
 
 思路：
 
@@ -2236,7 +2236,7 @@ object Solution {
 ```
 # 104.二叉树的最大深度
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
 
 给定一个二叉树，找出其最大深度。
 
@@ -2477,7 +2477,7 @@ object Solution {
 
 # 111.二叉树的最小深度
 
-[力扣题目链接](https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
 
 相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
 
diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index 65a155fb..defe8e06 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -12,7 +12,7 @@
 
 # 104.二叉树的最大深度
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
 
 给定一个二叉树，找出其最大深度。
 
@@ -223,7 +223,7 @@ impl Solution {
 
 # 559.n叉树的最大深度
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximum-depth-of-n-ary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/)
 
 给定一个 n 叉树，找到其最大深度。
 
diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
index 188ad3cb..8cbe5eb6 100644
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -12,7 +12,7 @@
 
 # 106.从中序与后序遍历序列构造二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)
+[力扣题目链接](https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)
 
 根据一棵树的中序遍历与后序遍历构造二叉树。
 
@@ -394,7 +394,7 @@ public:
 
 # 105.从前序与中序遍历序列构造二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)
+[力扣题目链接](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)
 
 根据一棵树的前序遍历与中序遍历构造二叉树。
 
diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md
index 6ee3947b..c9c1a693 100644
--- a/problems/0108.将有序数组转换为二叉搜索树.md
+++ b/problems/0108.将有序数组转换为二叉搜索树.md
@@ -9,7 +9,7 @@
 
 # 108.将有序数组转换为二叉搜索树
 
-[力扣题目链接](https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/)
+[力扣题目链接](https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/)
 
 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
 
diff --git a/problems/0110.平衡二叉树.md b/problems/0110.平衡二叉树.md
index b7598365..3aa815ab 100644
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@@ -9,7 +9,7 @@
 
 # 110.平衡二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/balanced-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/balanced-binary-tree/)
 
 给定一个二叉树，判断它是否是高度平衡的二叉树。
 
diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index b1331659..9f5ef4c8 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -9,7 +9,7 @@
 
 # 111.二叉树的最小深度
 
-[力扣题目链接](https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
 
 给定一个二叉树，找出其最小深度。
 
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index d3eec16b..681cd1a0 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -16,7 +16,7 @@
 
 # 112. 路径总和
 
-[力扣题目链接](https://leetcode-cn.com/problems/path-sum/)
+[力扣题目链接](https://leetcode.cn/problems/path-sum/)
 
 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
 
@@ -216,7 +216,7 @@ public:
 
 # 113. 路径总和ii
 
-[力扣题目链接](https://leetcode-cn.com/problems/path-sum-ii/)
+[力扣题目链接](https://leetcode.cn/problems/path-sum-ii/)
 
 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
 
diff --git a/problems/0115.不同的子序列.md b/problems/0115.不同的子序列.md
index ca66e20d..9ae04139 100644
--- a/problems/0115.不同的子序列.md
+++ b/problems/0115.不同的子序列.md
@@ -6,7 +6,7 @@
 
 ## 115.不同的子序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/distinct-subsequences/)
+[力扣题目链接](https://leetcode.cn/problems/distinct-subsequences/)
 
 给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。
 
diff --git a/problems/0116.填充每个节点的下一个右侧节点指针.md b/problems/0116.填充每个节点的下一个右侧节点指针.md
index 2c443de5..ed8ce592 100644
--- a/problems/0116.填充每个节点的下一个右侧节点指针.md
+++ b/problems/0116.填充每个节点的下一个右侧节点指针.md
@@ -7,7 +7,7 @@
 
 # 116. 填充每个节点的下一个右侧节点指针
 
-[力扣题目链接](https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/)
+[力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
 
 给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
 
diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md
index a2498bb6..a577f1dd 100644
--- a/problems/0121.买卖股票的最佳时机.md
+++ b/problems/0121.买卖股票的最佳时机.md
@@ -6,7 +6,7 @@
 
 ## 121. 买卖股票的最佳时机
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/)
 
 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
 
diff --git a/problems/0122.买卖股票的最佳时机II.md b/problems/0122.买卖股票的最佳时机II.md
index 1e7b77d8..b9fa8386 100644
--- a/problems/0122.买卖股票的最佳时机II.md
+++ b/problems/0122.买卖股票的最佳时机II.md
@@ -7,7 +7,7 @@
 
 # 122.买卖股票的最佳时机II
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/)
 
 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
 
diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
index 12b21fde..fa9f8842 100644
--- a/problems/0122.买卖股票的最佳时机II（动态规划）.md
+++ b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -6,7 +6,7 @@
 
 ## 122.买卖股票的最佳时机II 
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/)
 
 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
 
diff --git a/problems/0123.买卖股票的最佳时机III.md b/problems/0123.买卖股票的最佳时机III.md
index 67c99497..c15aaee8 100644
--- a/problems/0123.买卖股票的最佳时机III.md
+++ b/problems/0123.买卖股票的最佳时机III.md
@@ -6,7 +6,7 @@
 
 ## 123.买卖股票的最佳时机III
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/)
 
 
 给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
diff --git a/problems/0127.单词接龙.md b/problems/0127.单词接龙.md
index 584bcb2a..f1c6f182 100644
--- a/problems/0127.单词接龙.md
+++ b/problems/0127.单词接龙.md
@@ -7,7 +7,7 @@
 
 # 127. 单词接龙
 
-[力扣题目链接](https://leetcode-cn.com/problems/word-ladder/)
+[力扣题目链接](https://leetcode.cn/problems/word-ladder/)
 
 字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：
 * 序列中第一个单词是 beginWord 。
diff --git a/problems/0129.求根到叶子节点数字之和.md b/problems/0129.求根到叶子节点数字之和.md
index b271ca7d..ea3845b7 100644
--- a/problems/0129.求根到叶子节点数字之和.md
+++ b/problems/0129.求根到叶子节点数字之和.md
@@ -5,7 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 # 129. 求根节点到叶节点数字之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/)
+[力扣题目链接](https://leetcode.cn/problems/sum-root-to-leaf-numbers/)
 
 # 思路
 
diff --git a/problems/0131.分割回文串.md b/problems/0131.分割回文串.md
index 7a702898..a70af603 100644
--- a/problems/0131.分割回文串.md
+++ b/problems/0131.分割回文串.md
@@ -9,7 +9,7 @@
 
 # 131.分割回文串
 
-[力扣题目链接](https://leetcode-cn.com/problems/palindrome-partitioning/)
+[力扣题目链接](https://leetcode.cn/problems/palindrome-partitioning/)
 
 给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
 
diff --git a/problems/0132.分割回文串II.md b/problems/0132.分割回文串II.md
index 87d3e4b4..92f9b602 100644
--- a/problems/0132.分割回文串II.md
+++ b/problems/0132.分割回文串II.md
@@ -8,7 +8,7 @@
 
 # 132. 分割回文串 II
 
-[力扣题目链接](https://leetcode-cn.com/problems/palindrome-partitioning-ii/)
+[力扣题目链接](https://leetcode.cn/problems/palindrome-partitioning-ii/)
 
 给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。
 
diff --git a/problems/0134.加油站.md b/problems/0134.加油站.md
index a88f677d..e6dec44b 100644
--- a/problems/0134.加油站.md
+++ b/problems/0134.加油站.md
@@ -7,7 +7,7 @@
 
 # 134. 加油站
 
-[力扣题目链接](https://leetcode-cn.com/problems/gas-station/)
+[力扣题目链接](https://leetcode.cn/problems/gas-station/)
 
 在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
 
diff --git a/problems/0135.分发糖果.md b/problems/0135.分发糖果.md
index 3456a04c..55c2efc7 100644
--- a/problems/0135.分发糖果.md
+++ b/problems/0135.分发糖果.md
@@ -7,7 +7,7 @@
 
 # 135. 分发糖果
 
-[力扣题目链接](https://leetcode-cn.com/problems/candy/)
+[力扣题目链接](https://leetcode.cn/problems/candy/)
 
 老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
 
diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
index 5b4e92b9..7ff13f72 100644
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@@ -8,7 +8,7 @@
 
 ## 139.单词拆分
 
-[力扣题目链接](https://leetcode-cn.com/problems/word-break/)
+[力扣题目链接](https://leetcode.cn/problems/word-break/)
 
 给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
 
diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index f8e62d45..6b7c7e66 100644
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@@ -11,7 +11,7 @@
 
 ## 142.环形链表II
 
-[力扣题目链接](https://leetcode-cn.com/problems/linked-list-cycle-ii/)
+[力扣题目链接](https://leetcode.cn/problems/linked-list-cycle-ii/)
 
 题意：
 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index 5452c304..05916135 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -11,7 +11,7 @@
 
 # 150. 逆波兰表达式求值
 
-[力扣题目链接](https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/)
+[力扣题目链接](https://leetcode.cn/problems/evaluate-reverse-polish-notation/)
 
 根据 逆波兰表示法，求表达式的值。
 
diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
index 0e25fc4d..1bcf9888 100644
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@@ -10,7 +10,7 @@
 
 # 151.翻转字符串里的单词
 
-[力扣题目链接](https://leetcode-cn.com/problems/reverse-words-in-a-string/)
+[力扣题目链接](https://leetcode.cn/problems/reverse-words-in-a-string/)
 
 给定一个字符串，逐个翻转字符串中的每个单词。
 
@@ -234,7 +234,7 @@ public:
     }
 
     void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
-        int slow = 0;   //整体思想参考Leetcode: 27. 移除元素：https://leetcode-cn.com/problems/remove-element/
+        int slow = 0;   //整体思想参考Leetcode: 27. 移除元素：https://leetcode.cn/problems/remove-element/
         for (int i = 0; i < s.size(); ++i) { //
             if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                 if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
diff --git a/problems/0188.买卖股票的最佳时机IV.md b/problems/0188.买卖股票的最佳时机IV.md
index 27eb38c3..7ff19852 100644
--- a/problems/0188.买卖股票的最佳时机IV.md
+++ b/problems/0188.买卖股票的最佳时机IV.md
@@ -6,7 +6,7 @@
 
 ## 188.买卖股票的最佳时机IV
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/)
 
 给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
 
diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md
index a828b9a9..ad660f27 100644
--- a/problems/0198.打家劫舍.md
+++ b/problems/0198.打家劫舍.md
@@ -6,7 +6,7 @@
 
 ## 198.打家劫舍
 
-[力扣题目链接](https://leetcode-cn.com/problems/house-robber/)
+[力扣题目链接](https://leetcode.cn/problems/house-robber/)
 
 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
 
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 7738b2f6..0bea0c72 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -10,7 +10,7 @@
 
 # 第202题. 快乐数
 
-[力扣题目链接](https://leetcode-cn.com/problems/happy-number/)
+[力扣题目链接](https://leetcode.cn/problems/happy-number/)
 
 编写一个算法来判断一个数 n 是不是快乐数。
 
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index 975ca429..b79d29a5 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -9,7 +9,7 @@
 
 # 203.移除链表元素
 
-[力扣题目链接](https://leetcode-cn.com/problems/remove-linked-list-elements/)
+[力扣题目链接](https://leetcode.cn/problems/remove-linked-list-elements/)
 
 题意：删除链表中等于给定值 val 的所有节点。
 
diff --git a/problems/0205.同构字符串.md b/problems/0205.同构字符串.md
index d4b71c59..284e7fd9 100644
--- a/problems/0205.同构字符串.md
+++ b/problems/0205.同构字符串.md
@@ -7,7 +7,7 @@
 
 # 205. 同构字符串
 
-[力扣题目链接](https://leetcode-cn.com/problems/isomorphic-strings/)
+[力扣题目链接](https://leetcode.cn/problems/isomorphic-strings/)
 
 给定两个字符串 s 和 t，判断它们是否是同构的。
 
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index 25b16907..d8a4eddb 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -9,7 +9,7 @@
 
 # 206.反转链表
 
-[力扣题目链接](https://leetcode-cn.com/problems/reverse-linked-list/)
+[力扣题目链接](https://leetcode.cn/problems/reverse-linked-list/)
 
 题意：反转一个单链表。
 
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index 69e0da4f..e2eb378e 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -7,7 +7,7 @@
 
 # 209.长度最小的子数组
 
-[力扣题目链接](https://leetcode-cn.com/problems/minimum-size-subarray-sum/)
+[力扣题目链接](https://leetcode.cn/problems/minimum-size-subarray-sum/)
 
 给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
 
@@ -133,8 +133,8 @@ public:
 
 ## 相关题目推荐
 
-* [904.水果成篮](https://leetcode-cn.com/problems/fruit-into-baskets/)
-* [76.最小覆盖子串](https://leetcode-cn.com/problems/minimum-window-substring/)
+* [904.水果成篮](https://leetcode.cn/problems/fruit-into-baskets/)
+* [76.最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring/)
 
 
 
diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
index 9e698d01..d6b53a24 100644
--- a/problems/0213.打家劫舍II.md
+++ b/problems/0213.打家劫舍II.md
@@ -6,7 +6,7 @@
 
 ## 213.打家劫舍II
 
-[力扣题目链接](https://leetcode-cn.com/problems/house-robber-ii/)
+[力扣题目链接](https://leetcode.cn/problems/house-robber-ii/)
 
 你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
 
diff --git a/problems/0216.组合总和III.md b/problems/0216.组合总和III.md
index 32b1347e..cb9e379f 100644
--- a/problems/0216.组合总和III.md
+++ b/problems/0216.组合总和III.md
@@ -11,7 +11,7 @@
 
 # 216.组合总和III
 
-[力扣题目链接](https://leetcode-cn.com/problems/combination-sum-iii/)
+[力扣题目链接](https://leetcode.cn/problems/combination-sum-iii/)
 
 找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
 
diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index ba7acc5a..82d748a7 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -7,7 +7,7 @@
 
 # 222.完全二叉树的节点个数
 
-[力扣题目链接](https://leetcode-cn.com/problems/count-complete-tree-nodes/)
+[力扣题目链接](https://leetcode.cn/problems/count-complete-tree-nodes/)
 
 给出一个完全二叉树，求出该树的节点个数。
 
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index 3c134870..994d1875 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -10,7 +10,7 @@
 
 # 225. 用队列实现栈
 
-[力扣题目链接](https://leetcode-cn.com/problems/implement-stack-using-queues/)
+[力扣题目链接](https://leetcode.cn/problems/implement-stack-using-queues/)
 
 使用队列实现栈的下列操作：
 
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index 9b5cfbae..8e35fc9d 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -7,7 +7,7 @@
 
 # 226.翻转二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/invert-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/invert-binary-tree/)
 
 翻转一棵二叉树。
 
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index d9ba8e26..47993fa1 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -9,7 +9,7 @@
 
 # 232.用栈实现队列
 
-[力扣题目链接](https://leetcode-cn.com/problems/implement-queue-using-stacks/)
+[力扣题目链接](https://leetcode.cn/problems/implement-queue-using-stacks/)
 
 使用栈实现队列的下列操作：
 
diff --git a/problems/0234.回文链表.md b/problems/0234.回文链表.md
index db910d4e..f591fcef 100644
--- a/problems/0234.回文链表.md
+++ b/problems/0234.回文链表.md
@@ -7,7 +7,7 @@
 
 # 234.回文链表
 
-[力扣题目链接](https://leetcode-cn.com/problems/palindrome-linked-list/)
+[力扣题目链接](https://leetcode.cn/problems/palindrome-linked-list/)
 
 请判断一个链表是否为回文链表。
 
diff --git a/problems/0235.二叉搜索树的最近公共祖先.md b/problems/0235.二叉搜索树的最近公共祖先.md
index f7f1427a..9ff7e293 100644
--- a/problems/0235.二叉搜索树的最近公共祖先.md
+++ b/problems/0235.二叉搜索树的最近公共祖先.md
@@ -7,7 +7,7 @@
 
 # 235. 二叉搜索树的最近公共祖先
 
-[力扣题目链接](https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)
+[力扣题目链接](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/)
 
 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
 
diff --git a/problems/0236.二叉树的最近公共祖先.md b/problems/0236.二叉树的最近公共祖先.md
index 69a6d0d6..23695b11 100644
--- a/problems/0236.二叉树的最近公共祖先.md
+++ b/problems/0236.二叉树的最近公共祖先.md
@@ -9,7 +9,7 @@
 
 # 236. 二叉树的最近公共祖先
 
-[力扣题目链接](https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/)
+[力扣题目链接](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/)
 
 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
 
diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md
index eb32fdd2..23e79c80 100644
--- a/problems/0239.滑动窗口最大值.md
+++ b/problems/0239.滑动窗口最大值.md
@@ -10,7 +10,7 @@
 
 # 239. 滑动窗口最大值
 
-[力扣题目链接](https://leetcode-cn.com/problems/sliding-window-maximum/)
+[力扣题目链接](https://leetcode.cn/problems/sliding-window-maximum/)
 
 给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
 
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index 8fd9c604..8f4b5ae2 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@@ -9,7 +9,7 @@
 
 ## 242.有效的字母异位词
 
-[力扣题目链接](https://leetcode-cn.com/problems/valid-anagram/)
+[力扣题目链接](https://leetcode.cn/problems/valid-anagram/)
 
 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
 
diff --git a/problems/0257.二叉树的所有路径.md b/problems/0257.二叉树的所有路径.md
index 1362897c..dc76a432 100644
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@@ -9,7 +9,7 @@
 
 # 257. 二叉树的所有路径
 
-[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-paths/)
+[力扣题目链接](https://leetcode.cn/problems/binary-tree-paths/)
 
 给定一个二叉树，返回所有从根节点到叶子节点的路径。
 
diff --git a/problems/0279.完全平方数.md b/problems/0279.完全平方数.md
index 5b15639c..e8ec98c6 100644
--- a/problems/0279.完全平方数.md
+++ b/problems/0279.完全平方数.md
@@ -7,7 +7,7 @@
 
 ## 279.完全平方数
 
-[力扣题目链接](https://leetcode-cn.com/problems/perfect-squares/)
+[力扣题目链接](https://leetcode.cn/problems/perfect-squares/)
 
 给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
 
diff --git a/problems/0283.移动零.md b/problems/0283.移动零.md
index ed59d2c4..9600edd3 100644
--- a/problems/0283.移动零.md
+++ b/problems/0283.移动零.md
@@ -8,7 +8,7 @@
 
 # 283. 移动零
 
-[力扣题目链接](https://leetcode-cn.com/problems/move-zeroes/)
+[力扣题目链接](https://leetcode.cn/problems/move-zeroes/)
 
 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
 
diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
index ffa66c02..41c6a7ce 100644
--- a/problems/0300.最长上升子序列.md
+++ b/problems/0300.最长上升子序列.md
@@ -6,7 +6,7 @@
 
 ## 300.最长递增子序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/longest-increasing-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/longest-increasing-subsequence/)
 
 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
 
diff --git a/problems/0309.最佳买卖股票时机含冷冻期.md b/problems/0309.最佳买卖股票时机含冷冻期.md
index f037fe85..229fc636 100644
--- a/problems/0309.最佳买卖股票时机含冷冻期.md
+++ b/problems/0309.最佳买卖股票时机含冷冻期.md
@@ -6,7 +6,7 @@
 
 ## 309.最佳买卖股票时机含冷冻期
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
 
 给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
 
diff --git a/problems/0322.零钱兑换.md b/problems/0322.零钱兑换.md
index fc0490c8..03c6a4e2 100644
--- a/problems/0322.零钱兑换.md
+++ b/problems/0322.零钱兑换.md
@@ -7,7 +7,7 @@
 
 ## 322. 零钱兑换
 
-[力扣题目链接](https://leetcode-cn.com/problems/coin-change/)
+[力扣题目链接](https://leetcode.cn/problems/coin-change/)
 
 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
 
diff --git a/problems/0332.重新安排行程.md b/problems/0332.重新安排行程.md
index c71b2a93..71942c79 100644
--- a/problems/0332.重新安排行程.md
+++ b/problems/0332.重新安排行程.md
@@ -9,7 +9,7 @@
 
 # 332.重新安排行程
 
-[力扣题目链接](https://leetcode-cn.com/problems/reconstruct-itinerary/)
+[力扣题目链接](https://leetcode.cn/problems/reconstruct-itinerary/)
 
 给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。
 
diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md
index 6f50723d..d2add232 100644
--- a/problems/0337.打家劫舍III.md
+++ b/problems/0337.打家劫舍III.md
@@ -7,7 +7,7 @@
 
 ## 337.打家劫舍 III
 
-[力扣题目链接](https://leetcode-cn.com/problems/house-robber-iii/)
+[力扣题目链接](https://leetcode.cn/problems/house-robber-iii/)
 
 在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
 
diff --git a/problems/0343.整数拆分.md b/problems/0343.整数拆分.md
index 279f1d71..dd03937f 100644
--- a/problems/0343.整数拆分.md
+++ b/problems/0343.整数拆分.md
@@ -6,7 +6,7 @@
 
 # 343. 整数拆分
 
-[力扣题目链接](https://leetcode-cn.com/problems/integer-break/)
+[力扣题目链接](https://leetcode.cn/problems/integer-break/)
 
 给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
 
diff --git a/problems/0344.反转字符串.md b/problems/0344.反转字符串.md
index e1f27bd7..1217be15 100644
--- a/problems/0344.反转字符串.md
+++ b/problems/0344.反转字符串.md
@@ -10,7 +10,7 @@
 
 # 344.反转字符串
 
-[力扣题目链接](https://leetcode-cn.com/problems/reverse-string/)
+[力扣题目链接](https://leetcode.cn/problems/reverse-string/)
 
 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
 
diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 20932b28..a04041cc 100644
--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@@ -11,7 +11,7 @@
 
 # 347.前 K 个高频元素
 
-[力扣题目链接](https://leetcode-cn.com/problems/top-k-frequent-elements/)
+[力扣题目链接](https://leetcode.cn/problems/top-k-frequent-elements/)
 
 给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
 
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 4fbdd414..98518647 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -12,7 +12,7 @@
 
 ## 349. 两个数组的交集
 
-[力扣题目链接](https://leetcode-cn.com/problems/intersection-of-two-arrays/)
+[力扣题目链接](https://leetcode.cn/problems/intersection-of-two-arrays/)
 
 题意：给定两个数组，编写一个函数来计算它们的交集。
 
diff --git a/problems/0376.摆动序列.md b/problems/0376.摆动序列.md
index 6822896e..00f8f70c 100644
--- a/problems/0376.摆动序列.md
+++ b/problems/0376.摆动序列.md
@@ -9,7 +9,7 @@
 
 # 376. 摆动序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/wiggle-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/wiggle-subsequence/)
 
 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
 
diff --git a/problems/0377.组合总和Ⅳ.md b/problems/0377.组合总和Ⅳ.md
index 1d808a3a..f8e544a9 100644
--- a/problems/0377.组合总和Ⅳ.md
+++ b/problems/0377.组合总和Ⅳ.md
@@ -8,7 +8,7 @@
 
 ## 377. 组合总和 Ⅳ
 
-[力扣题目链接](https://leetcode-cn.com/problems/combination-sum-iv/)
+[力扣题目链接](https://leetcode.cn/problems/combination-sum-iv/)
 
 难度：中等
 
diff --git a/problems/0383.赎金信.md b/problems/0383.赎金信.md
index 9c3dda8c..3cde5472 100644
--- a/problems/0383.赎金信.md
+++ b/problems/0383.赎金信.md
@@ -10,7 +10,7 @@
 
 # 383. 赎金信
 
-[力扣题目链接](https://leetcode-cn.com/problems/ransom-note/)
+[力扣题目链接](https://leetcode.cn/problems/ransom-note/)
 
 给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
 
diff --git a/problems/0392.判断子序列.md b/problems/0392.判断子序列.md
index 3f7eb11d..9a26d639 100644
--- a/problems/0392.判断子序列.md
+++ b/problems/0392.判断子序列.md
@@ -7,7 +7,7 @@
 
 ## 392.判断子序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/is-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/is-subsequence/)
 
 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
 
diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
index 4ef68d3b..6a1d80c9 100644
--- a/problems/0404.左叶子之和.md
+++ b/problems/0404.左叶子之和.md
@@ -7,7 +7,7 @@
 
 # 404.左叶子之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/sum-of-left-leaves/)
+[力扣题目链接](https://leetcode.cn/problems/sum-of-left-leaves/)
 
 计算给定二叉树的所有左叶子之和。
 
diff --git a/problems/0406.根据身高重建队列.md b/problems/0406.根据身高重建队列.md
index 641086a9..879820ea 100644
--- a/problems/0406.根据身高重建队列.md
+++ b/problems/0406.根据身高重建队列.md
@@ -7,7 +7,7 @@
 
 # 406.根据身高重建队列
 
-[力扣题目链接](https://leetcode-cn.com/problems/queue-reconstruction-by-height/)
+[力扣题目链接](https://leetcode.cn/problems/queue-reconstruction-by-height/)
 
 假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。
 
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index eb6601e1..b9fa78d2 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -6,7 +6,7 @@
 
 ## 416. 分割等和子集
 
-[力扣题目链接](https://leetcode-cn.com/problems/partition-equal-subset-sum/)
+[力扣题目链接](https://leetcode.cn/problems/partition-equal-subset-sum/)
 
 题目难易：中等
 
diff --git a/problems/0435.无重叠区间.md b/problems/0435.无重叠区间.md
index 66aa1244..f1e259ae 100644
--- a/problems/0435.无重叠区间.md
+++ b/problems/0435.无重叠区间.md
@@ -7,7 +7,7 @@
 
 # 435. 无重叠区间
 
-[力扣题目链接](https://leetcode-cn.com/problems/non-overlapping-intervals/)
+[力扣题目链接](https://leetcode.cn/problems/non-overlapping-intervals/)
 
 给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。
 
diff --git a/problems/0450.删除二叉搜索树中的节点.md b/problems/0450.删除二叉搜索树中的节点.md
index e8f7e54c..aca9084f 100644
--- a/problems/0450.删除二叉搜索树中的节点.md
+++ b/problems/0450.删除二叉搜索树中的节点.md
@@ -9,7 +9,7 @@
 
 # 450.删除二叉搜索树中的节点
 
-[力扣题目链接]( https://leetcode-cn.com/problems/delete-node-in-a-bst/)
+[力扣题目链接]( https://leetcode.cn/problems/delete-node-in-a-bst/)
 
 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
 
diff --git a/problems/0452.用最少数量的箭引爆气球.md b/problems/0452.用最少数量的箭引爆气球.md
index d4bbe961..e593b876 100644
--- a/problems/0452.用最少数量的箭引爆气球.md
+++ b/problems/0452.用最少数量的箭引爆气球.md
@@ -7,7 +7,7 @@
 
 # 452. 用最少数量的箭引爆气球
 
-[力扣题目链接](https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/)
+[力扣题目链接](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons/)
 
 在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。
 
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index 726fdb15..d22e2335 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -9,7 +9,7 @@
 
 # 第454题.四数相加II
 
-[力扣题目链接](https://leetcode-cn.com/problems/4sum-ii/)
+[力扣题目链接](https://leetcode.cn/problems/4sum-ii/)
 
 给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
 
diff --git a/problems/0455.分发饼干.md b/problems/0455.分发饼干.md
index 17db4a85..b787dee6 100644
--- a/problems/0455.分发饼干.md
+++ b/problems/0455.分发饼干.md
@@ -7,7 +7,7 @@
 
 # 455.分发饼干
 
-[力扣题目链接](https://leetcode-cn.com/problems/assign-cookies/)
+[力扣题目链接](https://leetcode.cn/problems/assign-cookies/)
 
 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
 
diff --git a/problems/0459.重复的子字符串.md b/problems/0459.重复的子字符串.md
index a51c68ee..bb55bd7c 100644
--- a/problems/0459.重复的子字符串.md
+++ b/problems/0459.重复的子字符串.md
@@ -11,7 +11,7 @@
 
 # 459.重复的子字符串
 
-[力扣题目链接](https://leetcode-cn.com/problems/repeated-substring-pattern/)
+[力扣题目链接](https://leetcode.cn/problems/repeated-substring-pattern/)
 
 给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
 
diff --git a/problems/0463.岛屿的周长.md b/problems/0463.岛屿的周长.md
index 9911dfe5..ea038140 100644
--- a/problems/0463.岛屿的周长.md
+++ b/problems/0463.岛屿的周长.md
@@ -5,7 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 # 463. 岛屿的周长
 
-[力扣题目链接](https://leetcode-cn.com/problems/island-perimeter/)
+[力扣题目链接](https://leetcode.cn/problems/island-perimeter/)
 
 ## 思路
 
diff --git a/problems/0474.一和零.md b/problems/0474.一和零.md
index d38ce03f..a5018baf 100644
--- a/problems/0474.一和零.md
+++ b/problems/0474.一和零.md
@@ -7,7 +7,7 @@
 
 ## 474.一和零
 
-[力扣题目链接](https://leetcode-cn.com/problems/ones-and-zeroes/)
+[力扣题目链接](https://leetcode.cn/problems/ones-and-zeroes/)
 
 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
 
diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md
index 3ea2382b..291a19bd 100644
--- a/problems/0491.递增子序列.md
+++ b/problems/0491.递增子序列.md
@@ -9,7 +9,7 @@
 
 # 491.递增子序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/increasing-subsequences/)
+[力扣题目链接](https://leetcode.cn/problems/increasing-subsequences/)
 
 给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。
 
diff --git a/problems/0494.目标和.md b/problems/0494.目标和.md
index 8ce1f6f1..540de7f4 100644
--- a/problems/0494.目标和.md
+++ b/problems/0494.目标和.md
@@ -7,7 +7,7 @@
 
 ## 494. 目标和
 
-[力扣题目链接](https://leetcode-cn.com/problems/target-sum/)
+[力扣题目链接](https://leetcode.cn/problems/target-sum/)
 
 难度：中等
 
diff --git a/problems/0496.下一个更大元素I.md b/problems/0496.下一个更大元素I.md
index 02339677..aa5277f8 100644
--- a/problems/0496.下一个更大元素I.md
+++ b/problems/0496.下一个更大元素I.md
@@ -6,7 +6,7 @@
 
 # 496.下一个更大元素 I
 
-[力扣题目链接](https://leetcode-cn.com/problems/next-greater-element-i/)
+[力扣题目链接](https://leetcode.cn/problems/next-greater-element-i/)
 
 给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。
 
diff --git a/problems/0501.二叉搜索树中的众数.md b/problems/0501.二叉搜索树中的众数.md
index 9cb5d071..f22f1eb3 100644
--- a/problems/0501.二叉搜索树中的众数.md
+++ b/problems/0501.二叉搜索树中的众数.md
@@ -9,7 +9,7 @@
 
 # 501.二叉搜索树中的众数
 
-[力扣题目链接](https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/solution/)
+[力扣题目链接](https://leetcode.cn/problems/find-mode-in-binary-search-tree/solution/)
 
 给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。
 
diff --git a/problems/0503.下一个更大元素II.md b/problems/0503.下一个更大元素II.md
index ace4d40b..67c2c9bc 100644
--- a/problems/0503.下一个更大元素II.md
+++ b/problems/0503.下一个更大元素II.md
@@ -6,7 +6,7 @@
 
 # 503.下一个更大元素II
 
-[力扣题目链接](https://leetcode-cn.com/problems/next-greater-element-ii/)
+[力扣题目链接](https://leetcode.cn/problems/next-greater-element-ii/)
 
 给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。
 
diff --git a/problems/0509.斐波那契数.md b/problems/0509.斐波那契数.md
index 1d17784d..71647a0a 100644
--- a/problems/0509.斐波那契数.md
+++ b/problems/0509.斐波那契数.md
@@ -6,7 +6,7 @@
 
 # 509. 斐波那契数
 
-[力扣题目链接](https://leetcode-cn.com/problems/fibonacci-number/)
+[力扣题目链接](https://leetcode.cn/problems/fibonacci-number/)
 
 斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
 F(0) = 0，F(1) = 1
diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
index 12c62c70..6230ea51 100644
--- a/problems/0513.找树左下角的值.md
+++ b/problems/0513.找树左下角的值.md
@@ -7,7 +7,7 @@
 
 # 513.找树左下角的值
 
-[力扣题目链接](https://leetcode-cn.com/problems/find-bottom-left-tree-value/)
+[力扣题目链接](https://leetcode.cn/problems/find-bottom-left-tree-value/)
 
 给定一个二叉树，在树的最后一行找到最左边的值。
 
diff --git a/problems/0516.最长回文子序列.md b/problems/0516.最长回文子序列.md
index 63120b14..ba71b240 100644
--- a/problems/0516.最长回文子序列.md
+++ b/problems/0516.最长回文子序列.md
@@ -5,7 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 ## 516.最长回文子序列
-[力扣题目链接](https://leetcode-cn.com/problems/longest-palindromic-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/longest-palindromic-subsequence/)
 
 给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
 
diff --git a/problems/0518.零钱兑换II.md b/problems/0518.零钱兑换II.md
index b6593438..222a10d7 100644
--- a/problems/0518.零钱兑换II.md
+++ b/problems/0518.零钱兑换II.md
@@ -7,7 +7,7 @@
 
 ## 518. 零钱兑换 II
 
-[力扣题目链接](https://leetcode-cn.com/problems/coin-change-2/)
+[力扣题目链接](https://leetcode.cn/problems/coin-change-2/)
 
 难度：中等
 
diff --git a/problems/0530.二叉搜索树的最小绝对差.md b/problems/0530.二叉搜索树的最小绝对差.md
index 77699c9f..cbf8138c 100644
--- a/problems/0530.二叉搜索树的最小绝对差.md
+++ b/problems/0530.二叉搜索树的最小绝对差.md
@@ -9,7 +9,7 @@
 
 # 530.二叉搜索树的最小绝对差
 
-[力扣题目链接](https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/)
+[力扣题目链接](https://leetcode.cn/problems/minimum-absolute-difference-in-bst/)
 
 给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。
 
diff --git a/problems/0538.把二叉搜索树转换为累加树.md b/problems/0538.把二叉搜索树转换为累加树.md
index 37eb7d0f..853cca6f 100644
--- a/problems/0538.把二叉搜索树转换为累加树.md
+++ b/problems/0538.把二叉搜索树转换为累加树.md
@@ -7,7 +7,7 @@
 
 # 538.把二叉搜索树转换为累加树
 
-[力扣题目链接](https://leetcode-cn.com/problems/convert-bst-to-greater-tree/)
+[力扣题目链接](https://leetcode.cn/problems/convert-bst-to-greater-tree/)
 
 给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
 
diff --git a/problems/0541.反转字符串II.md b/problems/0541.反转字符串II.md
index 99d6ebe0..2a4bd3b3 100644
--- a/problems/0541.反转字符串II.md
+++ b/problems/0541.反转字符串II.md
@@ -10,7 +10,7 @@
 
 # 541. 反转字符串II
 
-[力扣题目链接](https://leetcode-cn.com/problems/reverse-string-ii/)
+[力扣题目链接](https://leetcode.cn/problems/reverse-string-ii/)
 
 给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。
 
diff --git a/problems/0583.两个字符串的删除操作.md b/problems/0583.两个字符串的删除操作.md
index 00f11700..fc7e6f39 100644
--- a/problems/0583.两个字符串的删除操作.md
+++ b/problems/0583.两个字符串的删除操作.md
@@ -6,7 +6,7 @@
 
 ## 583. 两个字符串的删除操作 
 
-[力扣题目链接](https://leetcode-cn.com/problems/delete-operation-for-two-strings/)
+[力扣题目链接](https://leetcode.cn/problems/delete-operation-for-two-strings/)
 
 给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。   
 
diff --git a/problems/0617.合并二叉树.md b/problems/0617.合并二叉树.md
index 55786ea9..40aa98c3 100644
--- a/problems/0617.合并二叉树.md
+++ b/problems/0617.合并二叉树.md
@@ -7,7 +7,7 @@
 
 # 617.合并二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/merge-two-binary-trees/)
+[力扣题目链接](https://leetcode.cn/problems/merge-two-binary-trees/)
 
 给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
 
diff --git a/problems/0647.回文子串.md b/problems/0647.回文子串.md
index 913aec65..dd0b8d51 100644
--- a/problems/0647.回文子串.md
+++ b/problems/0647.回文子串.md
@@ -6,7 +6,7 @@
 
 ## 647. 回文子串
 
-[力扣题目链接](https://leetcode-cn.com/problems/palindromic-substrings/)
+[力扣题目链接](https://leetcode.cn/problems/palindromic-substrings/)
 
 给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
 
diff --git a/problems/0649.Dota2参议院.md b/problems/0649.Dota2参议院.md
index 6e84c9fd..f1b3be11 100644
--- a/problems/0649.Dota2参议院.md
+++ b/problems/0649.Dota2参议院.md
@@ -8,7 +8,7 @@
 
 # 649. Dota2 参议院
 
-[力扣题目链接](https://leetcode-cn.com/problems/dota2-senate/)
+[力扣题目链接](https://leetcode.cn/problems/dota2-senate/)
 
 
 Dota2 的世界里有两个阵营：Radiant(天辉)和 Dire(夜魇)
diff --git a/problems/0654.最大二叉树.md b/problems/0654.最大二叉树.md
index 1c73354b..38d2a9ec 100644
--- a/problems/0654.最大二叉树.md
+++ b/problems/0654.最大二叉树.md
@@ -7,7 +7,7 @@
 
 # 654.最大二叉树
 
-[力扣题目地址](https://leetcode-cn.com/problems/maximum-binary-tree/)
+[力扣题目地址](https://leetcode.cn/problems/maximum-binary-tree/)
 
 给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：
 
diff --git a/problems/0657.机器人能否返回原点.md b/problems/0657.机器人能否返回原点.md
index 4eb69a6c..3d91a5c3 100644
--- a/problems/0657.机器人能否返回原点.md
+++ b/problems/0657.机器人能否返回原点.md
@@ -7,7 +7,7 @@
 
 # 657. 机器人能否返回原点
 
-[力扣题目链接](https://leetcode-cn.com/problems/robot-return-to-origin/)
+[力扣题目链接](https://leetcode.cn/problems/robot-return-to-origin/)
 
 在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
 
diff --git a/problems/0669.修剪二叉搜索树.md b/problems/0669.修剪二叉搜索树.md
index 385b2268..154ba5a9 100644
--- a/problems/0669.修剪二叉搜索树.md
+++ b/problems/0669.修剪二叉搜索树.md
@@ -10,7 +10,7 @@
 
 # 669. 修剪二叉搜索树
 
-[力扣题目链接](https://leetcode-cn.com/problems/trim-a-binary-search-tree/)
+[力扣题目链接](https://leetcode.cn/problems/trim-a-binary-search-tree/)
 
 给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。
 
diff --git a/problems/0673.最长递增子序列的个数.md b/problems/0673.最长递增子序列的个数.md
index 9a2c5db2..8a6a2d46 100644
--- a/problems/0673.最长递增子序列的个数.md
+++ b/problems/0673.最长递增子序列的个数.md
@@ -8,7 +8,7 @@
 # 673.最长递增子序列的个数
 
 
-[力扣题目链接](https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/number-of-longest-increasing-subsequence/)
 
 
 给定一个未排序的整数数组，找到最长递增子序列的个数。
diff --git a/problems/0674.最长连续递增序列.md b/problems/0674.最长连续递增序列.md
index b1ed80c3..5865a68d 100644
--- a/problems/0674.最长连续递增序列.md
+++ b/problems/0674.最长连续递增序列.md
@@ -6,7 +6,7 @@
 
 ## 674. 最长连续递增序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/longest-continuous-increasing-subsequence/)
 
 给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。
 
diff --git a/problems/0684.冗余连接.md b/problems/0684.冗余连接.md
index a16833bc..3928e051 100644
--- a/problems/0684.冗余连接.md
+++ b/problems/0684.冗余连接.md
@@ -9,7 +9,7 @@
 # 684.冗余连接
 
 
-[力扣题目链接](https://leetcode-cn.com/problems/redundant-connection/)
+[力扣题目链接](https://leetcode.cn/problems/redundant-connection/)
 
 树可以看成是一个连通且 无环 的 无向 图。
 
diff --git a/problems/0685.冗余连接II.md b/problems/0685.冗余连接II.md
index d96d4912..a8da1124 100644
--- a/problems/0685.冗余连接II.md
+++ b/problems/0685.冗余连接II.md
@@ -7,7 +7,7 @@
 
 # 685.冗余连接II
 
-[力扣题目链接](https://leetcode-cn.com/problems/redundant-connection-ii/)
+[力扣题目链接](https://leetcode.cn/problems/redundant-connection-ii/)
 
 在本问题中，有根树指满足以下条件的 有向 图。该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。
 
diff --git a/problems/0700.二叉搜索树中的搜索.md b/problems/0700.二叉搜索树中的搜索.md
index 40cf4ea1..bda400c2 100644
--- a/problems/0700.二叉搜索树中的搜索.md
+++ b/problems/0700.二叉搜索树中的搜索.md
@@ -7,7 +7,7 @@
 
 # 700.二叉搜索树中的搜索
 
-[力扣题目地址](https://leetcode-cn.com/problems/search-in-a-binary-search-tree/)
+[力扣题目地址](https://leetcode.cn/problems/search-in-a-binary-search-tree/)
 
 给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
 
diff --git a/problems/0701.二叉搜索树中的插入操作.md b/problems/0701.二叉搜索树中的插入操作.md
index 50e39ade..102f091e 100644
--- a/problems/0701.二叉搜索树中的插入操作.md
+++ b/problems/0701.二叉搜索树中的插入操作.md
@@ -7,7 +7,7 @@
 
 # 701.二叉搜索树中的插入操作
 
-[力扣题目链接](https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/)
+[力扣题目链接](https://leetcode.cn/problems/insert-into-a-binary-search-tree/)
 
 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。
 
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index 50f01226..6a37e4d1 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -7,7 +7,7 @@
 
 ## 704. 二分查找
 
-[力扣题目链接](https://leetcode-cn.com/problems/binary-search/)
+[力扣题目链接](https://leetcode.cn/problems/binary-search/)
 
 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
 
diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index dcdb53f4..6ee11eef 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -9,7 +9,7 @@
 
 # 707.设计链表
 
-[力扣题目链接](https://leetcode-cn.com/problems/design-linked-list/)
+[力扣题目链接](https://leetcode.cn/problems/design-linked-list/)
 
 题意：
 
diff --git a/problems/0714.买卖股票的最佳时机含手续费.md b/problems/0714.买卖股票的最佳时机含手续费.md
index b27631c6..7600c52c 100644
--- a/problems/0714.买卖股票的最佳时机含手续费.md
+++ b/problems/0714.买卖股票的最佳时机含手续费.md
@@ -7,7 +7,7 @@
 
 # 714. 买卖股票的最佳时机含手续费
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)
 
 给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。
 
diff --git a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
index 5625604b..7734450e 100644
--- a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
+++ b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
@@ -6,7 +6,7 @@
 
 ## 714.买卖股票的最佳时机含手续费
 
-[力扣题目链接](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)
+[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)
 
 给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。
 
diff --git a/problems/0718.最长重复子数组.md b/problems/0718.最长重复子数组.md
index 0b7b5199..18007b70 100644
--- a/problems/0718.最长重复子数组.md
+++ b/problems/0718.最长重复子数组.md
@@ -6,7 +6,7 @@
 
 ## 718. 最长重复子数组
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray/)
+[力扣题目链接](https://leetcode.cn/problems/maximum-length-of-repeated-subarray/)
 
 给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。
 
diff --git a/problems/0724.寻找数组的中心索引.md b/problems/0724.寻找数组的中心索引.md
index 14dcd2c0..2fc42009 100644
--- a/problems/0724.寻找数组的中心索引.md
+++ b/problems/0724.寻找数组的中心索引.md
@@ -7,7 +7,7 @@
 
 # 724.寻找数组的中心下标
 
-[力扣题目链接](https://leetcode-cn.com/problems/find-pivot-index/)
+[力扣题目链接](https://leetcode.cn/problems/find-pivot-index/)
 
 给你一个整数数组 nums ，请计算数组的 中心下标 。
 
diff --git a/problems/0738.单调递增的数字.md b/problems/0738.单调递增的数字.md
index 4e4079a7..d2f041f5 100644
--- a/problems/0738.单调递增的数字.md
+++ b/problems/0738.单调递增的数字.md
@@ -6,7 +6,7 @@
 
 
 # 738.单调递增的数字
-[力扣题目链接](https://leetcode-cn.com/problems/monotone-increasing-digits/)
+[力扣题目链接](https://leetcode.cn/problems/monotone-increasing-digits/)
 
 给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
 
diff --git a/problems/0739.每日温度.md b/problems/0739.每日温度.md
index 987ce27e..dbe9afe0 100644
--- a/problems/0739.每日温度.md
+++ b/problems/0739.每日温度.md
@@ -7,7 +7,7 @@
 
 # 739. 每日温度
 
-[力扣题目链接](https://leetcode-cn.com/problems/daily-temperatures/)
+[力扣题目链接](https://leetcode.cn/problems/daily-temperatures/)
 
 请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。
 
diff --git a/problems/0746.使用最小花费爬楼梯.md b/problems/0746.使用最小花费爬楼梯.md
index 5931fc8a..c2c73715 100644
--- a/problems/0746.使用最小花费爬楼梯.md
+++ b/problems/0746.使用最小花费爬楼梯.md
@@ -6,7 +6,7 @@
 
 # 746. 使用最小花费爬楼梯
 
-[力扣题目链接](https://leetcode-cn.com/problems/min-cost-climbing-stairs/)
+[力扣题目链接](https://leetcode.cn/problems/min-cost-climbing-stairs/)
 
 数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
 
diff --git a/problems/0763.划分字母区间.md b/problems/0763.划分字母区间.md
index 2f4d1b48..eb21e42f 100644
--- a/problems/0763.划分字母区间.md
+++ b/problems/0763.划分字母区间.md
@@ -7,7 +7,7 @@
 
 # 763.划分字母区间
 
-[力扣题目链接](https://leetcode-cn.com/problems/partition-labels/)
+[力扣题目链接](https://leetcode.cn/problems/partition-labels/)
 
 字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。
 
diff --git a/problems/0841.钥匙和房间.md b/problems/0841.钥匙和房间.md
index 1cd13065..6f51b4ad 100644
--- a/problems/0841.钥匙和房间.md
+++ b/problems/0841.钥匙和房间.md
@@ -8,7 +8,7 @@
 
 # 841.钥匙和房间
 
-[力扣题目链接](https://leetcode-cn.com/problems/keys-and-rooms/)
+[力扣题目链接](https://leetcode.cn/problems/keys-and-rooms/)
 
 有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。
 
diff --git a/problems/0844.比较含退格的字符串.md b/problems/0844.比较含退格的字符串.md
index dccc5404..c0773653 100644
--- a/problems/0844.比较含退格的字符串.md
+++ b/problems/0844.比较含退格的字符串.md
@@ -7,7 +7,7 @@
 
 # 844.比较含退格的字符串
 
-[力扣题目链接](https://leetcode-cn.com/problems/backspace-string-compare/)
+[力扣题目链接](https://leetcode.cn/problems/backspace-string-compare/)
 
 给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。
 
diff --git a/problems/0860.柠檬水找零.md b/problems/0860.柠檬水找零.md
index aa09e1c6..f5785a91 100644
--- a/problems/0860.柠檬水找零.md
+++ b/problems/0860.柠檬水找零.md
@@ -7,7 +7,7 @@
 
 # 860.柠檬水找零
 
-[力扣题目链接](https://leetcode-cn.com/problems/lemonade-change/)
+[力扣题目链接](https://leetcode.cn/problems/lemonade-change/)
 
 在柠檬水摊上，每一杯柠檬水的售价为 5 美元。
 
diff --git a/problems/0922.按奇偶排序数组II.md b/problems/0922.按奇偶排序数组II.md
index cb564fb6..8ca46db9 100644
--- a/problems/0922.按奇偶排序数组II.md
+++ b/problems/0922.按奇偶排序数组II.md
@@ -9,7 +9,7 @@
 
 # 922. 按奇偶排序数组II
 
-[力扣题目链接](https://leetcode-cn.com/problems/sort-array-by-parity-ii/)
+[力扣题目链接](https://leetcode.cn/problems/sort-array-by-parity-ii/)
 
 给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。
 
diff --git a/problems/0925.长按键入.md b/problems/0925.长按键入.md
index 0ef5a3d7..bb6aeff2 100644
--- a/problems/0925.长按键入.md
+++ b/problems/0925.长按键入.md
@@ -6,7 +6,7 @@
 
 
 # 925.长按键入
-[力扣题目链接](https://leetcode-cn.com/problems/long-pressed-name/)
+[力扣题目链接](https://leetcode.cn/problems/long-pressed-name/)
 
 你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。
 
diff --git a/problems/0941.有效的山脉数组.md b/problems/0941.有效的山脉数组.md
index 4b7a978c..7c98aeea 100644
--- a/problems/0941.有效的山脉数组.md
+++ b/problems/0941.有效的山脉数组.md
@@ -7,7 +7,7 @@
 
 # 941.有效的山脉数组
 
-[力扣题目链接](https://leetcode-cn.com/problems/valid-mountain-array/)
+[力扣题目链接](https://leetcode.cn/problems/valid-mountain-array/)
 
 给定一个整数数组 arr，如果它是有效的山脉数组就返回 true，否则返回 false。
 
diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md
index 9a510a1b..0aa04a02 100644
--- a/problems/0968.监控二叉树.md
+++ b/problems/0968.监控二叉树.md
@@ -7,7 +7,7 @@
 
 # 968.监控二叉树
 
-[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-cameras/)
+[力扣题目链接](https://leetcode.cn/problems/binary-tree-cameras/)
 
 给定一个二叉树，我们在树的节点上安装摄像头。
 
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 20bdf7b0..4052c570 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -8,7 +8,7 @@
 
 # 977.有序数组的平方
 
-[力扣题目链接](https://leetcode-cn.com/problems/squares-of-a-sorted-array/)
+[力扣题目链接](https://leetcode.cn/problems/squares-of-a-sorted-array/)
 
 给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
 
diff --git a/problems/1002.查找常用字符.md b/problems/1002.查找常用字符.md
index 075b5ef1..6f54c098 100644
--- a/problems/1002.查找常用字符.md
+++ b/problems/1002.查找常用字符.md
@@ -8,7 +8,7 @@
 
 # 1002. 查找常用字符
 
-[力扣题目链接](https://leetcode-cn.com/problems/find-common-characters/)
+[力扣题目链接](https://leetcode.cn/problems/find-common-characters/)
 
 给你一个字符串数组 words ，请你找出所有在 words 的每个字符串中都出现的共用字符（ 包括重复字符），并以数组形式返回。你可以按 任意顺序 返回答案。
 
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 202534da..8e161594 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@@ -7,7 +7,7 @@
 
 # 1005.K次取反后最大化的数组和
 
-[力扣题目链接](https://leetcode-cn.com/problems/maximize-sum-of-array-after-k-negations/)
+[力扣题目链接](https://leetcode.cn/problems/maximize-sum-of-array-after-k-negations/)
 
 给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）
 
diff --git a/problems/1035.不相交的线.md b/problems/1035.不相交的线.md
index 4463c5f7..83ccb08c 100644
--- a/problems/1035.不相交的线.md
+++ b/problems/1035.不相交的线.md
@@ -6,7 +6,7 @@
 
 ## 1035.不相交的线
 
-[力扣题目链接](https://leetcode-cn.com/problems/uncrossed-lines/)
+[力扣题目链接](https://leetcode.cn/problems/uncrossed-lines/)
 
 我们在两条独立的水平线上按给定的顺序写下 A 和 B 中的整数。
 
diff --git a/problems/1047.删除字符串中的所有相邻重复项.md b/problems/1047.删除字符串中的所有相邻重复项.md
index a92a3911..7d160172 100644
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@@ -11,7 +11,7 @@
 
 # 1047. 删除字符串中的所有相邻重复项
 
-[力扣题目链接](https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/)
+[力扣题目链接](https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/)
 
 给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
 
diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md
index 3d256c3d..c0cd6d59 100644
--- a/problems/1049.最后一块石头的重量II.md
+++ b/problems/1049.最后一块石头的重量II.md
@@ -7,7 +7,7 @@
 
 ## 1049. 最后一块石头的重量 II
 
-[力扣题目链接](https://leetcode-cn.com/problems/last-stone-weight-ii/)
+[力扣题目链接](https://leetcode.cn/problems/last-stone-weight-ii/)
 
 题目难度：中等
 
diff --git a/problems/1143.最长公共子序列.md b/problems/1143.最长公共子序列.md
index d58330ec..ad9825b8 100644
--- a/problems/1143.最长公共子序列.md
+++ b/problems/1143.最长公共子序列.md
@@ -6,7 +6,7 @@
 
 ## 1143.最长公共子序列
 
-[力扣题目链接](https://leetcode-cn.com/problems/longest-common-subsequence/)
+[力扣题目链接](https://leetcode.cn/problems/longest-common-subsequence/)
 
 给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
 
diff --git a/problems/1207.独一无二的出现次数.md b/problems/1207.独一无二的出现次数.md
index ba92552a..e88f909c 100644
--- a/problems/1207.独一无二的出现次数.md
+++ b/problems/1207.独一无二的出现次数.md
@@ -6,7 +6,7 @@
 
 # 1207.独一无二的出现次数
 
-[力扣题目链接](https://leetcode-cn.com/problems/unique-number-of-occurrences/)
+[力扣题目链接](https://leetcode.cn/problems/unique-number-of-occurrences/)
 
 给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
 
diff --git a/problems/1221.分割平衡字符串.md b/problems/1221.分割平衡字符串.md
index 1a9b34a2..08d4fee7 100644
--- a/problems/1221.分割平衡字符串.md
+++ b/problems/1221.分割平衡字符串.md
@@ -6,7 +6,7 @@
 
 # 1221. 分割平衡字符串 
 
-[力扣题目链接](https://leetcode-cn.com/problems/split-a-string-in-balanced-strings/)
+[力扣题目链接](https://leetcode.cn/problems/split-a-string-in-balanced-strings/)
 
 在一个 平衡字符串 中，'L' 和 'R' 字符的数量是相同的。
 
diff --git a/problems/1356.根据数字二进制下1的数目排序.md b/problems/1356.根据数字二进制下1的数目排序.md
index 838c3a96..5ca73607 100644
--- a/problems/1356.根据数字二进制下1的数目排序.md
+++ b/problems/1356.根据数字二进制下1的数目排序.md
@@ -8,9 +8,9 @@
 
 # 1356. 根据数字二进制下 1 的数目排序
 
-[力扣题目链接](https://leetcode-cn.com/problems/sort-integers-by-the-number-of-1-bits/)
+[力扣题目链接](https://leetcode.cn/problems/sort-integers-by-the-number-of-1-bits/)
 
-题目链接：https://leetcode-cn.com/problems/sort-integers-by-the-number-of-1-bits/
+题目链接：https://leetcode.cn/problems/sort-integers-by-the-number-of-1-bits/
 
 给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。
 
diff --git a/problems/1365.有多少小于当前数字的数字.md b/problems/1365.有多少小于当前数字的数字.md
index 78fa84c0..1d1f86b4 100644
--- a/problems/1365.有多少小于当前数字的数字.md
+++ b/problems/1365.有多少小于当前数字的数字.md
@@ -8,7 +8,7 @@
 
 # 1365.有多少小于当前数字的数字
 
-[力扣题目链接](https://leetcode-cn.com/problems/how-many-numbers-are-smaller-than-the-current-number/)
+[力扣题目链接](https://leetcode.cn/problems/how-many-numbers-are-smaller-than-the-current-number/)
 
 给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
 
diff --git a/problems/1382.将二叉搜索树变平衡.md b/problems/1382.将二叉搜索树变平衡.md
index 57231ec4..d944ac30 100644
--- a/problems/1382.将二叉搜索树变平衡.md
+++ b/problems/1382.将二叉搜索树变平衡.md
@@ -7,7 +7,7 @@
 
 # 1382.将二叉搜索树变平衡
 
-[力扣题目链接](https://leetcode-cn.com/problems/balance-a-binary-search-tree/)
+[力扣题目链接](https://leetcode.cn/problems/balance-a-binary-search-tree/)
 
 给你一棵二叉搜索树，请你返回一棵 平衡后 的二叉搜索树，新生成的树应该与原来的树有着相同的节点值。
 
diff --git a/problems/二叉树的迭代遍历.md b/problems/二叉树的迭代遍历.md
index fac30f99..dc8e812c 100644
--- a/problems/二叉树的迭代遍历.md
+++ b/problems/二叉树的迭代遍历.md
@@ -11,9 +11,9 @@
 
 看完本篇大家可以使用迭代法，再重新解决如下三道leetcode上的题目：
 
-* [144.二叉树的前序遍历](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/)
-* [94.二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
-* [145.二叉树的后序遍历](https://leetcode-cn.com/problems/binary-tree-postorder-traversal/)
+* [144.二叉树的前序遍历](https://leetcode.cn/problems/binary-tree-preorder-traversal/)
+* [94.二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal/)
+* [145.二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal/)
 
 为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？
 
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 29c0cfda..1cce2a0d 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -99,9 +99,9 @@ void traversal(TreeNode* cur, vector<int>& vec) {
 
 此时大家可以做一做leetcode上三道题目，分别是：
 
-* [144.二叉树的前序遍历](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/)
-* [145.二叉树的后序遍历](https://leetcode-cn.com/problems/binary-tree-postorder-traversal/)
-* [94.二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
+* [144.二叉树的前序遍历](https://leetcode.cn/problems/binary-tree-preorder-traversal/)
+* [145.二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal/)
+* [94.二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal/)
 
 可能有同学感觉前后中序遍历的递归太简单了，要打迭代法（非递归），别急，我们明天打迭代法，打个通透！
 
diff --git a/problems/剑指Offer05.替换空格.md b/problems/剑指Offer05.替换空格.md
index eecd7f0c..a4a8c777 100644
--- a/problems/剑指Offer05.替换空格.md
+++ b/problems/剑指Offer05.替换空格.md
@@ -7,7 +7,7 @@
 
 # 题目：剑指Offer 05.替换空格
 
-[力扣题目链接](https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof/)
+[力扣题目链接](https://leetcode.cn/problems/ti-huan-kong-ge-lcof/)
 
 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
 
diff --git a/problems/剑指Offer58-II.左旋转字符串.md b/problems/剑指Offer58-II.左旋转字符串.md
index 7c39ed69..4674c141 100644
--- a/problems/剑指Offer58-II.左旋转字符串.md
+++ b/problems/剑指Offer58-II.左旋转字符串.md
@@ -9,7 +9,7 @@
 
 # 题目：剑指Offer58-II.左旋转字符串
 
-[力扣题目链接](https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/)
+[力扣题目链接](https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/)
 
 字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
 
diff --git a/problems/面试题02.07.链表相交.md b/problems/面试题02.07.链表相交.md
index 0a38cc33..1ae01061 100644
--- a/problems/面试题02.07.链表相交.md
+++ b/problems/面试题02.07.链表相交.md
@@ -7,7 +7,7 @@
 
 # 面试题 02.07. 链表相交
 
-[力扣题目链接](https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/)
+[力扣题目链接](https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/)
 
 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。