Master公式:
Master公式主要是用来推导递归算法的时间复杂度。
公式:
T
(
N
)
=
a
∗
T
(
N
/
b
)
+
T
(
N
d
)
T(N) = a * T(N/b) + T(N^d)
T(N)=a∗T(N/b)+T(Nd) 其中:a、b、d为常数
当
l
o
g
b
a
<
d
log b^a <d
logba<d 时。复杂度为
O
(
N
d
)
O(N^d)
O(Nd)
当
l
o
g
b
a
>
d
log b^a >d
logba>d 时。复杂度为O(Nlog
b
a
b^a
ba)
当
l
o
g
b
a
=
d
log b^a =d
logba=d 时。复杂度为
O
(
N
d
∗
l
o
g
N
)
O(N^d * logN)
O(Nd∗logN)
需要注意的是:该公式只针对递归中子问题规模相同的才有效。
举例:
用递归求数组中最大的数。先求最左侧最大值,再求最右侧最大值,再从最左侧最大值和最右侧最大值中取最大值。
public static int getMax(int[] arr) {
return process(arr, 0, arr.length - 1);
}
public static int process(int[] arr, int L, int R) {
//L = R,说明只有一个数,直接返回
if (L == R) {
return arr[L];
}
// L + ((R - L) >> 1) --> (L + R) / 2 防止数组下标越界
int mid = L + ((R - L) >> 1);
//递归,求最左侧最大值和最右侧最大值
int leftMax = process(arr, L, mid);
int rightMax = process(arr, mid + 1, R);
return Math.max(leftMax, rightMax);
}
分析
不用将递归整体拆开,单独看一次调用而后将值带入公式即可。
上面代码中,整体数据样本量为N(T(N)), 将数组拆成左右两个子过程进行查找,左右两侧数据量分别就是 N/2( T(N/2) )-> b = 2,子过程查找2次 -> a = 2,左右两侧查找出最大值比较,是O(1)的时间复杂度常数操作,公式
T
(
N
d
)
=
O
(
1
)
T(N^d) =O(1)
T(Nd)=O(1),所以d = 0, 带入公式:T(N) = 2 * T(N/2) + O(1)
又因为当
l
o
g
b
a
>
d
log b^a >d
logba>d 时。复杂度为O(Nlog
b
a
b^a
ba)
将a、b的值带入可得,该递归算法的整体时间复杂度为
O
(
N
)
O(N)
O(N)