Complete Tutorial of (ADT) Abstract Data Type in Data Structures

We all know that In Today’s world there is lots of software running in the market, But do you ever think how they work. there are many things behind that Software like Data Structures, algorithms, codes, etc. In this Tutorial we are going to learn about Abstract Data Type in Data Structures. If you don’t have any knowledge about Data Structures then go to my previous tutorial in which i have shared many things about what is Data Structures, why we use and some more things. Please click on this link to know about Data Structures. So, lets start with the (ADT) Abstract Data Type.

What is (ADT) Abstract Data Type?

An abstract data type (ADT) is an in competency a data types’ mathematical model in which a data type is described from the point of view of a data user by its behavior (semantics), in particular with regard to potential values, possible operations and the behavior of such operations. This contradicts data structures that reflect specific data representations, and which are an implementer’s point of view and not a user.

PHP consists of eight primitive data types: integer, float, text, array, object, resource, and null. We must know that PHP is a language with a weak type and we don’t have trouble with the declaration of data type during its creation. Although PHP has certain static type characteristics, PHP is mostly a language written in dynamic form, which implies that variables need not be declared before using them. We can allocate and quickly use a value to a new variable.

The Abstract datatype is a specific type of datatype, the behavior of which is specified by a collection of values. As we can use certain data types, we can do different operations, we use the term “Abstract.” However, how these actions function is completely concealed from the user. The ADT consists of elementary data types, but operational logic is concealed.

Which are the Types of (ADT) Abstract Data Type?

Stack and Queue are the Two Types, Let us see some operations of those mentioned (ADT) Abstract Data Type:-

• Stack
• Queue

What is Stack?

In everyday use, Stack is a pile which is a added in object of typical of a layer — a Stack of books on your desk or a Stack of tables at the school canteen. In IT, a stack is a sequential collection having a specific attribute, in that the latest object on the stack is the first deleted object. This feature is usually called LIFO(LastIn FirstOut). Candy, chip and cigarette distributors function according to the same concept and initially dispense the last item put on the rack.

The stack is in abstraction, a linear list of items in which the list is limited to one end – defined as the ‘top’ for each addition to (push) and deletion from (pop-) (of the stack). The fundamental operations defining a stack are:

• init – stack is created.
• push – add item on top of the stack.
• pop – remove last item which is added on top of the stack.
• top – looking item on the top of the stack without removing it.
• isEmpty – return whether the stack contains no more items.

A stack with the maximum capacity can also be implemented. Where the stack is complete and there is not many slots to receive new entities, the phrase “stack overflow” is said to be overflowing. Similarly, a “stack underflow” will occur if an operation on an empty stack is tried.

We can simply use arrays for implementing a stack in knowing that our stack is defined by the LIFO attribute and a handful of fundamental actions, notably push and pop.

Let’s see a simple example of Stack:-

Some Explanation about the example:-

In this example, rather than using array_push() and array_shift(), I use array_unshift() and array_pop(), thus the initial stack piece will always be the highest. In order to maintain semantic consistency, you can use array_push() and array_pop() to maintain a Nth stack element. This makes no difference, as the whole aim of an abstract form of data is to abstract the processing of the data.

What is Queue?

If you were ever in the queue at the grocery store, the first person in the queue is first served. Another abstract data type in computer language runs on an initial basis FIFO(FirstIn FirstOut). Inventory should also be maintained on a FIFO basis, especially if these commodities are perishable.

The basic fundamental operations defining a Queue are:

• init – queue is created.
• enqueue – item added at the “end” (tail) of the queue.
• dequeue – item remove from the “front” (head) of the queue.
• isEmpty – return whether the queue contains no more items.

Let’s see a simple example of Queue:-

Some Explanation about the example:-

In this Given Example we have Implementing of Queue using PHP. There is a Queue class that store element in queue. It Removes element from font and Insert element to back. then we have Check whether the queue is empty or not. After this we have call the return boolean and the public function isEmpty(){ return false; }. Then we have Insert element at the back of queue. Calling public function enqueue($value) and Remove element from the font of queue that return shows the $variable. and the Public Function is dequeue().

Why (ADT) Abstract Data Type is used in Data Structure?

In this article when you are learning, One thing just came in your mind that why you use (ADT) Abstract Data Type in Data Structure. We must recognise that ADT are largely theoretical notions for algorithms, data structures and software design design, design and analysis. Concrete representations, however, are data structures. We may need to employ data types or data frameworks or both in order to implement an ADT. Stack and queue are the most typical example of ADTs.

Here are some common (ADT) Abstract Data Type:-

• List
• Map
• Set
• Stack
• Queue
• Priority queue
• Graph
• Tree

How we relate Abstract Data Types and Data Structure

The data type has both a logical form and a physical form, as you can seen in the chart below. Therefore, the definition of the type of data is its logical form as regards the ADT (Abstract Data Types). The Data Structure (DA) is, thus, its physical shape for the implementation of data type.

Therefore, you deal with the physical form of the associated data type while implementing an ADT(Abstract Data Types). Also, you are occasionally interested with the logical form of the associated data type if you utilise an ADT otherwise in your application.

The ADT determines the logical shape of the data type. The physical shape of a data type is therefore implemented by the data structure (DA). Abstract Data Types users are usually programmers that work in the same language as the ADT implementer.

Conclusion

This article shows how stack and queue are used for programming with abstract data types. These data structures are abstract because they are defined by the operations that may be done on their own, establishing an intersection between their implementation and the underlying data. The effects of such operations also confine those structures: only things from the top of the stack may be added or removed and only items may be removed from a rear end or items added on the rear of the queue.