Search data structure

In computer science, a search data structure is any data structure that allows the efficient retrieval of specific items from a set of items, such as a specific record from a database.

The simplest, most general, and least efficient search structure is merely an unordered sequential list of all the items. Locating the desired item in such a list, by the linear search method, inevitably requires a number of operations proportional to the number n of items, in the worst case as well as in the average case. Useful search data structures allow faster retrieval; however, they are limited to queries of some specific kind. Moreover, since the cost of building such structures is at least proportional to n, they only pay off if several queries are to be performed on the same database (or on a database that changes little between queries).

Static search structures are designed for answering many queries on a fixed database; dynamic structures also allow insertion, deletion, or modification of items between successive queries. In the dynamic case, one must also consider the cost of fixing the search structure to account for the changes in the database.

Classification

The simplest kind of query is to locate a record that has a specific field (the key) equal to a specified value v. Other common kinds of query are "find the item with smallest (or largest) key value", "find the item with largest key value not exceeding v", "find all items with key values between specified bounds v_min and v_max".

In certain databases the key values may be points in some multi-dimensional space. For example, the key may be a geographic position (latitude and longitude) on the Earth. In that case, common kinds of queries are find the record with a key closest to a given point v", or "find all items whose key lies at a given distance from v", or "find all items within a specified region R of the space".

A common special case of the latter are simultaneous range queries on two or more simple keys, such as "find all employee records with salary between 50,000 and 100,000 and hired between 1995 and 2007".

Single ordered keys

• Array if the key values span a moderately compact interval.
• Priority-sorted list; see linear search
• Key-sorted array; see binary search
• Self-balancing binary search tree
• Hash table

Finding the smallest element

• Heap

Asymptotic amortized worst-case analysis

In this table, the asymptotic notation O(f(n)) means "not exceeding some fixed multiple of f(n) in the worst case."

	Insert	Delete	Search	Find maximum	Space usage
Unsorted array	O(1)	O(1)	O(n)	O(n)	O(n)
Value-indexed array	O(1)	O(1)	O(1)	O(n)	O(n)
Sorted array	O(n)	O(n)	O(log n)	O(1)	O(n)
Unsorted linked list	O(1)*	O(1)*	O(n)	O(n)	O(n)
Sorted linked list	O(1)*	O(1)*	O(n)	O(1)	O(n)
Self-balancing binary tree	O(log n)	O(log n)	O(log n)	O(log n)	O(n)
Heap	O(log n)	O(log n)**	O(n)	O(1)	O(n)
Hash table	O(1)	O(1)	O(1)	O(n)	O(n)

 * The cost to add or delete an element into a known location in the list (i.e. if you have an iterator to the location) is O(1). If you don't know the location, then you need to traverse the list to the location of deletion/insertion, which takes O(n) time.  ** The deletion cost is O(log n) for the minimum or maximum, O(n) for an arbitrary element.

This table is only an approximate summary; for each data structure there are special situations and variants that may lead to different costs. Also two or more data structures can be combined to obtain lower costs.

Footnotes

See also

• List of data structures