## Accounting method in data structure

### Accounting (Banker’s) Method

Here we explain about accounting method in data structure which is coming under Amortized Analysis .The aggregate method directly seeks a bound on the overall running time of a sequence of operations. In contrast, the accounting method seeks to find a *payment* of a number of extra time units charged to each individual operation such that the sum of the payments is an upper bound on the total actual cost. Intuitively, one can think of maintaining a bank account. Low-cost operations are charged a little bit more than their true cost, and the surplus is deposited into the bank account for later use. High-cost operations can then be charged less than their true cost, and the deficit is paid for by the savings in the bank account. In that way we spread the cost of high-cost operations over the entire sequence. The charges to each operation must be set large enough that the balance in the bank account always remains positive, but small enough that no one operation is charged significantly more than its actual cost.

We emphasize that the extra time charged to an operation does not mean that the operation really takes that much time. It is just a method of accounting that makes the analysis easier.

If we let *c’ _{i}* be the charge for the

*i*-th operation and

*c*be the true cost, then we would like

_{i}Σ* _{1≤i≤n} c_{i}* ≤ Σ

_{1≤i≤n}c’_{i}for all *n*, which says that the amortized time Σ* _{1≤i≤n} c’_{i}* for that sequence of

*n*operations is a bound on the true time Σ

*.*

_{1≤i≤n}c_{i}Back to the example of the extensible array. Say it costs 1 unit to insert an element and 1 unit to move it when the table is doubled. Clearly a charge of 1 unit per insertion is not enough, because there is nothing left over to pay for the moving. A charge of 2 units per insertion again is not enough, but a charge of 3 appears to be:

i1 2 3 4 5 6 7 8 9 10s1 2 4 4 8 8 8 8 16 16_{i}c1 2 3 1 5 1 1 1 9 1_{i}c'3 3 3 3 3 3 3 3 3 3_{i}b2 3 3 5 3 5 7 9 3 4_{i}

where *b _{i}* is the balance after the

*i*-th insertion.

In fact, this is enough in general. Let *m* refer to the *m*-th element inserted. The three units charged to *m* are spent as follows:

- One unit is used to insert
*m*immediately into the table. - One unit is used to move
*m*the first time the table is grown after*m*is inserted. - One unit is donated to element
*m − 2*, where^{k}*2*is the largest power of 2 not exceeding^{k}*m*, and is used to move that element the first time the table is grown after*m*is inserted.

Now whenever an element is moved, the move is already paid for. The first time an element is moved, it is paid for by one of its own time units that was charged to it when it was inserted; and all subsequent moves are paid for by donations from elements inserted later.

In fact, we can do slightly better, by charging just 1 for the first insertion and then 3 for each insertion after that, because for the first insertion there are no elements to copy. This will yield a zero balance after the first insertion and then a positive one thereafter.