PARUL UNIVERISTY

PARUL INSTITUTE OF TECHNOLOGY

FACULTY OF ENGINEERING AND TECHNOLOGY

Lab Manual

Name :-

Enrollment no. :-

Roll no. :-

Division :-

Subject :- Competitive Coding Level 2A

Year/Sem :-

Faculty :-
 CERTIFICATE
This is to certify that with Enrollment no.

…………………. has successfully completed his laboratory experiments

in the Competitive Coding Level-2A from the department of B. Tech

Computer Science & Engineering during academic year 2023-24.

Date of submission :- Staff in charge :-

Enrollment No : Page | 1
 Index
Sr.no Experiment title Date Marks Sign
1 Write a program for implementing
a MINSTACK which should support
operations like push, pop, overflow,
underflow, display
1. Construct a stack of N-capacity
2. Push elements
3. Pop elements
4. Top element
5. Retrieve the min element from the
stack

2 Write a program to deal with real-world

situations where Stack data structure is widely
used
Evaluation of expression:
Stacks are used to evaluate expressions,
especially in languages that use postfix or
prefix notation. Operators and operands are
pushed onto the stack, and operations are
performed based on the LIFO principle.
3 Write a program for finding NGE NEXT
GREATER ELEMENT from an array

4 Write a program to design a circular queue(k)

which Should implement the below functions
• Enqueue
• Dequeue
• Front
• Rear

5 Write a Program for an infix expression, and

convert it to postfix notation. Use a queue to
implement the Shunting Yard Algorithm for
expression conversion.

Enrollment No : Page | 2
 6 Write a Program for finding the Product of the
three largest Distinct Elements. Use a Priority
Queue to efficiently find and remove the
largest elements

7 Write a Program to Merge two linked

lists(sorted)
8 Write a Program to find the Merge point of
two linked lists(sorted)

9 Write a Program to Swap Nodes pairwise

10 Write a Program to Understand and

implement Tree traversals i.e. Pre-Order Post-
Order, In-Order
11 Write a Program to verify and validate
mirrored trees or not
12 Write a Program to determine the depth of a
given Tree by Implementing MAXDEPTH
13 Write a program for Lowest Common
Ancestors

14 Write a Program to Build BST

15 Write a Program for Building a Function
ISVALID to VALIDATE BST
16 Write a Program to Traverse a Tree using
Level Order Traversal
17 Write a Program to perform Boundary
Traversal on BST
18 Write a Program to view a tree from left View
19 Write a Program for a basic hash function in a
programming language of your choice.
Demonstrate its usage to store and retrieve
key-value pairs.
20 Write a Program to Implement Two sums
using HASHMAP
21 Write a Program to find Distinct substrings in
a string

Enrollment No : Page | 3
 Practical 1
Aim : Write a program for implementing a MINSTACK which should support
operations like push, pop, overflow, underflow, display
a. Construct a stack of N-capacity
a. Push elements
a. Pop elements
a. Top element
a. Retrieve the min element from the stack

Algorithm :

This Java code implements a MinStack data structure that stores integers with the ability to
retrieve the minimum element efficiently. It uses two stacks - one stack (stack) to store elements
and another stack (minStack) to keep track of the current minimum element.

• Instance Variables:
o maxSize: Maximum capacity of the stack.
o stack: A stack to store elements.
o minStack: A stack to keep track of the minimum element.
• Constructor (MinStack(int capacity)):
o Initializes maxSize to the given capacity.
o Creates empty stack and minStack.
• Methods:
o push(int element): Adds an element to the stack and updates the minimum
element in minStack if necessary.
o pop(): Removes the top element from the stack and
updates minStack accordingly.
o top(): Returns the top element of the stack without removing it.
o getMin(): Returns the current minimum element.
o display(): Displays all elements in the stack.
• Main Method:
o Creates a MinStack instance with a capacity of 5.
o Demonstrates pushing elements, popping elements, displaying the stack,
obtaining the minimum element, and getting the top element.

Algorithm :
1. Initialization:
• Create a MinStack instance minStack with a capacity of 5.
2. Push Operation:
• push(int element)
o Check if the stack is not full.

Enrollment No : Page | 4
 Push the element onto the stack.
o
If minStack is empty or the element is less than or equal to the current
o
minimum, push element onto minStack.
3. Pop Operation:
• pop()
o Check if the stack is not empty.
o Pop the top element from the stack.
o If the popped element is the current minimum, pop from minStack as
well.
4. Top Operation:
• top()
o Check if the stack is not empty.
o Return the top element of the stack.
5. GetMin Operation:
• getMin()
o Check if minStack is not empty.
o Return the minimum element from minStack.
6. Display Operation:
• display()
o Print "Elements in the stack:".
o Iterate over elements in the stack and print each element.
7. Main Method Execution:
• Instantiate a MinStack object with a capacity of 5.
• Push elements (3, 5, 2, 7, 1) to the stack.
• Display elements in the stack.
• Print the minimum element in the stack.
• Pop two elements from the stack.
• Print the top element in the stack.

Code :

import java.util.*;

