分治思想
并不仅仅是一种算法,更是一种设计算法的思想
基本思想
- Divide :把问题分解
- Conquer :递归的解决每一个分解出来的问题
- Merge :合并解决的问题
学而不思则罔
分析几种使用分治思想的算法,希望从中学到如何去拆解问题,治理问题
归并排序
分治思想分析
-
分解:将待排序数组一分为二
降低问题规模,比如我们要从排序
n
个数,我们可以把这个问题分解成两个问题(即排序n/2
个数),此时我们的问题规模直接降低了一半,我们还可以递归的将问题继续分解,问题规模会变成n/4
…n/8
… -
治理问题:递归的对每个子数组进行排序
这一步是会递归的执行(1,2,3步骤),因为我们要把问题分割的尽可能小,小到哪种程度呢,当然是只有一个数的情况,那样就不用排序了,因为只有一个数
-
合并问题:很明显合并已经排序好的两个数组,可以在线性时间内完成,这里是 O ( n ) O(n) O(n)
我们解决了分解之后的问题,这时候需要按照一定的规则把分解之后的问题,组合起来,这里就是把已经排序好的数合并起来
时间复杂度
-
递归表达式
T ( N ) = 2 T ( N 2 ) + N T(N) = 2T(\frac{N}{2}) + N T(N)=2T(2N)+N
其中, n n n表示问题规模, T ( N ) T(N) T(N)表示解决问题 n n n需要的时间, 2 T ( N / 2 ) 2T(N/2) 2T(N/2)表示需要把一个规模为 N N N的问题分解成
两个
N / 2 N/2 N/2规模的问题,最后的 N N N是指额外的工作,这里指的是合并子问题需要花费的时间 -
可视化的方法搞清楚时间复杂度
- 首先,我们把
N
递归分解,能分解多少次?(分解是没有复杂度的,因为分解并没有实际的计算) - 其次,我们需要计算多少次
观察上图,可知最多会有 l o g n log^n logn层,每层需要 n n n次计算(这里的计算,是把排序好的数据,合并到一起)
- 数学方法搞清楚时间复杂度
首先根据递归式我们可以得到下面的等式 :
{ T ( 1 ) = 1 T ( N ) = 2 T ( N / 2 ) + N \begin{cases} T(1) = 1 \\ T(N) = 2T(N/2) + N \end{cases} {T(1)=1T(N)=2T(N/2)+N
我们让等号两边除以 N N N得到:
T ( N ) N = T ( N / 2 ) N / 2 + 1 \frac{T(N)}{N} = \frac{T(N/2)}{N/2} + 1 NT(N)=N/2T(N/2)+1
T ( N / 2 ) N / 2 = T ( N / 4 ) N / 4 + 1 \frac{T(N/2)}{N/2} = \frac{T(N/4)}{N/4} + 1 N/2T(N/2)=N/4T(N/4)+1
T
(
N
/
4
)
N
/
4
=
T
(
N
/
8
)
N
/
8
+
1
\frac{T(N/4)}{N/4} = \frac{T(N/8)}{N/8} + 1
N/4T(N/4)=N/8T(N/8)+1
…
T
(
2
)
2
=
T
(
1
)
1
+
1
\frac{T(2)}{2} = \frac{T(1)}{1} + 1
2T(2)=1T(1)+1
将所有这些方程相加得到:
T ( N ) N = T ( 1 ) 1 + l o g N \frac{T(N)}{N} = \frac{T(1)}{1} + logN NT(N)=1T(1)+logN
所以就有:
T ( N ) = N + N ∗ l o g N T(N)= N + N * logN T(N)=N+N∗logN
当然,也有很多其它排序方法都能达到这个速度,甚至一些情况下,有 O ( n ) O(n) O(n)复杂度的排序算法,但是归并排序,相对来说比较稳定,通用
二分查找
分治思想分析
有序的数 [ n 1 , n 2 , n 3 . . . . n i ] [n_1, n_2, n_3....n_i] [n1,n2,n3....ni]中查找目标数 x x x
查找目标数: x x x
- 分解: x x x 和 中间数比较
- 治理:如果 x x x和中间数不同,那么就根据大小关系,让子数组进行递归(这里会根据条件,递归执行1,2,3步骤)
- 合并:这里不需要额外计算,因为找到这个数(或者证明这个数不存在)就可以了
时间复杂度
T ( n ) = T ( n / 2 ) + θ ( 1 ) T(n) = T(n/2) + \theta(1) T(n)=T(n/2)+θ(1)
计算 n m n^m nm
分治思想分析
-
分解:将计算 n m n^m nm 分解为计算 n m / 2 n^{m/2} nm/2
这里假设m
是偶数,如果m
是奇数,只需要先设置 m = m − 1 m = m -1 m=m−1,算法执行结束后乘以 n n n,问题规模同样降低了一半 -
治理:递归的将问题分解,最终最小的问题将是 n 1 n^1 n1
-
合并:将得到的结果自身相乘
这里的操作就是将两个数相乘,所以这里的时间复杂度为 θ ( 1 ) \theta(1) θ(1)
时间复杂度
T ( n ) = T ( n / 2 ) + θ ( 1 ) T(n) = T(n/2) + \theta(1) T(n)=T(n/2)+θ(1)