Abstract data type

In computing, an abstract data type (ADT) is a specification of a set of data and the set of operations that can be performed on the data. Such a data type is abstract in the sense that it is independent of various concrete implementations. The definition can be mathematical, or it can be programmed as an interface. A first class ADT supports the creation of multiple instances of the ADT, and the interface normally provides a "constructor", which returns an abstract handle to new data, and several "operations", which are functions accepting the abstract handle as an argument. [cite book | author=Robert Sedgewick | title=Algorithms in C | publisher=Addison/Wesley | date=1998 | isbn=0-201-31452-5, definition 4.4. An alternative is to create an ADT that assumes it is the only instance. This means that a constructor is not required (although a routine to initialize the ADT may be), and individual functions need not specify an ADT handle. ]


Abstract data types (ADT) typically seen in textbooks and implemented in programming languages (or their libraries) include:

*Complex number
*Priority queue

eparation of interface and implementation

When realized in a computer program, the ADT is represented by an interface, which shields a corresponding implementation. Users of an ADT are concerned with the interface, but not the implementation, as the implementation can change in the future. (This supports the principle of information hiding, or protecting the program from design decisions that are subject to change.)

The strength of an ADT is that the implementation is hidden from the user. Only the interface is published. This means that the ADT can be implemented in various ways, but as long as it adheres to the interface, user programs are unaffected.

There is a distinction, although sometimes subtle, between the abstract data type and the data structure used in its implementation. For example, a List ADT can be represented using an array-based implementation or a linked-list implementation. A List is an abstract data type with well-defined operations (add element, remove element, etc.) while a linked-list is a pointer-based data structure that can be used to create a representation of a List. The linked-list implementation is so commonly used to represent a List ADT that the terms are interchanged in common use.

Similarly, a Binary Search Tree ADT can be represented in several ways: binary tree, AVL tree, red-black tree, array, etc. Regardless of the implementation, the Binary Search Tree always has the same operations (insert, remove, find, etc.)

Separating the interface from the implementation doesn't always mean the user is unaware of the implementation method, but rather that they can't depend on any of the implementation details. For example, an ADT can be created using a scripting language or one that can be decompiled (like C). Even though the user can discover the implementation method, the construct can still be called an ADT as long as any client program that conforms to the interface is unaffected if the implementation changes.

In object-oriented parlance, an ADT is a class; an instance of an ADT or class is an object. Some languages include a constructor for declaring ADTs or classes. For example, C++ and Java provide a class constructor for this purpose.

Abstract data structure

An abstract data structure is an abstract storage for data defined in terms of the set of operations to be performed on data and computational complexity for performing these operations, regardless of the implementation in a concrete data structure.

Selection of an abstract data structure is crucial in the design of efficient algorithms and in estimating their computational complexity, while selection of concrete data structures is important for efficient implementation of algorithms.

This notion is very close to that of an abstract data type, used in the theory of programming languages. The names of many abstract data structures (and abstract data types) match the names of concrete data structures.

Built-in abstract data types

Because some ADTs are so common and useful in computer programs, some programming languages build implementations of ADTs into the language as native types or add them into their standard libraries. For instance, Perl arrays can be thought of as an implementation of the List or Deque ADTs and Perl hashes can be thought of in terms of Map or Table ADTs. The C++ Standard Library and Java libraries provide classes that implement the List, Stack, Queue, Map, Priority Queue, and String ADTs.

Concrete examples

Rational numbers as an abstract data type

Rational numbers (numbers that can be written in the form a/b where a and b are integers and b is not zero) cannot be represented natively in a computer. A Rational ADT could be defined as shown below.

Construction: Create an instance of a rational number ADT using two integers, a and b, where a represents the numerator and b represents the denominator.

Operations: addition, subtraction, multiplication, division, exponentiation, comparison, simplify, conversion to a real (floating point) number.

