平摊分析

計算n個操作的時間複雜度上限T(n) 平攤T(n)至每一個操作，每一個操作的平攤成本是T(n)/n

執行花費較低的operations時先存credit未雨綢繆, 供未來花費較高的operations使用

對每個操作定義一個合法的平攤成本(amortized cost) 假設${\displaystyle c_{i}}$為第i個操作的actual cost，${\displaystyle {\hat {c_{i}}}}$為第i個操作的amortized cost

若${\displaystyle c_{i}<{\hat {c_{i}}}}$，則credit=${\displaystyle {\hat {c_{i}}}-c_{i}}$，我們把credit存起來(deposited)，未來可以提取(withdraw) 若${\displaystyle c_{i}>{\hat {c_{i}}}}$，則提取credit

設定每個操作的平攤成本(amortized cost)後，要做valid check確保credit不可以是0，也就是說 ${\displaystyle \sum _{k=1}^{n}{\hat {c_{i}}}\geq \sum _{k=1}^{n}c_{i}}$

定義一個位能函數(potential function)${\displaystyle \Phi (D)}$，將資料結構D(例如: 堆疊)的狀態對應到一個實數

${\displaystyle D_{0}}$: 資料結構D的初始狀態

${\displaystyle D_{i}}$: 資料結構D經過${\displaystyle i}$個操作後的狀態

${\displaystyle c_{i}}$: 第${\displaystyle i}$個操作的actual cost

${\displaystyle {\hat {c_{i}}}}$: 第${\displaystyle i}$個操作的amortized cost

定義${\displaystyle {\hat {c_{i}}}=c_{i}+\Phi (D_{i})-\Phi (D_{i-1})}$

${\displaystyle \sum _{k=1}^{n}{\hat {c_{i}}}=\sum _{k=1}^{n}(c_{i}+\Phi (D_{i})-\Phi (D_{i-1}))=(\sum _{k=1}^{n}c_{i})+\Phi (D_{n})-\Phi (D_{0})}$

為了滿足${\displaystyle \sum _{k=1}^{n}{\hat {c_{i}}}\geq \sum _{k=1}^{n}c_{i}}$

我們定義${\displaystyle \Phi (D_{n})-\Phi (D_{0})\geq 0}$ , 通常令${\displaystyle \Phi (D_{0})=0}$ 和 ${\displaystyle \Phi (D_{n})\geq 0}$

我們定義一個堆疊有下列操作

操作(operation)	說明	actual cost
S.push(x)	將一個元素x放入堆疊S中	${\displaystyle O(1)}$
S.pop()	把堆疊S中最上面的元素取出	${\displaystyle O(1)}$
S.multi-pop(k)	一次pop k個元素	${\displaystyle O(\min(\left\vert S\right\vert ,k))}$

S.mult-pop(k)的程式碼如下

def multi_pop(k):
	while (not S.empty()) and (k>0):
		S.pop()
		k -= 1

接下來我們分別使用聚集法(aggregate method), 記帳法(Accounting method), 位能法(Potential method)求出"堆疊一個操作的平攤成本是O(1)"

令${\displaystyle n_{push}}$是S.push(x)的執行次數，${\displaystyle n_{pop}}$是S.pop()的執行次數，${\displaystyle n_{multi-pop}}$是S.multi-pop(k)的執行次數

${\displaystyle n=n_{push}+n_{pop}+n_{multi-pop}}$為總執行次數

操作(operation)	actual cost	執行次數
S.push(x)	${\displaystyle O(1)}$	${\displaystyle n_{push}}$
S.pop()	${\displaystyle O(1)}$	${\displaystyle n_{pop}}$
S.multi-pop(k)	${\displaystyle O(\min(\left\vert S\right\vert ,k))}$	${\displaystyle n_{multi-pop}}$

因為一個堆疊S如果是空的，就不能執行pop了，也就是說可以pop或multi-pop的元素個數不會超過S中push進去的元素個數

所以${\displaystyle n_{pop}+n_{multi-pop}\leq n_{push}}$

假設${\displaystyle T(n)}$是執行${\displaystyle n}$個操作的時間複雜度上限

${\displaystyle T(n)=O(1)\times n_{push}+O(1)\times n_{push}=O(n)}$

所以堆疊一個操作的平攤成本為${\displaystyle O(n)/n=O(1)}$

