DAR ES SALAAM INSTITUTE OF TECHNOLOGY

DATASTRUCTURES & ALGORITHIMS

OPEN TEST
NAME: SIAKA THOMAS SHIRIMA
REG NO: 190230220567
QUESTIONS AND ANSWERS
i. Write an algorithm to demonstrate;
a) Linear search
Consider: -
 There is a linear array ‘a’ of size ‘n’.
 Linear search algorithm is being used to search
an element ‘item’ in this linear array.
 If search ends in success, it sets loc to the index
of the element otherwise it sets loc to -1.

Then, Linear Search Algorithm is as follows: -

Linear_Search (a , n , item , loc)

Begin
for i = 0 to (n - 1) by 1 do
if (a[i] = item) then
set loc = i
Exit
endif
endfor
set loc = -1
End

b) Binary search
Consider: -
 There is a linear array ‘a’ of size ‘n’.
 Binary search algorithm is being used to search
an element ‘item’ in this linear array.
 If search ends in success, it sets loc to the index
of the element otherwise it sets loc to -1.
 Variables beg and end keeps track of the index of
the first and last element of the array or sub
array in which the element is being searched at
that instant.
 Variable mid keeps track of the index of the
middle element of that array or sub array in
 which the element is being searched at that
instant.

Then, Binary Search Algorithm is as follows: -

Begin
Set beg = 0
Set end = n-1
Set mid = (beg + end) / 2
while ( (beg <= end) and (a[mid] ≠ item) ) do
if (item < a[mid]) then
Set end = mid - 1
else
Set beg = mid + 1
endif
Set mid = (beg + end) / 2
endwhile
if (beg > end) then
Set loc = -1
else
Set loc = mid
endif
End

c) Bubble sort
The bubble sort algorithm is given below-

for(int pass=1 ; pass<=n-1 ; ++pass) // Making passes

through array
{
for(int i=0 ; i<=n-2 ; ++i)
{
if(A[i] > A[i+1]) // If adjacent elements are in wrong order
swap(i,i+1,A); // Swap them
}
}
//swap function : Exchange elements from array A at
position x,y
 void swap(int x, int y, int[] A)
{
int temp = A[x];
A[x] = A[y];
A[y] = temp;
return ;
}
// pass : Variable to count the number of passes that are
done till now
// n : Size of the array
// i : Variable to traverse the array A
// swap() : Function to swap two numbers from the array
// x,y : Indices of the array that needs to be swapped

d) Insertion sort
Let A be an array with n elements. The insertion sort
algorithm used for sorting is as follows-

for (i = 1 ; i < n ; i++)

{
key = A [ i ];
j = i - 1;
while(j > 0 && A [ j ] > key)
{
A [ j+1 ] = A [ j ];
j--;
}
A [ j+1 ] = key;
}

Here,
• i = variable to traverse the array A
• key = variable to store the new number to be inserted
into the sorted sub-array
• j = variable to traverse the sorted sub-array

ii. State the time complexity for each of the algorithms in (i).
a. Time Complexity of Linear Search Algorithm is O(n).
Here, n is the number of elements in the linear array.

b. Time Complexity of Binary Search Algorithm is O(log2n).

Here, n is the number of elements in the sorted linear array.

c. Following are the Time complexity for the Bubble Sort

algorithm:
 Worst Case Time Complexity [ Big-O ]: O(n2)
 Best Case Time Complexity [Big-omega]: O(n)
 Average Time Complexity [Big-theta]: O(n2)

d. Following are the Time complexity for the Insertion Sort

algorithm:
 Worst Case Time Complexity [ Big-O ]: O(n2)
 Best Case Time Complexity [Big-omega]: O(n)
 Average Time Complexity [Big-theta]: O(n2)
iii. Write a program to swap 5 elements from array called HUB to
an empty array called HOB.

Output:
iv. Write a program to demonstrate addition and removal of
elements from a linked list with 5 numbers.

Output:
v. Write a program to demonstrate an array list with addition
and removal of elements at a specific position.

Output:
vi. With aid of a diagram demonstrate the two different types of
linked list.
 Singly Linked List
It is the most common. Each node has data and a pointer to
the next node.

 Doubly Linked List

We add a pointer to the previous node in a doubly-linked list.
Thus, we can go in either direction: forward or backward.

vii. Write step by stem instructions to explain dequeue () and

enqueue () methods.

Enqueue Operation: -
• check if the queue is full
• for the first element, set the value of FRONT to 0
• increase the REAR index by 1
• add the new element in the position pointed to by
REAR

