Monzon 1 1
Monzon 1 1
CCS0015L
(DATA STRUCTURES AND ALGORITHMS)
EXERCISE
1
ABSTRACT DATA TYPE
Name Role
Monzon
Members (if Group):
Section:
Professor:
I. PROGRAM OUTCOME/S (PO) ADDRESSED BY THE LABORATORY EXERCISE
● Apply knowledge of computing appropriate to the discipline. [PO: A]
Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a set of value
and a set of operations.
The definition of ADT only mentions what operations are to be performed but not how these operations
will be implemented. It does not specify how data will be organized in memory and what algorithms will be
used for implementing the operations. It is called “abstract” because it gives an implementation
independent view. The process of providing only the essentials and hiding the details is known as
abstraction.
The user of data type need not know that data type is implemented, for example, we have been using
int, float, char data types only with the knowledge with values that can take and operations that can be
performed on them without any idea of how these types are implemented. So a user only needs to know
what a data type can do but not how it will do it. We can think of ADT as a black box which hides the inner
structure and design of the data type. Now we’ll define three ADTs namely List ADT, Stack ADT, Queue
ADT.
List ADT
A list contains elements of same type arranged in sequential order and following operations can be
performed on the list.
• get() – Return an element from the list at any given position.
• insert() – Insert an element at any position of the list.
• remove() – Remove the first occurrence of any element from a non-empty list.
• removeAt() – Remove the element at a specified location from a non-empty list.
• replace() – Replace an element at any position by another element.
• size() – Return the number of elements in the list.
Stack ADT
A Stack contains elements of same type arranged in sequential order. All operations takes place at a single
end that is top of the stack and following operations can be performed:
• push() – Insert an element at one end of the stack called top.
• pop() – Remove and return the element at the top of the stack, if it is not empty.
• peek() – Return the element at the top of the stack without removing it, if the stack is not empty.
• size() – Return the number of elements in the stack.
• isEmpty() – Return true if the stack is empty, otherwise return false.
• isFull() – Return true if the stack is full, otherwise return false.
Queue ADT
A Queue contains elements of same type arranged in sequential order. Operations takes place at both
ends, insertion is done at end and deletion is done at front. Following operations can be performed:
• enqueue() – Insert an element at the end of the queue.
• dequeue() – Remove and return the first element of queue, if the queue is not empty.
• peek() – Return the element of the queue without removing it, if the queue is not empty.
• size() – Return the number of elements in the queue.
• isEmpty() – Return true if the queue is empty, otherwise return false.
• isFull() – Return true if the queue is full, otherwise return false.
From these definitions, we can clearly see that the definitions do not specify how these ADTs will be
represented and how the operations will be carried out. There can be different ways to implement an ADT,
for example, the List ADT can be implemented using arrays, or singly linked list or doubly linked list.
Similarly, stack ADT and Queue ADT can be implemented using arrays or linked lists.
V. LABORATORY ACTIVITY
Write a program to perform various operations on an array of elements, such as, create an array of
elements, store elements, retrieve elements using overloading of stream insertion and extraction operators,
and to know if array is empty or full, etc. The ADT for Array1D is as follows:
#include <iostream>
class Array1D {
private:
int *arr;
public:
Array1D(int capacity) {
this->capacity = capacity;
size = 0;
arr = new int[capacity];
}
~Array1D() {
delete[] arr;
}
bool isEmpty() {
return size == 0;
}
bool isFull() {
return size == capacity;
}
int main() {
int capacity;
std::cout << "Enter the capacity of the array: ";
std::cin >> capacity;
Array1D array(capacity);
if (array.isEmpty()) {
std::cout << "Array is empty." << std::endl;
} else {
std::cout << "Array is not empty." << std::endl;
}
if (array.isFull()) {
std::cout << "Array is full." << std::endl;
} else {
std::cout << "Array is not full." << std::endl;
}
return 0;
}
Implement the constructor to dynamically allocate memory to the array, and also implement the destructor
to release the memory allocated to array.
Implement also the following operations:
Array1D arr(5);
arr.AddItem(10);
arr.AddItem(20);
arr.AddItem(30);
arr.DisplayElements();
arr.InsertItem(1, 15);
arr.DisplayElements();
arr.AddItem(40);
arr.DisplayElements();
arr.AddItem(50);
arr.RemoveItem(0);
arr.DisplayElements();
cout << "Array size: " << arr.GetSize() << endl;
if (arr.isEmpty())
{
cout << "Array is empty!" << endl;
}
else
{
cout << "Array is not empty!" << endl;
}
return 0;
int main()
{
Array1D arr(5);
arr.AddItem(10);
arr.AddItem(20);
arr.InsertItem(1, 15);
arr.DisplayElements();
arr.AddItem(40);
arr.DisplayElements();
arr.AddItem(50);
arr.RemoveItem(0);
arr.DisplayElements();
if (arr.isEmpty())
{
std::cout << "Array is empty!" << std::endl;
}
else
{
std::cout << "Array is not empty!" << std::endl;
}
return 0;
}
● How the use of an abstract data type helps manage complexity in your program?
VII. REFERENCES
● Wittenberg, Lee.(2018). Data structures and algorithms in C++. s.l.: Mercury Learning
● Baka, Benjamin(2017). Python data structures and algorithms : improve the performance and speed of
your applications. Birmingham, U.K : Packt Publishing
● Downey, Allen.(2017). Think data structures : algorithms and information retrieval in Java. Sebastopol,
CA: O'Reilly
RUBRIC:
Criteria 4 3 2 1 Score
Solution(x5) A completed
A completed solution is An incomplete
A completed
solution is implemented solution is
solution runs
tested and runs on the required implemented
without errors.
but does not platform, and on the required
It meets all the
meet all the uses the platform. It
specifications
specifications compiler does not
and works for
nd/or work for specified. It compile and/or
all test data.
all test data. runs, but has run.
logical errors.
Program
Design(x3) The program Not all of the
Few of the
The program design selected
selected
design uses generally uses structures are
structures are
appropriate appropriate appropriate.
appropriate.
structures. The structures. Some of the
Program
overall program Program program
elements are
design is elements elements are
not well
appropriate. exhibit good appropriately
designed.
design. designed.
Completeness
of Document(x2)
All required There are few
All required
parts of the parts of the Most of the
parts in the
document are document are parts of the
document are
complete and missing but the document are
present and
correct(code, rest are missing and
correct but not
output of complete and incorrect.
complete.
screenshots) correct.
Total