Hw 4 Amortized Analysis
1 Dynamic Table
1
初始： Φ 0 = ∣ 2 ⋅ 0 − 0 ∣ = 0 \Phi_0 =|2 \cdot 0-0| = 0 Φ0=∣2⋅0−0∣=0
所以在第
i
i
i 次操作之前有：
∑
j
=
1
i
−
1
C
^
j
=
∑
j
=
1
i
−
1
C
j
+
(
Φ
j
−
Φ
j
−
1
)
=
Φ
i
−
1
−
Φ
0
+
∑
j
=
1
i
−
1
C
j
=
Φ
i
−
1
+
∑
j
=
1
i
−
1
C
j
\begin{aligned} \sum\limits_{j=1}^{i-1} \hat{C}_j &= \sum\limits_{j=1}^{i-1} C_j + (\Phi_j - \Phi_{j-1}) \\&= \Phi_{i-1} - \Phi_0+\sum\limits_{j=1}^{i-1} C_j\\&=\Phi_{i-1}+\sum\limits_{j=1}^{i-1} C_j \end{aligned}
j=1∑i−1C^j=j=1∑i−1Cj+(Φj−Φj−1)=Φi−1−Φ0+j=1∑i−1Cj=Φi−1+j=1∑i−1Cj
对于 ∀ i {\forall}i ∀i，均有 Φ i ≥ 0 \Phi_i \geq 0 Φi≥0，所以有 ∑ j = 1 i C ^ j ≥ ∑ j = 1 i C j \sum\limits_{j=1}^{i} \hat{C}_j \geq \sum\limits_{j=1}^{i} C_j j=1∑iC^j≥j=1∑iCj
对于 TABLE-DELETE 操作，有
n
u
m
i
=
n
u
m
i
−
1
−
1
num_i=num_{i-1}-1
numi=numi−1−1
-
当装载因子 α ≥ 1 2 \alpha\geq\frac{1}{2} α≥21 时， s i z e i = s i z e i − 1 size_i=size_{i-1} sizei=sizei−1
C ^ i = C i + ( 2 ⋅ n u m i − s i z e i ) − ( 2 ⋅ ( n u m i + 1 ) − s i z e i ) = − 1 = O ( 1 ) \begin{aligned}\hat{C}_i&=C_i+(2\cdot num_i-size_i)-(2\cdot (num_i+1)-size_i)\\&=-1\\&=\Omicron(1)\end{aligned} C^i=Ci+(2⋅numi−sizei)−(2⋅(numi+1)−sizei)=−1=O(1) -
当装载因子 α < 1 2 \alpha<\frac{1}{2} α<21 时，
- 若删除操作不引起缩表，
s
i
z
e
i
=
s
i
z
e
i
−
1
size_i=size_{i-1}
sizei=sizei−1
C ^ i = C i + ( − 2 ⋅ n u m i + s i z e i ) − ( − 2 ⋅ ( n u m i + 1 ) + s i z e i ) = 3 = O ( 1 ) \begin{aligned}\hat{C}_i&=C_i+(-2\cdot num_i+size_i)-(-2\cdot (num_i+1)+size_i)\\&=3\\&=\Omicron(1)\end{aligned} C^i=Ci+(−2⋅numi+sizei)−(−2⋅(numi+1)+sizei)=3=O(1) - 若删除操作引起缩表，
s
i
z
e
i
=
2
3
s
i
z
e
i
−
1
size_i=\frac{2}{3}size_{i-1}
sizei=32sizei−1
C ^ i = C i + ( − 2 ⋅ n u m i + s i z e i ) − ( − 2 ⋅ ( n u m i + 1 ) + 3 2 s i z e i ) = 3 + n u m i − 1 2 s i z e i \begin{aligned}\hat{C}_i&=C_i+(-2\cdot num_i+size_i)-(-2\cdot (num_i+1)+\frac{3}{2}size_i)\\&=3+num_i-\frac{1}{2}size_i\end{aligned} C^i=Ci+(−2⋅numi+sizei)−(−2⋅(numi+1)+23sizei)=3+numi−21sizei
因为将表规模变为原来的 2 3 \frac{2}{3} 32，所以 n u m i < 1 3 s i z e i − 1 = 1 2 s i z e i num_i<\frac{1}{3}size_{i-1}=\frac{1}{2}size_i numi<31sizei−1=21sizei，可得：
C ^ i = 3 + n u m i − 1 2 s i z e i < 3 ⇒ C ^ i = O ( 1 ) \begin{aligned}&\hat{C}_i=3+num_i-\frac{1}{2}size_i<3 \\\Rightarrow &\hat{C}_i=\Omicron(1)\end{aligned} ⇒C^i=3+numi−21sizei<3C^i=O(1)
- 若删除操作不引起缩表，
s
i
z
e
i
=
s
i
z
e
i
−
1
size_i=size_{i-1}
sizei=sizei−1
综上所述，对于
∀
i
{\forall}i
∀i，
C
^
i
=
O
(
1
)
\hat{C}_i=\Omicron(1)
C^i=O(1)，所以 TABLE-DELETE 操作的摊还代价的上界为一个常数
2
当负载因子 α ( T ) \alpha(T) α(T) 超过某个阈值，扩展散列表的大小；当负载因子 α ( T ) \alpha(T) α(T) 低于某个阈值，收缩散列表的大小。负载因子的大小对应于散列表中元素的数量与槽位数量的比例，根据负载因子动态调整散列表的大小，可以确保散列表保持合适的大小以提供较低的碰撞率和较高的操作效率。
- 在执行插入操作时，检查负载因子 α ( T ) \alpha(T) α(T) ，若超过一定阈值，执行扩展散列表的操作。再根据散列函数找到要插入的元素应该放置的槽位。
- 在执行删除操作时，删除元素后，更新负载因 α ( T ) \alpha(T) α(T) 的值，若低于某个阈值，执行收缩散列表的操作。
2 Making binary search dynamic
1
SEARCH(x)操作：在
k
k
k 个有序数组中做有序查找。
满数组 A i A_i Ai 查找的时间复杂度为 O ( i ) \Omicron(i) O(i)。
最坏情况：所有数组均满，且 x 不在任意数组中
此时时间复杂度
T
(
n
)
T(n)
T(n) 为：
T
(
n
)
=
∑
i
=
0
k
−
1
c
i
=
c
⋅
⌈
l
g
(
n
+
1
)
⌉
⋅
⌈
l
g
(
n
+
1
)
⌉
−
1
2
=
O
(
l
g
2
n
)
T(n)=\sum\limits_{i=0}^{k-1}c_i=c\cdot\lceil lg(n+1)\rceil\cdot\frac{\lceil lg(n+1)\rceil-1}{2}=\Omicron(lg^2n)
T(n)=i=0∑k−1ci=c⋅⌈lg(n+1)⌉⋅2⌈lg(n+1)⌉−1=O(lg2n)
2
执行 INSERT(x) 时：（二进制数的位为
1
1
1 时，对应数组为满；位为
0
0
0，数组为空）
- 创建一个大小为 1 1 1 的数组 S S S 存放该元素。
- 找到数据结构中大小与
S
S
S 相同的数组
A
l
g
∣
S
∣
A_{lg|S|}
Alg∣S∣。
- 若
A
l
g
∣
S
∣
A_{lg|S|}
Alg∣S∣ 为满，创建一个新数组
S
S
S 有序存放原
S
S
S 和
A
l
g
∣
S
∣
A_{lg|S|}
Alg∣S∣ 中的元素，并返回执行上一个步骤。
该步骤时间复杂度为 O ( ∣ S ∣ ) \Omicron(|S|) O(∣S∣)。 - 若
A
l
g
∣
S
∣
A_{lg|S|}
Alg∣S∣ 为空，则用
S
S
S 替代该数组，此时
INSERT(x)执行完毕。
- 若
A
l
g
∣
S
∣
A_{lg|S|}
Alg∣S∣ 为满，创建一个新数组
S
S
S 有序存放原
S
S
S 和
A
l
g
∣
S
∣
A_{lg|S|}
Alg∣S∣ 中的元素，并返回执行上一个步骤。
- 若不存在与 S S S 大小相同的数组 A l g ∣ S ∣ A_{lg|S|} Alg∣S∣，直接将 S S S 作为 A k A_k Ak 插入。
最坏情况：所有数组均满
此时时间复杂度
T
(
n
)
T(n)
T(n) 为：
T
(
n
)
=
∑
i
=
0
⌈
l
g
(
n
+
1
)
⌉
c
⋅
2
i
=
O
(
2
⌈
l
g
(
n
+
1
)
⌉
+
1
−
1
)
=
O
(
n
)
T(n)=\sum\limits_{i=0}^{\lceil lg(n+1)\rceil}c\cdot2^i=\Omicron(2^{\lceil lg(n+1)\rceil+1}-1)=\Omicron(n)
T(n)=i=0∑⌈lg(n+1)⌉c⋅2i=O(2⌈lg(n+1)⌉+1−1)=O(n)
对于摊还时间，当数组 A i A_i Ai 从空被置为满时，对应的数组 A j A_j Aj 要被置满再置空 2 i − j − 1 2^{i-j-1} 2i−j−1 次。则从 0 0 0 开始不断插入元素，插入总开销小于等于插入 2 ⌈ l g ( n + 1 ) ⌉ + 1 − 1 2^{\lceil lg(n+1)\rceil+1}-1 2⌈lg(n+1)⌉+1−1 个元素的开销。
与数组
A
i
A_i
Ai 相关的开销：
T
(
A
i
)
=
被置为满的单次开销
×
置满的次数
=
2
i
⋅
(
1
+
∑
j
=
1
k
−
1
−
i
2
j
)
=
2
i
⋅
(
2
k
−
i
−
1
)
=
Θ
(
2
k
)
=
Θ
(
n
)
\begin{aligned}T(A_i)&=被置为满的单次开销\times置满的次数\\&=2^i\cdot(1+\sum\limits_{j=1}^{k-1-i}2^j)\\&=2^i\cdot(2^{k-i}-1)\\&=\Theta(2^k)\\&=\Theta(n)\end{aligned}
T(Ai)=被置为满的单次开销×置满的次数=2i⋅(1+j=1∑k−1−i2j)=2i⋅(2k−i−1)=Θ(2k)=Θ(n)
总开销：
T
(
n
)
=
∑
i
=
0
k
−
1
T
(
A
i
)
=
k
⋅
Θ
(
n
)
=
Θ
(
n
l
g
n
)
T(n)=\sum\limits_{i=0}^{k-1}T(A_i)=k\cdot\Theta(n)=\Theta(nlgn)
T(n)=i=0∑k−1T(Ai)=k⋅Θ(n)=Θ(nlgn)
所以，摊还时间为 O ( l g n ) \Omicron(lgn) O(lgn)
3
记状态为满的最小下标数组为
A
i
A_i
Ai，则 DELETE 操作需要变动的数组为：被删除的元素所在的数组
A
m
A_m
Am 和
A
0
,
A
1
,
.
.
.
,
A
i
A_0,A_1,...,A_i
A0,A1,...,Ai。
- 通过
SEARCH(x)操作找到被删除元素。
该步骤时间复杂度为 O ( l g 2 n ) \Omicron(lg^2n) O(lg2n)。 - 将
A
m
A_m
Am 中的删除元素
x替换为 A i A_i Ai 中的一个元素y，并将y从 A i A_i Ai 中删除。 - 将 A i A_i Ai 中的剩下 2 i − 1 2^i-1 2i−1个元素填入 A 0 , A 1 , . . . , A i A_0,A_1,...,A_i A0,A1,...,Ai，置空 A i A_i Ai。
最坏情况下的总时间复杂度为：
T
(
n
)
=
Θ
(
l
g
2
n
)
+
2
k
−
1
=
Θ
(
n
)
T(n)=\Theta(lg^2n)+2^k-1=\Theta(n)
T(n)=Θ(lg2n)+2k−1=Θ(n)
摊还代价为： Θ ( n 2 ) \Theta(n^2) Θ(n2)
351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