我們假設S.push(x), S.pop(), S.multi-pop(k)的amortized cost分別為2, 0, 0，如下表所示

操作(operation)	actual cost ${\displaystyle c_{i}}$	amortized cost ${\displaystyle {\hat {c_{i}}}}$
S.push(x)	1	2
S.pop()	1	0
S.multi-pop(k)	${\displaystyle O(\min(\left\vert S\right\vert ,k))}$	0

Valid Check 證明: ${\displaystyle \sum _{k=1}^{n}{\hat {c_{i}}}\geq \sum _{k=1}^{n}c_{i}}$
${\displaystyle {\color {Red}proof:}}$ push進入堆疊S的元素會存入credit $1 pop(S), multi-pop(S, k) 會取出這些元素的credit $1

因此每個操作的平攤成本是O(1)

我們定義位能函數${\displaystyle \Phi (D)}$為執行i個操作後，堆疊內的元素個數

${\displaystyle \Phi (D_{0})=0}$ ，因為堆疊一開始是空的

${\displaystyle \Phi (D_{i})\geq 0}$ ，因為堆疊的元素個數一定${\displaystyle \geq 0}$

計算堆疊S每一個操作的平攤成本

操作(operation)	平攤成本(amortized cost) ${\displaystyle {\hat {c_{i}}}}$
S.push(x)	${\displaystyle {\hat {c_{i}}}=c_{i}+\Phi (D_{i})-\Phi (D_{i-1})=1+(\left\vert S\right\vert +1)-\left\vert S\right\vert =2}$
S.pop()	${\displaystyle {\hat {c_{i}}}=c_{i}+\Phi (D_{i})-\Phi (D_{i-1})=1+(\left\vert S-1\right\vert )-\left\vert S\right\vert =0}$
S.multi-pop(k)	${\displaystyle {\hat {c_{i}}}=c_{i}+\Phi (D_{i})-\Phi (D_{i-1})=k+(\left\vert S-k\right\vert )-\left\vert S\right\vert =k-k=0}$

總平攤成本 ${\displaystyle \sum _{k=1}^{n}{\hat {c_{i}}}=2\times n_{push}=O(n)}$，所以堆疊單一個操作的平攤成本是${\displaystyle O(n)/n=O(1)}$

动态数组的平摊分析

考虑一个随元素个数增加而增长的动态数组，比如Java的ArrayList或者C++的std::vector。如果我们的数组大小从4开始，那么来向其中增加四个元素的时间就是一个常数。然而，若要将第五个元素加入其中，那么会花费更多时间，因为我们此时必须要创建一个两倍于当前数组大小的数组（8个元素），把老元素拷贝到新数组中，然后增加一个新元素。接下来的三次加入操作也同样会花费常数时间，然后在数组被填满后则又需要一轮新的加倍扩充。

一般地，如果我们考虑任意一个任意的n大小的数组并对其进行n + 1次加入操作。我们注意到，所有的加入操作都是常数时间的，除了最后一个，它会花费${\displaystyle O(n)}$时间在大小加倍上。因为我们进行了n + 1次加入操作，我们可以将数组加倍的时间平摊到所有的加入操作上，因此得到加入操作的平均时间是${\displaystyle {\tfrac {nO(1)+O(n)}{n+1}}=O(1)}$。它是一个常数。[1]

使用Ruby實現的佇列，一个先進先出資料結構:

class Queue
  def initialize
    @input = []
    @output = []
  end

  def enqueue(element)
    @input << element
  end

  def dequeue
    if @output.empty?
      while @input.any?
        @output << @input.pop
      end
    end

    @output.pop
  end
end

佇列操作及特性參考佇列條目，enqeue及deqeue操作時間複雜度為常數， 否則，dequeue需要${\displaystyle O(n)}$時間將所有元素從輸入數組添加到輸出數組中，其中n是輸入數組的當前長度。 從輸入複製n元素後，我們可以在輸出數組再次為空之前執行n出隊操作，每次操作都需要一個恆定的時間。 因此，我們可以僅在${\displaystyle o(n)}$時間執行一系列n出列操作，這意味著每個出列操作的攤銷時間是${\displaystyle O(1)}$ 。[2]

或者，我們可以收取將任何項目從輸入數組複製到輸出數組的成本，以及該項目的早期排隊操作。 該計費方案將入隊的攤還時間加倍，但將出列的攤還時間減少到${\displaystyle O(1)}$。