class MinStack {
private int maxSize;
private Stack<Integer> stack;
private Stack<Integer> minStack;

public MinStack(int capacity) {

maxSize = capacity;
stack = new Stack<>();

Enrollment No : Page | 5
 minStack = new Stack<>();
}

public void push(int element) {

if (stack.size() >= maxSize) {
System.out.println("Overflow");
return;
}

stack.push(element);
if (minStack.isEmpty() || element <= minStack.peek()) {
minStack.push(element);
}
}

public void pop() {

if (stack.isEmpty()) {
System.out.println("Underflow");
return;
}

int popped = stack.pop();

if (popped == minStack.peek()) {
minStack.pop();
}
}

public int top() {

if (stack.isEmpty()) {
System.out.println("Stack is empty");
return -1;
}

return stack.peek();
}

public int getMin() {

if (minStack.isEmpty()) {
System.out.println("Stack is empty");
return -1;
}

Enrollment No : Page | 6
 return minStack.peek();
}

public void display() {

System.out.println("Elements in the stack:");
for (int i : stack) {
System.out.print(i + " ");
}
System.out.println();
}
}

public class Main {

public static void main(String[] args) {
MinStack minStack = new MinStack(5);
minStack.push(3);
minStack.push(5);
minStack.push(2);
minStack.push(7);
minStack.push(1);

minStack.display();

System.out.println("Min element in stack: " + minStack.getMin());

minStack.pop();
minStack.pop();

System.out.println("Top element in stack: " + minStack.top());

}
}

Output :

Enrollment No : Page | 7
 Practical 2

Aim : Write a program to deal with real-world situations where Stack data structure is
widely used
Evaluation of expression:
Stacks are used to evaluate expressions, especially in
languages that use postfix or prefix notation. Operators and operands are pushed
onto the stack, and operations are performed based on the LIFO principle.

Algorithm :

1. Initialize:
• Create an empty stack stack to store operands.

2. Iterate through each character in the expression string:

• Check if the character is a digit:
• If yes, convert it to an integer using Character.getNumericValue and push it onto the
stack.
• Otherwise, the character is an operator (+, -, *, /):
• Pop two operands (operand1 and operand2) from the stack.
• Perform the operation indicated by the character on the two operands.
• Push the result back onto the stack.

3. Final result:
• After iterating through all characters, the stack should contain only one element – the
final result of the expression.
• Pop this element from the stack and return it.

Additional points:
• The code assumes the expression is well-formed and uses valid operators and operands.
• The order of operations is followed using implicit order of precedence (multiplication
and division before addition and subtraction).
• Error handling for invalid expressions or division by zero is not implemented in this
specific code.
Example:

For the expression 36+9*, the algorithm works as follows:

• 3: Pushed onto the stack.

• 6: Pushed onto the stack.

Enrollment No : Page | 8
 • +: Pop 6 and 3, add them (9), and push the result back.
• 9: Pushed onto the stack.
• *: Pop 9 and 36, multiply them (324), and push the result back.
• No more characters.
• The stack now has only one element: 324.
Pop and return this element (324) as the result.

Code :

package LabQues;
import java.util.Stack;

public class ExpressionEvaluation {

public static int evaluateExpression(String expression) {
Stack<Integer> stack = new Stack<>();

for(char ch : expression.toCharArray()) {
if(Character.isDigit(ch)) {
stack.push(Character.getNumericValue(ch));
} else {
int operand2 = stack.pop();
int operand1 = stack.pop();
switch(ch) {
case '+': stack.push(operand1 + operand2); break;
case '-': stack.push(operand1 - operand2); break;
case '*': stack.push(operand1 * operand2); break;
case '/': stack.push(operand1 / operand2); break;
}
}
}

return stack.pop();
}

public static void main(String[] args) {

String expression = "36+9*";
System.out.println("Result: " + evaluateExpression(expression));
}
}

Enrollment No : Page | 9
 Output :

Enrollment No : Page | 10
 Practical 3

Aim : Write a program for finding NGE NEXT GREATER ELEMENT from an array

Algorithm :

1. Initialization:
• Create an empty stack stack to store elements.
• Create a result array result of the same size as the input array arr to store the next greater
elements.

1.Iterate through the input array in reverse order:

• For each element arr[i]:
• Pop elements from the stack until it's empty or the top element is greater than arr[i].
• If the stack becomes empty, it means there's no greater element to the right of arr[i], so
set result[i] to -1.
• Otherwise, the top element of the stack is the next greater element, so set result[i] to
stack.peek().
• Push arr[i] onto the stack.

3. Return the result array:

• The result array now contains the next greater elements for each element in the input
array.

Key points:
• The algorithm uses a stack to keep track of potential next greater elements for elements
to the left.
• It processes the array in reverse order to ensure correct NGEs are found for all elements.
• It has a time complexity of O(n) and a space complexity of O(n) due to the stack and
result array.

Code :

package LabQues;
import java.util.*;

