Name:
Reg No:
DATA STRUCTURE AND ALGORITHM (THEORY)
FINAL EXAMINATION
QUESTION NO: 01
CODE:
import java.util.Scanner;
public class LinkListInsertionAndBSTCreation {
class Node{
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
class NodeBST {
int key;
NodeBST left, right;
public NodeBST(int data){
key = data;
left = right = null;
// BST root node
NodeBST root;
// Constructor for BST =>initial empty tree
LinkListInsertionAndBSTCreation(){
root = null;
//Represent the head and tail of the singly linked list
public Node head = null;
public Node tail = null;
//addAtStart() will add a new node to the beginning of the list
public void addAtStart(int data) throws IllegalAccessException{
//Create a new node
Node newNode = new Node(data);
//Checks if the list is empty
if(head == null) {
//If list is empty, both head and tail will point to new node
head = newNode;
tail = newNode;
else {
if (head.data == data){
throw new IllegalAccessException(Integer.toString(data));
//Node temp will point to head
Node temp = head;
//newNode will become new head of the list
head = newNode;
//Node temp(previous head) will be added after new head
head.next = temp;
public void insertNth(int data, int position) throws IllegalAccessException{
//create new node.
Node newNode = new Node(data);
if (head == null) {
//if head is null and position is zero then exit.
if (position != 0) {
return;
} else { //node set to the head.
head = newNode;
tail = newNode;
if (head != null && position == 0) {
if (head.data == data){
throw new IllegalAccessException(Integer.toString(data));
newNode.next = this.head;
this.head = newNode;
return;
Node current = this.head;
Node previous = null;
if(position > 0){
int i = 1;
while (i < position) {
if (current.data == data){
throw new IllegalAccessException(Integer.toString(data));
}
previous = current;
current = current.next;
if (current == null) {
break;
i++;
newNode.next = current;
previous.next = newNode;
else{
tail.next = newNode;
//newNode will become new tail of the list
tail = newNode;
//display() will display all the nodes present in the list
public void display() {
//Node current will point to head
Node current = head;
if(head == null) {
System.out.println("List is empty");
return;
System.out.println("Nodes of the list: ");
while(current != null) {
//Prints each node by incrementing pointer
System.out.print(current.data + " ");
current = current.next;
System.out.println();
public int getLength() {
//Node current will point to head
Node current = head;
int listLength = 0;
if(head == null) {
return 0;
while(current != null) {
current = current.next;
listLength++;
return listLength;
}
// insert a node in BST
void insert(int key) {
root = insert_Recursive(root, key);
//recursive insert function
NodeBST insert_Recursive(NodeBST root, int key) {
//tree is empty
if (root == null) {
root = new NodeBST(key);
return root;
//traverse the tree
if (key < root.key) //insert in the left subtree
root.left = insert_Recursive(root.left, key);
else if (key > root.key) //insert in the right subtree
root.right = insert_Recursive(root.right, key);
// return pointer
return root;
void inorder() {
inorder_Recursive(root);
}
// recursively traverse the BST
void inorder_Recursive(NodeBST root) {
if (root != null) {
inorder_Recursive(root.left);
System.out.print(root.key + " ");
inorder_Recursive(root.right);
public void createTree(){
LinkListInsertionAndBSTCreation bstree = new LinkListInsertionAndBSTCreation();
Node current = head;
System.out.println("Adding nodes to the BST: ");
while(current != null) {
bstree.insert(current.data);
current = current.next;
bstree.inorder();
public static void main(String[] args) {
LinkListInsertionAndBSTCreation sList = new LinkListInsertionAndBSTCreation();
Scanner sc = new Scanner(System.in);
try {
sList.addAtStart(7);
sList.addAtStart(2);
sList.addAtStart(6);
sList.addAtStart(8);
sList.insertNth(4, -1);
sList.insertNth(10, -1);
sList.insertNth(1, -1);
sList.insertNth(9, -1);
sList.insertNth(3, -1);
catch (IllegalAccessException e) {
System.out.println("Duplicate Entry into list ---> "+e.getMessage());
/*while (true) {
try{
System.out.println("Enter Element and position :");
int e = sc.nextInt();
int p = sc.nextInt();
sList.insertNth(e, p);
System.out.println("Go again? enter y to continue, n to stop ");
String goAgain = sc.next();
if (!goAgain.equals("n") || !goAgain.equals("N")) {
break;
catch (IllegalAccessException e) {
System.out.println("Duplicate Entry into list ---> "+e.getMessage());
}
} */
sList.display();
int listlength = sList.getLength();
// System.out.println(listlength);
if(listlength >= 10){
sList.createTree();
OUTPUT:
QUESTION NO: 02
a)Division method with m=97
it using mod with the keys to generate code
Hash address with divisioon method is
For mouseKey 4614%97=55
For KeyboardKey 5882%97=62
For cableKey 6713%97=20
For webcamKey 4409%97= 44
For monitorKey 1825%97=79
b) Mid square method
Hash address
For mouseKey 4614*4614=21288996=88
For KeyboardKey 5882*5882=34597924=97
For cableKey 6713*6713=45064369=64
For webcamKey 4409*4409 =19439281=39
For monitorKey 1825*1825=3330625= 30
it multiply keys and pick the middle two elements
c) Folding method without reversing
Hash address with Folding method without reversing is
For mouseKey 4+6+1+3=15
For KeyboardKey5+8+8+2=23
For cableKey6+7+1+3=17
For webcamKey4+4+0+9=17+1=18(could be done)
For monitorKey1+8+2+5=16
digits in the keys are added to generate code
d) Folding method with reversing
Hash address with Folding method with reversing is
For mouseKey 4+6+1+3=15 reverse =51
For KeyboardKey5+8+8+2=23 reverse 32
For cableKey6+7+1+3=17 reverse=71
For webcamKey4+4+0+9=17 reverse =71+1=72(could be done)
For monitorKey1+8+2+5=16 reverse 61
digits in the keys are reversed and are added to generate code
Program in java
class hashCode
public static void main(String args[])
int mouseKey = 4614;
int KeyboardKey =5882;
int cableKey =6713;
int webcamKey = 4409;
int monitorKey = 1825;
//division method with m=97
//uses mod97
System.out.println("Hash address with divisioon method is ");
System.out.println("For mouseKey" +mouseKey%97);
System.out.println("For KeyboardKey"+KeyboardKey%97);
System.out.println("For cableKey"+cableKey%97);
System.out.println("For webcamKey"+webcamKey%97);
System.out.println("For monitorKey"+monitorKey%97);
System.out.println();
System.out.println("Hash address with mid square method is ");
System.out.println("For mouseKey" +gethash(mouseKey));
System.out.println("For KeyboardKey"+gethash(KeyboardKey));
System.out.println("For cableKey"+gethash(cableKey));
System.out.println("For webcamKey"+gethash(webcamKey));
System.out.println("For monitorKey"+gethash(monitorKey));
System.out.println();
System.out.println("Hash address with Folding method without reversing is ");
System.out.println("For mouseKey" +gethashFoldingMethod(mouseKey));
System.out.println("For KeyboardKey"+gethashFoldingMethod(KeyboardKey));
System.out.println("For cableKey"+gethashFoldingMethod(cableKey));
System.out.println("For webcamKey"+gethashFoldingMethod(webcamKey));
System.out.println("For monitorKey"+gethashFoldingMethod(monitorKey));
System.out.println();
System.out.println("Hash address with Folding method with reversing is ");
System.out.println("For mouseKey" +gethashFoldingMethodR(mouseKey));
System.out.println("For KeyboardKey"+gethashFoldingMethodR(KeyboardKey));
System.out.println("For cableKey"+gethashFoldingMethodR(cableKey));
System.out.println("For webcamKey"+gethashFoldingMethodR(webcamKey));
System.out.println("For monitorKey"+gethashFoldingMethodR(monitorKey));
System.out.println();
static long gethash(int key)
//example for key 4614
key = key * key; //key *key = 21288996
key = key / 1000; //key/1000=21288
key = key % 100; // key%100= 21288%100= 88
return key; //88 is returned
static int gethashFoldingMethod(int key)
int sum=0;
int r=0;
for(int i=key;i>0;i=i/10) //to extract digit
{
r=i%10;
sum=sum+r;
return sum;
static int gethashFoldingMethodR(int key)
int sum=0;
int r=0;
for(int i=key;i>0;i=i/10) //to extract digit
r=i%10;
sum=sum+r;
int rev=0;
for(int i=sum;i>0;i=i/10) //to extract digit and reverse
r=i%10;
rev=(rev*10)+r;
return rev;
}
}
OUTPUT:
QUESTION NO: 03(a)
Answers.
A priority queue can have any implementation, like a array that you search linearly when you
pop. All it means is that when you pop you get the value with either the minimum or the
maximum depending. A classic heap as it is typically referred to is usually a min heap.
An implementation that has good time complexity (O(log n) on push and pop) and no memory
overhead.
QUESTION NO: 03(b)
QUESTION NO: 04(a)
Consider the cut of a graph G, such that one particular vertex v is on one side of cut and
remaining V-v vertices are on other side of cut.
In the minimum spanning tree, either vertex v could be a leaf node of MST or it could act as a
bridge to connect two component of minimum spanning tree. Also MST is unique when every
edge weight are distinct.
Let e be minimum weight edge that is incident on v.
If vertex v is leaf node of MST, then vertex v will be connected with remaining portion of MST
by least weight edge e which is incident on v to minimize the total weight of MST. So minimum
weight edge e incident on v will be taken for MST.
If vertex v is not leaf node of MST then it must be connecting two connected components of
MST. In this case also, edge e will be connected with one of the connected component of MST to
minimize the total weight of MST and another edge will connect other connected component of
MST.
So in either case, the minimum weight edge which is incident on any vertex v must be the part of
MST.
Since we know that for every vertex having minimum weight edge incident on it must be the part
of MST. So since there are |V| vertices in the graph, we can select |V|/2 edges such that each of
these edges is minimum weight edge incident on atleast one vertex out of 2 vertices that this
edge connect. Hence we could select |V|/2 edges and then contract these edges to reduce the size
of graph to |V|/2 vertices and edge size will also reduce.
Since contracting one edge of graph requires transformation of graph which could take O(|V|+|
E|) time as per operations mentioned in question. So contacting |V|/2 edges will require O(|V|(|V|
+|E|)) time complexity.
Since this algorithm perform the same task on new graph with |V|/2 vertices, so the time
complexity recurrence will be
T(|V|) = T(|V|/2) + O(|V|2+|V||E|),
which gives T(|V|) = O(|V|2+|V||E|)
QUESTION NO: 04(b)
A graph is a data structure that consists of the following two components:
1. A finite set of vertices also called as nodes.
2. A finite set of ordered pair of the form (u, v) called as edge. The pair is ordered because (u, v)
is not the same as (v, u) in case of a directed graph(di-graph). The pair of the form (u, v)
indicates that there is an edge from vertex u to vertex v. The edges may contain
weight/value/cost.
Graphs are used to represent many real-life applications: Graphs are used to represent networks.
The networks may include paths in a city or telephone network or circuit network. Graphs are
also used in social networks like linkedIn, Facebook. For example, in Facebook, each person is
represented with a vertex(or node). Each node is a structure and contains information like person
id, name, gender, and locale. See this for more applications of graph.
Following is an example of an undirected graph with 5 vertices.
The following two are the most commonly used representations of a graph.
1. Adjacency Matrix
2. Adjacency List
There are other representations also like, Incidence Matrix and Incidence List. The choice of
graph representation is situation-specific. It totally depends on the type of operations to be
performed and ease of use.
Adjacency Matrix:
Adjacency Matrix is a 2D array of size V x V where V is the number of vertices in a graph. Let
the 2D array be adj[][], a slot adj[i][j] = 1 indicates that there is an edge from vertex i to vertex j.
Adjacency matrix for undirected graph is always symmetric. Adjacency Matrix is also used to
represent weighted graphs. If adj[i][j] = w, then there is an edge from vertex i to vertex j with
weight w.
