COLLEGE OF COMPUTER STUDIES AND MULTIMEDIA ARTS

CCS0015L
(DATA STRUCTURES AND ALGORITHMS)

EXERCISE

1
ABSTRACT DATA TYPE

Student Name / Group

Name:
Name Role
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]

II. COURSE LEARNING OUTCOME/S (CLO) ADDRESSED BY THE LABORATORY EXERCISE

 Understand the fundamental principles of data structures and algorithms: concepts of abstract data; types of
common data structures; description, properties, and storage allocation of data structures. [CLO: 1]

III. INTENDED LEARNING OUTCOME/S (ILO) OF THE LABORATORY EXERCISE

At the end of this exercise, students must be able to:
 Learn how to design a user-defined data structure.
 Create a program that will implement a simple user-defined data structure.

IV. BACKGROUND INFORMATION

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.
• isEmpty() – Return true if the list is empty, otherwise return false.
• isFull() – Return true if the list is full, otherwise return false.

CCS0015L-Data Structures and Algorithms Page 2 of

7
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

ACTIVITY 1.1: Array Abstract Data Type

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:

class Array1D
{
private:
int capacity;
int size;
int *array;
public:
Array1D(int Arraycap=10);

CCS0015L-Data Structures and Algorithms Page 3 of

7
~Array1D(){ delete [] array;}
int Getsize();
bool isEmpty() const;
bool isFull() const;
void InsertItem(int pos,int val);
void RemoveItem(int pos);
void AddItem(int val);
void DisplayElements();

};

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:
• AddItem(val) – inserts an item val in the array after the index of the last element.
• GetSize() function returns the number of elements currently stored in array
• isEmpty() checks if the array is empty and returns true if so, else false
• isFull() checks if the array is full before every insert operation on array.
• InsertItem(pos, val) is a function that will insert an item val at the index pos.
• RemoveItem(pos) is a function that will remove an item at index pos.
• DisplayItems() is a function that displays the elements in the array.

Encode the following lines below inside the main() function:

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;

CCS0015L-Data Structures and Algorithms Page 4 of

7
 }

return 0;

Program: (save as [surname_1_1.cpp] )

Note: Write your complete working program here.

Output:(screenshot of the output)

CCS0015L-Data Structures and Algorithms Page 5 of

7
VI. QUESTION AND ANSWER

Directions: Briefly answer the questions below.

 How do abstract data types help in creating applications?

 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
 Chang, Kung-Hua(2017). Data Structures Practice Problems for C++ Beginners. S.l : Simple and
Example
 Hemant Jain(2017). Problem Solving in Data Structures & Algorithms Using C++: Programming
Interview Guide. USA: CreateSpace Independent Publishing Platform

RUBRIC:

Criteria 4 3 2 1 Score
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.
Solution(x5) logical errors.

CCS0015L-Data Structures and Algorithms Page 6 of

7
 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
Program designed.
design. designed.
Design(x3)

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.
Completeness complete.
screenshots) correct.
of
Document(x2)
Total

CCS0015L-Data Structures and Algorithms Page 7 of

7