To be a complete specification, any operation should be defined in terms of the data. For example, when multiplying two rational numbers a/b and c/d, the result is defined as ( a c ) / ( b d ). Typically, inputs, outputs, preconditions, postconditions, and assumptions for the ADT are specified as well.


Formal specification


E is the element type and T is the Stack type.


* T new (void)
* T push (E,T)
* E top(T)
* T removetop(T)
* Boolean empty (T)


* empty(new())
* top(push(e,t)) = e
* removetop(push(e,t)) = t
* not empty(push(e,t))


* .. removetop (T) requires not empty (T)
* .. pop (T) requires not empty (T)

C-style interface and usage

The interface for a Stack ADT, written in C-style notation, might be:

long stack_create(); /* create new instance of a stack */ void stack_push(long stack, void *item); /* push an item on the stack */ void *stack_pop(long stack); /* get item from top of stack */ void stack_delete(long stack); /* delete the stack */

This ADT could be used in the following manner:

long stack; struct foo *f; stack = stack_create(); /* create a stack */ stack_push(stack, f); /* add foo structure to stack */ f = stack_pop(stack); /* get top structure from stack */

Implementation variants

The above stack ADT could be initially implemented using an array, and then later changed to a linked list, without affecting any user code. The number of ways a given ADT can be implemented depends on the programming language. For example, the above example could be written in C using a struct and an accompanying set of data structures using arrays or linked lists to store the entries; however, since the constructor function returns an abstract handle, the actual implementation is hidden from the user.


ee also

* Concept (generic programming)

External links

* [http://www.nist.gov/dads/HTML/abstractDataType.html Abstract data type] in NIST Dictionary of Algorithms and Data Structures

Wikimedia Foundation. 2010.

Look at other dictionaries:

  • abstract data type — abstraktusis duomenų tipas statusas T sritis informatika apibrėžtis ↑Duomenų tipas, kuris apibrėžiamas nusakant operacijas su to tipo duomenų reikšmėmis, tačiau nepriklauso nuo reikšmių pavaizdavimo. Santrumpa ADT. Abstrakčiojo duomenų tipo… …   Enciklopedinis kompiuterijos žodynas

  • Data type — For other uses, see Data type (disambiguation). In computer programming, a data type is a classification identifying one of various types of data, such as floating point, integer, or Boolean, that determines the possible values for that type; the …   Wikipedia

  • Array data type — Not to be confused with Array data structure. In computer science, an array type is a data type that is meant to describe a collection of elements (values or variables), each selected by one or more indices that can be computed at run time by the …   Wikipedia

  • Algebraic data type — In computer programming, particularly functional programming and type theory, an algebraic data type (sometimes also called a variant type[1]) is a datatype each of whose values is data from other datatypes wrapped in one of the constructors of… …   Wikipedia

  • Composite data type — In computer science, a composite data type is any data type which can be constructed in a program using its programming language s primitive data types and other composite types. The act of constructing a composite type is known as composition.… …   Wikipedia

  • Opaque data type — In computer science, an opaque data type is a user defined data type used like built in data type. It is incompletely defined in an interface, so that ordinary client programs can only manipulate data of that type by calling procedures that have… …   Wikipedia

  • Complex data type — Some programming languages provide a complex data type for complex number storage and arithmetic as a built in (primitive) data type. In some programming environments the term complex data type (in contrast to primitive data types) is a synonym… …   Wikipedia

  • Decimal data type — Some programming languages provide a built in (primitive) or library decimal data type to represent non repeating decimal fractions like 0.3 and 1.17 without rounding, and to do arithmetic on them. Examples are the decimal.Decimal type of Python …   Wikipedia

  • Data model — Overview of data modeling context: A data model provides the details of information to be stored, and is of primary use when the final product is the generation of computer software code for an application or the preparation of a functional… …   Wikipedia

  • Data structure — In computer science, a data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.[1][2] Different kinds of data structures are suited to different kinds of applications, and some are highly …   Wikipedia

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”