public class NextGreaterElement {

public static int[] findNextGreaterElement(int[] arr) {

Enrollment No : Page | 11
 Stack<Integer> stack = new Stack<>();
int n = arr.length;
int[] result = new int[n];

for (int i = n - 1; i >= 0; i--) {

while (!stack.isEmpty() && stack.peek() <= arr[i]) {
stack.pop();
}

if (stack.isEmpty()) {
result[i] = -1;
} else {
result[i] = stack.peek();
}

stack.push(arr[i]);
}

return result;
}

public static void main(String[] args) {

int[] arr = {4, 3, 2, 1, 5};
int[] nge = findNextGreaterElement(arr);

System.out.println("Next Greater Elements:");

for (int i : nge) {
System.out.print(i + " ");
}
}
}

Output :

Enrollment No : Page | 12
 Practical 4
Aim : Write a program to design a circular queue(k) which Should implement the below
functions
Enqueue
Dequeue
Front
Rear

Algorithm :

This code defines a class CircularQueue that represents a circular queue data structure. Here's
a breakdown of its key components:

• Instance Variables:
o queue: An integer array to store the elements of the circular queue.
o front: An integer representing the front index of the queue.
o rear: An integer representing the rear index of the queue.
o size: An integer representing the current size of the queue.
o capacity: An integer representing the maximum capacity of the queue.
• Constructor (CircularQueue(int k)):
o Initializes the queue with a specified capacity k.
o Initializes front to 0, rear to -1, and size to 0.
• Methods:
o enQueue(int value): Adds an element to the rear of the queue.
o deQueue(): Removes an element from the front of the queue.
o Front(): Returns the element at the front of the queue without removing it.
o Rear(): Returns the element at the rear of the queue without removing it.
o isEmpty(): Checks if the queue is empty.
o isFull(): Checks if the queue is full.
• Main Method:
o Creates an instance of CircularQueue with a capacity of 5.
o Demonstrates various operations on the circular queue like enqueue, dequeue,
checking front, checking rear, etc.

Algorithm :

1. Initialization:
• Create a CircularQueue instance cq with a capacity of 5.
2. Enqueue Operation:
• enQueue(int value)

Enrollment No : Page | 13
 o Check if the queue is not full (!isFull()).
o Calculate the new rear index using circular logic.
o Place the value at the new rear index.
o Increment the size.
o Return true.
3. Dequeue Operation:
• deQueue()
o Check if the queue is not empty (!isEmpty()).
o Calculate the new front index using circular logic.
o Decrement the size.
o Return true.
4. Front Operation:
• Front()
o Check if the queue is not empty.
o Return the element at the front index.
5. Rear Operation:
• Rear()
o Check if the queue is not empty.
o Return the element at the rear index.
6. isEmpty Operation:
• isEmpty()
o Check if the size of the queue is 0.
o Return true if the queue is empty.
7. isFull Operation:
• isFull()
o Check if the size of the queue is equal to the capacity.
o Return true if the queue is full.
8. Main Method Execution:
• Instantiate a CircularQueue object with a capacity of 5.
• Perform a series of enqueuing, dequeuing, and checking operations.
• Print the results of these operations.

Code :

package LabQues;
class CircularQueue {
private int[] queue;
private int front, rear, size, capacity;

public CircularQueue(int k) {
capacity = k;

Enrollment No : Page | 14
 queue = new int[k];
front = 0;
rear = -1;
size = 0;
}

public boolean enQueue(int value) {

if (!isFull()) {
rear = (rear + 1) % capacity;
queue[rear] = value;
size++;
return true;
}
return false;
}

public boolean deQueue() {

if (!isEmpty()) {
front = (front + 1) % capacity;
size--;
return true;
}
return false;
}

public int Front() {

if (!isEmpty()) {
return queue[front];
}
return -1;
}

public int Rear() {

if (!isEmpty()) {
return queue[rear];
}
return -1;
}

public boolean isEmpty() {

return size == 0;

Enrollment No : Page | 15
 }

public boolean isFull() {

return size == capacity;
}

public static void main(String[] args) {

CircularQueue cq = new CircularQueue(5);
System.out.println(cq.enQueue(1)); // true
System.out.println(cq.enQueue(2)); // true
System.out.println(cq.enQueue(3)); // true
System.out.println(cq.Front()); // 1
System.out.println(cq.Rear()); // 3
System.out.println(cq.enQueue(4)); // true
System.out.println(cq.enQueue(5)); // true
System.out.println(cq.enQueue(6)); // false
System.out.println(cq.isFull()); // true
System.out.println(cq.deQueue()); // true
System.out.println(cq.deQueue()); // true
System.out.println(cq.Front()); // 3
System.out.println(cq.Rear()); // 5
}
}

Output :

Enrollment No : Page | 16
 Practical 5
Aim : Write a Program for an infix expression, and convert it to postfix notation. Use a
queue to implement the Shunting Yard Algorithm for expression conversion.

Algorithm :

