Data structure with search, insert and delete in amortised time $O(1)$? Is there a data structure to maintain an ordered list that supports the following operations in $O(1)$ amortized time? 


GetElement(k): Return the $k$th element of the list.
InsertAfter(x,y): Insert the new element y into the list immediately after x.  
Delete(x): Remove x from the list.


For the last two operations, you can assume that x is given as a pointer directly into the data structure; InsertElement returns the corresponding pointer for y.  InsertAfter(NULL, y) inserts y at the beginning of the list.

For example, starting with an empty data structure, the following operations update the ordered list as shown below:


InsertAfter(NULL, a) $\implies$ [a]
InsertAfter(NULL, b) $\implies$ [b, a]
InsertAfter(b, c) $\implies$ [b, c, a]
InsertAfter(a, d) $\implies$ [b, c, a, d]
Delete(c) $\implies$ [b, a, d]


After these five updates, GetElement(2) should return d, and GetElement(3) should return an error.
NO.

Fredman and Saks proved that any data structure that supports these operations requires at least $\Omega(\log n/\log\log n)$ amortized time per operation.  (This is reference [1] in the paper by Dietz that you mention in your first comment.)  The lower bound holds in the very powerful cell probe model of computation, which only considers the number of distinct memory addresses accessed by the update and query algorithms.

Without some additional assumptions about the update and query operations, Dietz's data structure is the best possible (at least up to constant factors).