the aggregate method

The most direct way to find an amortized cost is also the bluntest: just add up the real cost of the entire sequence, then divide by how many operations there were. No clever bookkeeping, no per-operation charges — you bound the grand total directly and split it evenly. This is the aggregate method, and it works whenever you can reason about the sequence as a whole rather than one operation at a time.

The recipe is two steps. First, prove an upper bound T(m) on the total cost of ANY sequence of m operations from the empty state. Second, declare the amortized cost of each operation to be T(m)/m. Because the same number T(m)/m is assigned to every operation type, this method gives a single uniform amortized cost. For the binary counter, incrementing an n-bit counter from 0 through m increments flips bit 0 every time (m flips), bit 1 every other time (about m/2 flips), bit 2 every fourth time, and so on; the total flips are at most m(1 + 1/2 + 1/4 + ...) < 2m. So T(m) < 2m and the amortized cost per increment is 2m/m = 2 = O(1), even though one increment can flip all n bits.

The aggregate method's charm is that it needs no insight about which operations are expensive — you just bound the whole bill. Its limitation is exactly that bluntness: it assigns the SAME amortized cost to every operation, which can be wasteful when different operations deserve different charges (a cheap query versus an expensive insert). When you want to charge operations differently, the accounting or potential methods are more flexible. But when one global sum is easy to compute, aggregate analysis is the quickest route to an honest amortized bound.