1. Create a method named infixToPostfix that takes an infix expression as input and
returns the corresponding postfix expression.
2. Initialize an empty string postfix to store the postfix expression.
3. Create a stack operatorStack to hold operators during the conversion process.
4. Create a HashMap precedence to store the precedence of operators (+, -, *, /, ^), where
^ has the highest precedence followed by / and *, and finally + and - with the lowest
precedence.
5. Iterate through each character c in the input infix expression:
• If c is a letter or digit, add it directly to the postfix string.
• If c is an opening parenthesis (, push it onto the operatorStack.
• If c is a closing parenthesis ), pop and append operators from operatorStack
to postfix until an opening parenthesis is encountered. Pop the opening parenthesis
as well.
• If c is an operator (+, -, *, /, ^), compare its precedence with the operator at the
top of the stack. Pop and append operators with higher or equal precedence from
operatorStack to postfix before pushing c onto the stack.
6. After processing the entire input expression, pop and append any remaining operators
from operatorStack to postfix.
7. Return the postfix expression.
8. In the main method:
• Define an example infix expression a+b*(c^d-e)^(f+g*h)-i.
• Print the infix expression.
• Call the infixToPostfix method with the infix expression and print the resulting
postfix expression.
This way, the algorithm converts an infix expression to its equivalent postfix expression by
considering operator precedence and parentheses in the input expression.

Code :

package LabQues;
import java.util.*;
public class InfixToPostfix {

public static String infixToPostfix(String infix) {

Enrollment No : Page | 17
 String postfix = "";
Stack<Character> operatorStack = new Stack<>();

HashMap<Character, Integer> precedence = new HashMap<>();

precedence.put('+', 1);
precedence.put('-', 1);
precedence.put('*', 2);
precedence.put('/', 2);
precedence.put('^', 3);

for (char c : infix.toCharArray()) {

if (Character.isLetterOrDigit(c)) {
postfix += c;
} else if (c == '(') {
operatorStack.push(c);
} else if (c == ')') {
while (!operatorStack.isEmpty() && operatorStack.peek() != '(') {
postfix += operatorStack.pop();
}
operatorStack.pop(); // Pop '('
} else {
while (!operatorStack.isEmpty() && precedence.getOrDefault(c, 0) <=
precedence.getOrDefault(operatorStack.peek(), 0)) {
postfix += operatorStack.pop();
}
operatorStack.push(c);
}
}

while (!operatorStack.isEmpty()) {
postfix += operatorStack.pop();
}

return postfix;
}

public static void main(String[] args) {

String infixExpression = "a+b*(c^d-e)^(f+g*h)-i";
System.out.println("Postfix expression: " + infixToPostfix(infixExpression));
}
}

Enrollment No : Page | 18
 Output :

Enrollment No : Page | 19
 Practical 6

Aim : Write a Program for finding the Product of the three largest Distinct Elements. Use
a Priority Queue to efficiently find and remove the largest elements

Algorithms :

1. Initialize Priority Queue:

• Create a Priority Queue pq with a custom comparator to keep the elements in
descending order.
2. Insert Elements:
• Iterate over the input array nums.
• Add each element to the priority queue using the offer method.
3. Find Three Largest Elements:
• Retrieve the three largest elements from the priority queue by using
the poll method three times.
• Store them in variables largest1, largest2, and largest3.
4. Calculate Product:
• Compute the product of the three largest elements obtained.
• Multiply largest1, largest2, and largest3.
• Return the result as the product of the three largest distinct elements.
5. Main Method Execution:
• Create an array nums with integers {5, 10, 2, 8, 15, 3}.
• Call the findProductOfThreeLargest method with nums array as input.
• Display the product of the three largest distinct elements to the console.

Code :

