Update 01.Divide-And-Conquer-Algorithm.md

Author: itcharge

Contents/09.Algorithm-Base/03.Divide-And-Conquer-Algorithm/01.Divide-And-Conquer-Algorithm.md

@@ -6,7 +6,7 @@
 
 简单来说，分治算法的基本思想就是： **把规模大的问题不断分解为子问题，使得问题规模减小到可以直接求解为止。**
 
-![](https://qcdn.itcharge.cn/images/20220413153059.png)
+![分治算法的基本思想](https://qcdn.itcharge.cn/images/20220413153059.png)
 
 ### 1.2 分治算法和递归算法的异同
 
@@ -16,7 +16,7 @@
 
 分治算法从实现方式上来划分，可以分为两种：「递归算法」和「迭代算法」。
 
-![](https://qcdn.itcharge.cn/images/20220414093828.png)
+![分治算法的实现方式](https://qcdn.itcharge.cn/images/20240513162133.png)
 
 一般情况下，分治算法比较适合使用递归算法来实现。但除了递归算法之外，分治算法还可以通过迭代算法来实现。比较常见的例子有：快速傅里叶变换算法、二分查找算法、非递归实现的归并排序算法等等。
 
@@ -68,7 +68,7 @@ def divide_and_conquer(problems_n):             # problems_n 为问题规模
 
 一般来讲，分治算法将一个问题划分为 $a$ 个形式相同的子问题，每个子问题的规模为 $n/b$，则总的时间复杂度的递归表达式可以表示为：
 
-$T(n) = \begin{cases} \begin{array} \ \Theta{(1)} & n = 1 \cr a \times T(n/b) + f(n) & n > 1 \end{array} \end{cases}$
+$T(n) = \begin{cases} \Theta{(1)} & n = 1 \cr a \times T(n/b) + f(n) & n > 1 \end{cases}$
 
 其中，每次分解时产生的子问题个数是 $a$ ，每个子问题的规模是原问题规模的 $1 / b$，分解和合并 $a$ 个子问题的时间复杂度是 $f(n)$。
 
@@ -82,15 +82,15 @@ $T(n) = \begin{cases} \begin{array} \ \Theta{(1)} & n = 1 \cr a \times T(n/b) +
 
 我们得出归并排序算法的递归表达式如下：
 
-$T(n) = \begin{cases} \begin{array} \ O{(1)} & n = 1 \cr 2 \times T(n/2) + O(n) & n > 1 \end{array} \end{cases}$
+$T(n) = \begin{cases} O{(1)} & n = 1 \cr 2 \times T(n/2) + O(n) & n > 1 \end{cases}$
 
 根据归并排序的递归表达式，当 $n > 1$ 时，可以递推求解：
 
-$\begin{align} T(n) & =   2 \times T(n/2) + O(n) \cr & = 2 \times (2 \times T(n / 4) + O(n/2)) + O(n) \cr & = 4 \times T(n/4) + 2 \times O(n) \cr & = 8 \times T(n/8) + 3 \times O(n) \cr & = …… \cr & = 2^x \times T(n/2^x) + x \times O(n) \end{align}$
+$$\begin{aligned} T(n) & =   2 \times T(n/2) + O(n) \cr & = 2 \times (2 \times T(n / 4) + O(n/2)) + O(n) \cr & = 4 \times T(n/4) + 2 \times O(n) \cr & = 8 \times T(n/8) + 3 \times O(n) \cr & = …… \cr & = 2^x \times T(n/2^x) + x \times O(n) \end{aligned}$$
 
 递推最终规模为 $1$，令 $n = 2^x$，则 $x = \log_2n$，则：
 
-$\begin{align} T(n) & = n \times T(1) + \log_2n \times O(n) \cr & = n + \log_2n \times O(n) \cr & = O(n \times \log_2n) \end{align}$
+$$\begin{aligned} T(n) & = n \times T(1) + \log_2n \times O(n) \cr & = n + \log_2n \times O(n) \cr & = O(n \times \log_2n) \end{aligned}$$
 
 则归并排序的时间复杂度为 $O(n \times \log_2n)$。
 
@@ -106,13 +106,13 @@ $\text{时间复杂度} = \text{叶子数} \times T(1) + \text{成本和} = 2^x
 
 归并排序算法的递归表达式如下：
 
-$T(n) = \begin{cases} \begin{array} \ O{(1)} & n = 1 \cr 2T(n/2) + O(n) & n > 1 \end{array} \end{cases}$
+$T(n) = \begin{cases} O{(1)} & n = 1 \cr 2T(n/2) + O(n) & n > 1 \end{cases}$
 
 其对应的递归树如下图所示。
 
-![](https://qcdn.itcharge.cn/images/20220414171458.png)
+![归并排序算法的递归树](https://qcdn.itcharge.cn/images/20220414171458.png)
 
-因为 $n = 2^x$，则 $x = \log_2n$，则归并排序算法的时间复杂度为：$2^x \times T(1) + x \times O(n) = n + \log_2n \times O(n) = O(n \times log_2n)$。
+因为 $n = 2^x$，则 $x = \log_2n$，则归并排序算法的时间复杂度为：$2^x \times T(1) + x \times O(n) = n + \log_2n \times O(n) = O(n \times \log_2n)$。
 
 ## 4. 分治算法的应用
 
@@ -150,7 +150,7 @@ $T(n) = \begin{cases} \begin{array} \ O{(1)} & n = 1 \cr 2T(n/2) + O(n) & n > 1
 
 使用归并排序算法对数组排序的过程如下图所示。
 
-![](https://qcdn.itcharge.cn/images/20220414204405.png)
+![归并排序算法对数组排序的过程](https://qcdn.itcharge.cn/images/20220414204405.png)
 
 #### 4.1.4 代码
 
@@ -221,7 +221,7 @@ class Solution:
 
 二分查找的的分治算法过程如下图所示。
 
-![](https://qcdn.itcharge.cn/images/20211223115032.png)
+![二分查找的的分治算法过程](https://qcdn.itcharge.cn/images/20211223115032.png)
 
 #### 4.2.4 代码