Dequeue Operation: -
• check if the queue is empty
• return the value pointed by FRONT
• increase the FRONT index by 1
• for the last element, reset the values of FRONT and
REAR to -1
viii. With aid of a diagram demonstrate the following types of
queues. a) Simple Queue.
A simple queue is the most basic queue. In this queue, the
enqueue operation takes place at the rear, while the
dequeue operation takes place at the front:

Its applications are process scheduling, disk scheduling,

memory management, IO buffer, pipes, call center phone
systems, and interrupt handling.
b) Circular Queue.
A circular queue permits better memory utilization than a
simple queue when the queue has a fixed size.
In this queue, the last node points to the first node and creates a
circular connection. Thus, it allows us to insert an item at the first
node of the queue when the last node is full and the first node is
free.

It’s also called a ring buffer:

It’s used to switch on and off the lights of the traffic signal
systems. Apart from that, it can be also used in place of a simple
queue in all the applications mentioned above.
c) Priority Queue.
A priority queue is a special kind of queue in which each
item has a predefined priority of service. In this queue, the
enqueue operation takes place at the rear in the order of arrival of
the items, while the dequeue operation takes place at the front
based on the priority of the items.
That is to say that an item with a high priority will be dequeued
before an item with a low priority.
In the case, when two or more items have the same priority, then
they’ll be dequeued in the order of their arrival. Hence, it may or
may not strictly follow the FIFO rule:

It’s used in interrupt handling, Prim’s algorithm, Dijkstra’s

algorithm, A* search algorithm, heap sort, and Huffman code
generation.
d) Dequeue (Double Ended Queue)
A deque is also a special type of queue. In this queue, the
enqueue and dequeue operations take place at both front and
rear. That means, we can insert an item at both the ends and can
remove an item from both the ends. Thus, it may or may not
adhere to the FIFO order:

It’s used to save browsing history, perform undo operations,

implement A-Steal job scheduling algorithm, or implement a stack
or implement a simple queue.
Further, it has two special cases: input-restricted deque and
output-restricted deque.
 In the first case, the enqueue operation takes place only at the
rear, but the dequeue operation takes place at both rear and
front:

An input-restricted queue is useful when we need to remove an

item from the rear of the queue.
In the second case, the enqueue operation takes place at both
rear and front, but the dequeue operation takes place only at the
front:

An output-restricted queue is handy when we need to insert an

item at the front of the queue.
ix. Provide the five differences between Array and ArrayList
structures.
I. Resizable
One of the major and noticeable differences between the two data
structures is that Array is static in nature which means it is a fixed
length data type while ArrayList is dynamic in nature which means
it’s a variable length data structure. In technical terms, the length
of Array cannot be changed or modified once the Array object is
created. It contains sequential collection of elements of the same
data type. Arrays in Java work differently than they function in
C/C++. ArrayList, on the other hand, can resize itself and the
 arrays can grow as they needed. As it is a dynamic data structure,
the elements can be added and removed from the list.

II. Generics
You cannot create Arrays of Generic classes of interfaces in Java
so arrays and generics do not go hand in hand making it
impossible to create Generic Array for the one basic reason that
arrays are covariant while generics are invariant. While Array is a
fixed-length data structure, it contains objects of the same class or
primitives of the specific data type. So if you try to store different
data type other than the one specified while creating Array object,
it simply throws “ArrayStoreException”. ArrayList, on the other
hand, does support Generics to ensure type-safety.
III. Primitives
Primitive data types such as int, double, long, and char are not
allowed in ArrayList. It rather holds objects and primitives are not
considered objects in Java. Arrays, on the other hand, can hold
primitives as well as objects in Java because it is one of the most
efficient data structures in Java for storing objects. It’s an
aggregated data type that is designed to hold objects which can
be either of same or different type.
IV. Length

In order to get the length of the Array, the code needs to access
the length attribute because one must know the length to perform
operations on Array. While ArrayList uses size () method to
determine the size of the ArrayList, it is rather different from
determining the length of the Array. The size () method attribute
determines the number of elements in an ArrayList, which in turn
is the capacity of the ArrayList.
V. Implementation
Array is a native programming component in Java that are created
dynamically and they use assignment operator to hold elements,
while ArrayList use add( ) attribute to insert elements. ArrayList is
a class from collection framework in Java which uses a set of
specified methods to access and modify the elements. The size of
an ArrayList can be increased or decreased dynamically. The
elements in an array are stored in contiguous memory location and
its size remains static throughout.