package LabQues;
import java.util.*;
public class ThreeLargestProduct {

public static int findProductOfThreeLargest(int[] nums) {

PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

for (int num : nums) {

pq.offer(num);
}

int largest1 = pq.poll();

Enrollment No : Page | 20
 int largest2 = pq.poll();
int largest3 = pq.poll();

return largest1 * largest2 * largest3;

}

public static void main(String[] args) {

int[] nums = {5, 10, 2, 8, 15, 3};
System.out.println("Product of the three largest distinct elements: " +
findProductOfThreeLargest(nums));
}

Output :

Enrollment No : Page | 21
 Practical 7

Aim : Write a Program to Merge two linked lists(sorted)

Algorithms :

1. Node Class:
• Define a node class with integer data and a next pointer to the next node.
• Constructor to initialize the node with data.
2. Merge Two Sorted Lists:
• Create a dummy node with data 0 and l3 pointing to dummy.
• Iterate while both l1 and l2 are not null:
o Compare l1.data and l2.data.
o Connect the node with the smaller data to l3.
o Move the connected list (l1 or l2) to the next node.
o Move l3 to the connected node.
• If l1 is still remaining, connect the rest of l1 to l3.
• If l2 is still remaining, connect the rest of l2 to l3.
• Return the next node of the dummy.
3. Main Method:
• Create two sorted linked lists l1 and l2.
• Merge the two lists using the mergeTwoLists method and store the result
in dummy.
• Print the merged list data by iterating over dummy and traversing through the
nodes.
4. Output:
• Print the data of the merged linked list elements.

Code :

package LabQues;

class node
{
int data;
node next;
node(int data){
this.data = data;
}

Enrollment No : Page | 22
 }
public class MergeTwoSortedList {
public static node mergeTwoLists(node l1, node l2) {
node dummy = new node(0);
node l3 = dummy;
while (l1 != null && l2 != null) {
if (l1.data < l2.data) {
l3.next = l1;
l1 = l1.next;
} else {
l3.next = l2;
l2 = l2.next;
}
l3 = l3.next;
}
if(l1 == null){
l3.next = l2;
}
else{
l3.next = l1;
}
return dummy.next;
}
public static void main(String[] args) {
node l1 = new node(1);
l1.next = new node(2);
l1.next.next = new node(4);

node l2 = new node(1);

l2.next = new node(3);
l2.next.next = new node(4);

node dummy = mergeTwoLists(l1, l2);

while(dummy != null){
System.out.print(dummy.data + " ");
dummy = dummy.next;
}

}
}

Enrollment No : Page | 23
 Output :

Enrollment No : Page | 24
 Practical 8
Aim : Write a Program to find the Merge point of two linked lists(sorted)

Algorithms :

This Java program defines a MergePointLinkedList class that contains a method findMergePoint
which takes two linked list nodes as input and finds the merge point (intersection node) of the
two linked lists.

Here's a breakdown of the algorithm implemented:

1. Initialize two pointers, l1 and l2, pointing to the heads of the two linked lists.
2. Compare the data values of l1 and l2 nodes.
3. If l1.data is less than l2.data , move l1 to the next node.
4. If l1.data is greater than l2.data , move l2 to the next node.
5. If l1.data is equal to l2.data , it means the two linked lists intersect at this point, so return

the intersecting node.

6. Repeat steps 2-5 until l1 is equal to l2 (i.e., they point to the same node).
7. Return the node at which the two linked lists merge.
In the main method:

• Two linked lists l1 and l2 are created with intersecting node intersectNode.
• The findMergePoint method is called with l1 and l2 as arguments to find the merge
point.
• If there is a merge point, it prints the data of the merge point node; otherwise, it prints
"No Merge Point found."

Code :

package LabQues;

class Node {
int data;
Node next;

Node(int data) {
this.data = data;
}
}
Enrollment No : Page | 25
 public class MergePointLinkedList {
public static Node findMergePoint(Node l1, Node l2) {
while (l1 != l2) {
if (l1.data < l2.data) {
l1 = l1.next;
} else if (l1.data > l2.data) {
l2 = l2.next;
} else {
return l1;
}
}
return l1; // or return l2 (since they intersect at the same point)
}

public static void main(String[] args) {

Node intersectNode = new Node(8);

Node l1 = new Node(1);

l1.next = new Node(3);
l1.next.next = new Node(5);
l1.next.next.next = intersectNode;

Node l2 = new Node(2);

l2.next = new Node(4);
l2.next.next = intersectNode;

Node mergePoint = findMergePoint(l1, l2);

if (mergePoint != null) {
System.out.println("Merge Point: " + mergePoint.data);
} else {
System.out.println("No Merge Point found.");
}
}
}

Output :

Enrollment No : Page | 26
 Practical 9

Aim : Write a Program to Swap Nodes pairwise

Algorithms :

The code defines a Node class with integer data and a reference to the next node. It also includes
a SwapNodesInPairs class with two methods - swap for swapping data value of nodes in pairs
and addressSwap for swapping the nodes themselves in pairs.

1. swap(node head):
• Initialize a node l1 to the head of the list.
• Loop through the list as long as l1 and the next of l1 are not null.
• Swap the data values of l1 and l1.next.
• Move l1 two nodes ahead.
• Return the head of the list.
2. addressSwap(node head):
• Initialize l1 to the head and create a dummy node pointing to l1.
• Loop until there are at least two more nodes after point.
• Perform node swapping by adjusting the next references of nodes.
• Move point to the next pair of nodes.
• Return the modified list starting from the node after the dummy node.
3. main method:
• Create a linked list with nodes containing data 3, 5, 4, and 7.
• Call addressSwap method to swap nodes in pairs.
• Print the data of nodes in the modified list.
Here are the algorithms:

• swap(node head):
o Start from the head of the list.
o While there are at least two more nodes:
▪ Swap data values of current node and its next node.
▪ Move two nodes ahead.
o Return the head.
• addressSwap(node head):
o Start from the head and create a dummy node pointing to it.
o While there are at least two more nodes after point:
▪ Swap the next references of nodes to swap the nodes.
▪ Move to the next pair.
o Return the modified list starting from the node after the dummy.
• main method:

Enrollment No : Page | 27
 o Create a linked list with data 3, 5, 4, and 7.
o Swap nodes in pairs.
o Print the modified list data.

Code :

package LabQues;
class node{
int data;
node next;
node(int data){
this.data = data;
}
}
public class SwapNodesInPairs {

// (data swap) if ask to swap data then use this function

public static node swap(node head){
node l1 = head;
while (l1 != null && l1.next != null){
int temp = l1.data;
l1.data = l1.next.data;
l1.next.data = temp;
l1 = l1.next.next;
}
return head;
}
// (nodes swap) if ask to swap nodes then use this function
public static node addressSwap(node head){
node l1 = head;
node dummy = new node(-1);
dummy.next = l1;
node point = dummy;
while(point.next != null && point.next.next != null){
node swap1 = point.next;
node swap2 = point.next.next;
swap1.next = swap2.next;
swap2.next = swap1;
point.next = swap2;
point = swap1;
}

Enrollment No : Page | 28
 return dummy.next;
}
public static void main(String[] args){
node l1 = new node(3);
l1.next = new node(5);
l1.next.next = new node(4);
l1.next.next.next = new node(7);
node head = addressSwap(l1);

while(head != null){
System.out.print(head.data+" ");
head = head.next;
}
}
}

Output

Enrollment No : Page | 29
 Practical 10
Aim : Write a Program to Understand and implement Tree traversals i.e. Pre-Order Post-
Order, In-Order

Algorithms :

• The code defines a class TreeTraversals inside the package LabQues.

• Inside the class, there is a static nested class Node representing a node in a binary tree.
• The Node class has fields for data, left child, and right child.
• The code creates sample binary tree with 5 nodes numbered from 1 to 5.
• The code then performs three types of tree traversals: Pre-order, In-order, and Post-
order.
• Pre-order traversal visits the root node first, then the left subtree, and finally the right
subtree.
• In-order traversal visits the left subtree first, then the root node, and finally the right
subtree.
• Post-order traversal visits the left subtree first, then the right subtree, and finally the
root node.
Here are the algorithms

• Pre-order traversal: Visit the root node, then recursively traverse the left subtree and
the right subtree.
• In-order traversal: Recursively traverse the left subtree, visit the root node, and then
recursively traverse the right subtree.
• Post-order traversal: Recursively traverse the left subtree, then the right subtree, and
finally visit the root node.

Code :

package LabQues;
public class TreeTraversals {

// Node class representing a node in the tree

static class Node {
int data;
Node left, right;

Node(int data) {

Enrollment No : Page | 30
 this.data = data;
this.left = null;
this.right = null;
}
}

// Main class with tree creation and traversal methods

public static void main(String[] args) {
// Create a sample binary tree
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

// Pre-order traversal (Root -> Left -> Right)

System.out.print("Pre-order traversal: ");
preOrderTraversal(root);
System.out.println();

// In-order traversal (Left -> Root -> Right)

System.out.print("In-order traversal: ");
inOrderTraversal(root);
System.out.println();

// Post-order traversal (Left -> Right -> Root)

System.out.print("Post-order traversal: ");
postOrderTraversal(root);
System.out.println();
}

// Pre-order traversal method

public static void preOrderTraversal(Node root) {
if (root == null) {
return;
}
System.out.print(root.data + " "); // Visit root first
preOrderTraversal(root.left); // Then visit left subtree
preOrderTraversal(root.right); // Then visit right subtree
}

Enrollment No : Page | 31
 // In-order traversal method
public static void inOrderTraversal(Node root) {
if (root == null) {
return;
}
inOrderTraversal(root.left); // Visit left subtree first
System.out.print(root.data + " "); // Then visit root
inOrderTraversal(root.right); // Then visit right subtree
}

// Post-order traversal method

public static void postOrderTraversal(Node root) {
if (root == null) {
return;
}
postOrderTraversal(root.left); // Visit left subtree first
postOrderTraversal(root.right); // Then visit right subtree
System.out.print(root.data + " "); // Then visit root
}
}

Output :

Enrollment No : Page | 32
 Practical 11

Aim : Write a Program to verify and validate mirrored trees or not

Algorithms :

1. Define a Node class representing a node in a binary tree. Each node contains data and
references to its left and right child nodes.
2. Implement a method areMirror(Node root1, Node root2) to recursively check if two
trees are mirror images of each other:
• If both trees are empty (both roots are null), return true.
• If one tree is empty and the other is not, return false.
• Check if the data in the current nodes match and their subtrees are mirror images
of each other by recursively calling areMirror on the left and right child nodes.
3. In the main method:
• Create two sample binary trees with mirrored structures.
• Check if the trees are mirror images by calling the areMirror method.
• Print whether the given trees are mirrored or not based on the result.
This algorithm recursively compares the data in corresponding nodes of two trees and checks if
their left and right subtrees are mirror images of each other to determine if the trees are mirrored.

Code :

package LabQues;
public class VerifyMirroredTrees {

// Node class representing a node in the tree

static class Node {
int data;
Node left, right;

Node(int data) {
this.data = data;
this.left = null;
this.right = null;
}
}

Enrollment No : Page | 33
 // Method to check if two trees are mirror images
public static boolean areMirror(Node root1, Node root2) {
// Base case: Both trees are empty
if (root1 == null && root2 == null) {
return true;
}

// One tree is empty and the other is not

if (root1 == null || root2 == null) {
return false;
}

// Check if root data matches and subtrees are mirrors

return root1.data == root2.data &&
areMirror(root1.left, root2.right) &&
areMirror(root1.right, root2.left);
}

// Main method for creating sample trees and checking if they are mirrored
public static void main(String[] args) {
// Create mirrored trees
Node root1 = new Node(1);
root1.left = new Node(2);
root1.right = new Node(3);
root1.left.left = new Node(4);
root1.left.right = new Node(5);

Node root2 = new Node(1);

root2.left = new Node(3);
root2.right = new Node(2);
root2.right.left = new Node(5);
root2.right.right = new Node(4);

// Check if the trees are mirror images

boolean mirrored = areMirror(root1, root2);

if (mirrored) {
System.out.println("Given trees are mirrored trees.");
} else {
System.out.println("Given trees are not mirrored trees.");
}

Enrollment No : Page | 34
 }
}

Output :

Enrollment No : Page | 35
 Practical 12

Aim : Write a Program to determine the depth of a given Tree by Implementing

MAXDEPTH

Algorithms :

This Java code defines a class named TreeDepth with a nested static class Node representing a
node in a binary tree. The maxDepth method calculates the maximum depth of the binary tree
using recursion.

1. The maxDepth method takes a Node as input.

2. If the input node is null, it returns 0 (indicating an empty tree).
3. It recursively calculates the depths of the left and right subtrees by calling maxDepth on
the left and right child nodes.
4. It then returns the larger depth of the left and right subtrees plus 1 (for the current node).
5. The main method creates a sample binary tree with nodes and calculates the depth of
the tree using the maxDepth method.
In short, the algorithm recursively calculates the depth of a binary tree by finding the maximum
depth of its left and right subtrees and adding 1 for the current node.

Code :

package LabQues;

public class TreeDepth {

// Node class representing a node in the tree

static class Node {
int data;
Node left, right;

Node(int data) {
this.data = data;
this.left = null;
this.right = null;
}
}

Enrollment No : Page | 36
 // Method to calculate the maximum depth of a tree
public static int maxDepth(Node root) {
if (root == null) {
return 0; // Empty tree has depth 0
}

// Recursively find depths of left and right subtrees

int leftDepth = maxDepth(root.left);
int rightDepth = maxDepth(root.right);

// Return the larger depth + 1 (for the current node)

return Math.max(leftDepth, rightDepth) + 1;
}

// Main method for creating a sample tree and calculating its depth
public static void main(String[] args) {
// Create a sample binary tree
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

// Calculate and print the depth of the tree

int depth = maxDepth(root);
System.out.println("Depth of the tree: " + depth);
}
}

Output :

Enrollment No : Page | 37
 Practical 13
Aim : Write a program for Lowest Common Ancestors

Algorithm :

The algorithm implemented in the provided Java code for finding the Lowest Common
Ancestor (LCA) of two nodes in a binary tree is as follows:

1. Define a static nested class Node representing a node in a binary tree, with integer data,
left, and right child nodes.
2. Implement a findLCA method that takes the root of the tree and two node
values n1 and n2 as input:
• If the tree is empty or the root node matches either n1 or n2, return the current
root.
• Recursively search for n1 and n2 in the left and right subtrees.
• If both n1 and n2 are found in the left and right subtrees respectively, the current
root is the LCA.
• If only one node is found in either the left or right subtree, return that node.
3. In the main method:
• Create a sample binary tree with nodes and values.
• Find the LCA of nodes with values 4 and 7 in the tree by calling
the findLCA method.
• Print the data of the LCA node if found, else print "LCA not found."
This algorithm efficiently finds the Lowest Common Ancestor (LCA) of two nodes in a binary
tree by recursively searching for the nodes and determining the LCA based on their positions
in the tree.

Code :

package LabQues;

public class LowestCommonAncestor {

// Node class representing a node in the tree

static class Node {
int data;
Node left, right;

Node(int data) {
this.data = data;

Enrollment No : Page | 38
 this.left = null;
this.right = null;
}
}

// Method to find the Lowest Common Ancestor (LCA) of two nodes

public static Node findLCA(Node root, int n1, int n2) {
// Base case: Empty tree or root matches one of the nodes
if (root == null || root.data == n1 || root.data == n2) {
return root;
}

// Recursively search for n1 and n2 in left and right subtrees

Node leftLCA = findLCA(root.left, n1, n2);
Node rightLCA = findLCA(root.right, n1, n2);

// If both left and right subtrees found a node, then root is LCA
if (leftLCA != null && rightLCA != null) {
return root;
}

// Return the only node found (if one is in left and the other in right)
return (leftLCA != null) ? leftLCA : rightLCA;
}

// Main method to create a sample tree and find LCA

public static void main(String[] args) {
// Create a sample binary tree
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);

// Find LCA of nodes 4 and 7

int n1 = 4, n2 = 7;
Node lca = findLCA(root, n1, n2);

if (lca != null) {

Enrollment No : Page | 39
 System.out.println("LCA of " + n1 + " and " + n2 + " is: " + lca.data);
} else {
System.out.println("LCA not found.");
}
}
}

