In the 2D point searching problem, the goal is to preprocess n points P = {p1,..., pn} in the plane so that, for an online sequence of query points q1,..., qm, it can quickly determined which (if any) of the elements of P are equal to each query point qi. This problem can be solved in O(log n) time by mapping the problem to one dimension. We present a data structure that is optimized for answering queries quickly when they are geometrically close to the previous successful query. Specifically, our data structure executes queries in time O(log d(qi−1, qi)), where d is some distance function between two points, and uses O(n log n) space. Our structure works with a variety of distance functions. In contrast, it is proved that, for some of the most intuitive distance functions d, it is impossible to obtain an O(log d(qi−1, qi)) runtime, or any bound that is o(log n).

We present a new priority queue data structure, the queap, that executes insertion in O(1) amortized time and extract-min in O(log(k + 2)) amortized time if there are k items that have been in the heap longer than the item to be extracted. Thus if the operations on the queap are rst-in rst-out, as on a queue, each operation will execute in constant time. This idea of trying to make operations on the least recently accessed items fast, which we call the queueish property, is a natural complement to the working set property of certain data structures, such as splay trees and pairing heaps, where operations on the most recently accessed data execute quickly. However, we show that the queueish property is in some sense more dicult than the working set property by demonstrating that it is impossible to create a queueish binary search tree, but that many search data structures can be made almost queueish with a O(log log n) amortized extra cost per operation.