Abstract Data Type ADT Abstract Data Type ADT

Abstract Data Type (ADT)

Abstract Data Type (ADT) • An Abstract Data Type (ADT) is a data structure with a set of operations – Operations specify how the ADT behaves, but does not reveal how they are implemented – In many cases, there are more than one way to implement an ADT • In this course we will cover lots of ADTs – – – Lists Stacks Queues Trees & Search Trees Hash Tables & Tries 2

Abstract Data Type (ADT) - more • An Abstract Data Type (ADT) is a data structure with a set of operations Attributes (ADT State) … … Operations (ADT Methods) Operation 1(…) Operation 2(…) Operation 3(…) … … … 3

• What is a list? List ADT – An ordered sequence of elements A 1, A 2, …, AN – Elements may be of arbitrary, but the same type (i. e. , all ints, all doubles etc. ) • Common List operations are: – – – – Insert(Element. Type E, Position P) Delete(Position P) Find(Element. Type E) Is. Empty() – Returns true if the list is empty First() – Returns the first element Last() – Returns the last element Kth(Position K) – Returns the Kth element Length() – Returns the length of the list 4

Array List ADT Array. List ADT #define MAX_SIZE 100; typedef struct Array. List { int elements[MAX_SIZE]; int no. Of. Elements; // Constructor: // Make empty list Array. List(){ no. Of. Elements = 0; } // end-Array. List //public Array. List (); // Constructor void Insert(int e, int pos); void Delete(int pos); int Find(int e); bool Is. Empty(); int First(); int Last(); int Kth(int pos); int Length(); }; 5

The Abstract Data Type (ADT) The concept of abstraction means: • We know what a data type can do • How it is hidden for the user ØWith an ADT users are not concerned with how the task is done but rather with what it can do. 6

ADT: Example • The program code to read/write some data is ADT. It has a data structure (character, array of characters, array of integers, array of floating-point numbers, etc. ) and a set of operations that can be used to read/write that data structure. 7

The Abstract Data Type (ADT) is: • A data declaration packaged together with the operations that are meaningful for the data type. • In other words, we encapsulate the data and the operations on the data, and then we hide them from the user. ØDeclaration of data ØDeclaration of operations ØEncapsulation of data and operations 8

The Abstract Data Type (ADT) • All references to and manipulation of the data in a structure must be handled through defined interfaces to the structure. • Allowing the application program to directly reference the data structure is a common fault in many implementations. • We must hide the implementation from the user 9

ADT Operations • 1. 2. 3. 4. Several classes of operations are required in order to effectively used ADT. Constructors – used to create instances of the data type. Destructors – used to destroy an instance of the data type Accessors – used to access attributes of the data type. (Such as “get” functions) Modifiers – used to modify attributes of the data type. (Such as “set” functions) Object-oriented languages provide some of this functionality within the language. In C you must do it yourself.

11

Design While we’ve defined an ADT interface, we can’t just start coding quite yet. There are more design decisions to be made before writing code for the implementation. A common error among programmers is to not place enough emphasis on the design step. This is the difference between a “programmer” and an “analyst”.

Fraction ADT Design: Data Analysis begins with the idea that all the operations will be acting on Fractions that have some internal representation. The representation shall be shared among all the operations. Each operation is responsible for maintaining your design rules regarding the representation of Fraction information. typedef enum{ POS, NEG } Sign. Type; typedef Fraction { //private: // data members int numerator; /* numerator and denominator are declared as */ int denominator; /* int to simplify the algorithms, but they */ Sign. Type sign; /* will always be stored >= 0 */ // public: // member functions would follow //private: // utility functions would follow }; All operations must preserve these rules.

Fraction ADT Variables • Now that we’ve decided how to represent the value of a fraction, how are we going to declare variables whose values are fractions? Fraction f 1, f 2;

Fraction ADT Algorithms • You are responsible for designing algorithms that implement all the operations. What process must you follow to implement the operations? a c ad + bc Sum: + = b d bd Product: a c ac * = b d bd then, reduce Subtraction involves adding the opposite, and Division involves multiplying by the reciprocal.

Fraction ADT Algorithms • Reducing a fraction involves finding the Greatest Common Divisor, and then dividing all the terms by that amount. Euclid’s Algorithm: if x < y, then swap x and y While y is not zero remainder = x mod y x=y y = remainder When you’re done, x is the GCD.

Accessors /****** Accessors *******/ int get. Numerator(); int get. Denominator(); char get. Sign();

Modifiers /***** Modifiers ******/ void set. Numerator(int); void set. Denominator(int); void set. Sign(char); void reduce. Fract();