Output :

Enrollment No : Page | 40
 Practical 14
Aim : Write a Program to Build BST

Algorithm :

This Java code defines a Binary Search Tree (BST) class and a Solution class with methods to
insert nodes into the BST and perform an inorder traversal. Here are the algorithms in short:

1. BST Class:
• Data: An integer representing the data in the node.
• Left: A reference to the left child node in the BST.
• Right: A reference to the right child node in the BST.
2. Insert Method:
• Insert a new node with the given value val into the BST.
• If the root is null, create a new node with the value val.
• If the value is greater than the root's data, recursively insert into the right
subtree.
• If the value is less than or equal to the root's data, recursively insert into the left
subtree.
3. Inorder Traversal Method:
• Perform an inorder traversal of the BST (left subtree, root, right subtree).
• If the root is null, return.
• Recursively traverse the left subtree, then print the current node's data, and
finally recursively traverse the right subtree.
These algorithms work together to insert nodes into the BST in the correct order and print out
the data in sorted order using an inorder traversal.

Code :

package LabQues;

public class BST {

int data;
BST left;
BST right;

public BST(int data){

this.data= data;
}

Enrollment No : Page | 41
 }
class Solution{
public static void main(String[] args) {
BST root = null;

root = insert(root, 80);

insert(root, 60);
insert(root, 90);
insert(root, 10);
insert(root, 70);
insert(root, 85);
insert(root, 110);
inorder(root);
}
public static BST insert(BST root, int val){
if(root == null){
return new BST(val);
}
if(root.data < val){
root.right = insert(root.right, val);
}
else{
root.left = insert(root.left, val);
}
return root;
}
public static void inorder(BST root){
if(root == null){
return;
}
inorder(root.left);
System.out.print(root.data + " ");
inorder(root.right);
}
}

