Output-sensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an on-line query in O(t(n) + l) time, where t(n) is the cost of traversing the structure and l ≤ n is the number of reported items satisfying the query. In this paper we focus on rank-sensitive data structures, which are additionally given a ranking of the n items, so that just the top k best-ranking items should be reported at query time, sorted in rank order, at a cost of O(t(n) + k) time. Note that k is part of the query as a parameter under the control of the user (as opposed to l which is query-dependent). We explore the problem of adding rank-sensitivity to data structures such as suffix trees or range trees, where the l items satisfying the query form O(polylog(n)) intervals of consecutive entries from which we choose the top k best-ranking ones. Letting s(n) be the number of items (including their copies) stored in the original data structures, we increase the space by an additional term of O(s(n) lgen) memory words of space, each of O(lg n) bits, for any positive constant e < 1. We allow for changing the ranking on the fly during the lifetime of the data structures, with ranking values in 0 ... O(n). In this case, query time becomes O(t(n) + k) plus O(lg n/ lg lg n) per interval; each change in the ranking and each insertion/deletion of an item takes O(lg n); the additional term in space occupancy increases to O(s(n) lg n/ lg lg n).