Output :

Enrollment No : Page | 42
 Practical 16

Aim : Write a Program to Traverse a Tree using Level Order Traversal

Algorithms :

1. Node Class Definition:

• Define a static nested class Node representing a node in a binary tree, with data,
left child, and right child attributes.
• Initialize the Node with the data provided and set left and right child to null
initially.
2. Level Order Traversal Method (levelOrderTraversal):
• Accepts the root node of the binary tree as input.
• If the root is null, return.
• Create a queue (LinkedList) to store nodes.
• Add the root node to the queue.
• While the queue is not empty:
o Dequeue the current node from the queue.
o Print the data of the current node.
o Enqueue the left and right children of the current node if they exist.
3. Main Method:
• Create a sample binary tree with nodes and connections.
• Call the levelOrderTraversal method with the root of the binary tree.
• Print the output of the level order traversal.

Code :

package LabQues;

import java.util.*;

public class LevelOrderTraversal {

// Node class representing a node in the tree

static class Node {
int data;
Node left, right;

Node(int data) {
this.data = data;

Enrollment No : Page | 43
 this.left = null;
this.right = null;
}
}

// Method to perform Level Order Traversal using a Queue

public static void levelOrderTraversal(Node root) {
if (root == null) {
return;
}

// Create a Queue to store nodes

Queue<Node> queue = new LinkedList<>();

// Add the root node to the queue

queue.add(root);

while (!queue.isEmpty()) {
// Get the current node from the queue
Node current = queue.poll();

// Print the node data

System.out.print(current.data + " ");

// Add children to the queue (if any)

if (current.left != null) {
queue.add(current.left);
}
if (current.right != null) {
queue.add(current.right);
}
}
}

// Main method for creating a sample tree and performing traversal

public static void main(String[] args) {
// Create a sample binary tree
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);

Enrollment No : Page | 44
 root.left.right = new Node(5);

// Perform Level Order Traversal

System.out.print("Level Order Traversal: ");
levelOrderTraversal(root);
System.out.println();
}
}

Output :

Enrollment No : Page | 45
 Practical 18
Aim : Write a Program to view a tree from left View

Algorithms :

1. Node Class Definition:

• Define a static nested class Node representing a node in a binary tree, with data,
left child, and right child attributes.
• Initialize the node with the provided data and set left and right children to null
initially.
2. Left View Utility Function (leftViewUtil):
• Accepts the current node, current level, and an array containing the maximum
level visited so far as inputs.
• If the current node is null, return.
• Compare the current level with the maxLevel stored in the array:
o If the current level is greater, print the data of the current node and
update the maxLevel.
• Recursively call the function for the left child incrementing the level by 1 and
passing the updated maxLevel.
• Recursively call the function for the right child incrementing the level by 1 and
passing the updated maxLevel.
3. Left View Function:
• Accepts the root node of the binary tree as input.
• Initialize an array maxLevel to keep track of the maximum level visited.
• Call the leftViewUtil function starting from level 1 and passing the root node
and the maxLevel array.
4. Main Method:
• Create a sample binary tree with nodes and connections.
• Call the leftView function with the root of the binary tree.
• Print the output as the left view of the binary tree.

Code :

package LabQues;

public class LeftView {

static class Node {

int data;

Enrollment No : Page | 46
 Node left, right;

Node(int data) {
this.data = data;
this.left = null;
this.right = null;
}
}

// Recursive function to print the left view of a binary tree

static void leftViewUtil(Node root, int level, int[] maxLevel) {
if (root == null) {
return;
}

if (level > maxLevel[0]) {

System.out.print(root.data + " ");
maxLevel[0] = level;
}

leftViewUtil(root.left, level + 1, maxLevel);

leftViewUtil(root.right, level + 1, maxLevel);
}

// Function to print the left view of a binary tree

static void leftView(Node root) {
int[] maxLevel = {0}; // Keep track of the maximum level visited so far
leftViewUtil(root, 1, maxLevel);
}

public static void main(String[] args) {

Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

System.out.print("Left view of the tree: ");

leftView(root);
}
}

Enrollment No : Page | 47
 Output :

Enrollment No : Page | 48