0% found this document useful (0 votes)

6 views41 pages

ADS With Java Lab Record

The document contains Java programs for various linked list operations including singly linked lists, doubly linked lists, circular linked lists, and stack operations using linked lists. Each section outlines specific functionalities such as insertion, deletion, searching, displaying, and merging lists, along with sample outputs. The programs are structured with user interaction through a menu-driven approach to perform the desired operations.

Uploaded by

Rohan Roxx

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

6 views41 pages

ADS With Java Lab Record

Uploaded by

Rohan Roxx

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

EXPERIMENT–1

Write a java program to perform various operations on single linked list

Operations
1. Insert at Beginning
2. Insert at End
3. Delete by Value
4. Search
5. Display
6. Exit
Program: [Link]
import [Link];

class SinglyLinkedList {

class Node {
int data;
Node next;

Node(int data) {
[Link] = data;
next = null;
}
}

Node head = null;

// Insert at beginning
void insertBeg(int data) {
Node newNode = new Node(data);
[Link] = head;
head = newNode;
[Link]("Inserted Successfully!");
}

// Insert at end
void insertEnd(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
Node temp = head;
while ([Link] != null)
temp = [Link];
[Link] = newNode;
}
[Link]("Inserted Successfully!");
}

// Delete element
1
void delete(int key) {
Node temp = head, prev = null;

if (temp != null && [Link] == key) {

head = [Link];
[Link]("Deleted Successfully!");
return;
}

while (temp != null && [Link] != key) {

prev = temp;
temp = [Link];
}

if (temp == null) {
[Link]("Element Not Found!");
return;
}

[Link] = [Link];
[Link]("Deleted Successfully!");
}

// Search element
void search(int key) {
Node temp = head;
int pos = 1;

while (temp != null) {

if ([Link] == key) {
[Link]("Element found at position: " + pos);
return;
}
temp = [Link];
pos++;
}
[Link]("Element Not Found!");
}

// Display list
void display() {
if (head == null) {
[Link]("List is Empty!");
return;
}

Node temp = head;

[Link]("Linked List: ");
while (temp != null) {
2
[Link]([Link] + " -> ");
temp = [Link];
}
[Link]("NULL");
}

// Main Method
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
SinglyLinkedList list = new SinglyLinkedList();
int choice, data;

do {
[Link]("\n--- SINGLY LINKED LIST MENU ---");
[Link]("1. Insert at Beginning");
[Link]("2. Insert at End");
[Link]("3. Delete");
[Link]("4. Search");
[Link]("5. Display");
[Link]("6. Exit");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;

case 2:
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;

case 3:
[Link]("Enter Element to Delete: ");
data = [Link]();
[Link](data);
break;

case 4:
[Link]("Enter Element to Search: ");
data = [Link]();
[Link](data);
break;

3
case 5:
[Link]();
break;

case 6:
[Link]("Exiting...");
break;

default:
[Link]("Invalid Choice!");
}

} while (choice != 6);

}
}
Sample Output
--- SINGLY LINKED LIST MENU ---
1. Insert at Beginning
2. Insert at End
3. Delete
4. Search
5. Display
6. Exit
Enter Choice: 1
Enter Data: 10
Inserted Successfully!

Enter Choice: 2
Enter Data: 20
Inserted Successfully!

Enter Choice: 5
Linked List: 10 -> 20 -> NULL

Enter Choice: 4
Enter Element to Search: 20
Element found at position: 2

Enter Choice: 3
Enter Element to Delete: 10
Deleted Successfully!

Enter Choice: 5
Linked List: 20 -> NULL

4
EXPERIMENT–2
Write a java program for the following
a) Reverse a linked list b) Sort the data in a linked list c) Remove duplicates d)
Merge two linked lists

import [Link];

class ReverseList {

static class Node {

int data;
Node next;
Node(int d) { data = d; }
}

static Node head = null;

static void insert(int d) {

Node n = new Node(d);
if (head == null)
head = n;
else {
Node t = head;
while ([Link] != null)
t = [Link];
[Link] = n;
}
}

static void reverse() {

Node prev = null, curr = head, next;
while (curr != null) {
next = [Link];
[Link] = prev;
prev = curr;
curr = next;
}
head = prev;
}

static void display() {

Node t = head;
while (t != null) {
[Link]([Link] + " ");
t = [Link];
}
[Link]();
}

5
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n, val;

[Link]("Enter number of nodes: ");

n = [Link]();

for (int i = 0; i < n; i++) {

[Link]("Enter value: ");
val = [Link]();
insert(val);
}

[Link]("Original List: ");

display();

reverse();

EXPERIMENT–2(b)
import [Link].*;

class SortList {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
LinkedList<Integer> list = new LinkedList<>();

[Link]("Enter number of elements: ");

int n = [Link]();

for (int i = 0; i < n; i++) {

[Link]("Enter value: ");
[Link]([Link]());
}

[Link](list);
[Link]("Sorted List: " + list);
6
}
}

Sample Output
Enter number of elements: 5
Enter value: 40
Enter value: 10
Enter value: 30
Enter value: 20
Enter value: 50
Sorted List: [10, 20, 30, 40, 50]

EXPERIMENT–2(c)
Remove Duplicates
import [Link].*;

class RemoveDuplicates {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
LinkedHashSet<Integer> set = new LinkedHashSet<>();

[Link]("Enter number of elements: ");

int n = [Link]();

for (int i = 0; i < n; i++) {

[Link]([Link]());
}

[Link]("After Removing Duplicates: " + set);

}
}
Sample Output
Enter number of elements: 6
10 20 10 30 20 40
After Removing Duplicates: [10, 20, 30, 40]

EXPERIMENT–2(d)
Merge Two Linked Lists
import [Link].*;

class MergeLists {
public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

LinkedList<Integer> list1 = new LinkedList<>();
LinkedList<Integer> list2 = new LinkedList<>();

[Link]("Enter size of List1: ");

7
int n1 = [Link]();
for (int i = 0; i < n1; i++)
[Link]([Link]());

[Link]("Enter size of List2: ");

int n2 = [Link]();
for (int i = 0; i < n2; i++)
[Link]([Link]());

[Link](list2);
[Link](list1);

[Link]("Merged List: " + list1);

}
}

Output
Enter size of List1: 3
10 30 50
Enter size of List2: 3
20 40 60
Merged List: [10, 20, 30, 40, 50, 60]

8
EXPERIMENT–3
Write a java program to perform various operations on doubly linked list.
Operations
1. Insert at Beginning
2. Insert at End
3. Delete
4. Display Forward
5. Display Reverse
6. Exit
Program: [Link]
import [Link];

class DoublyLinkedList {

class Node {
int data;
Node prev, next;

Node(int d) {
data = d;
prev = next = null;
}
}

Node head = null;

// Insert at beginning
void insertBeg(int data) {
Node newNode = new Node(data);
if (head != null)
[Link] = newNode;
[Link] = head;
head = newNode;
[Link]("Inserted Successfully!");
}

// Insert at end
void insertEnd(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node temp = head;
while ([Link] != null)
temp = [Link];
[Link] = newNode;
[Link] = temp;
9
[Link]("Inserted Successfully!");
}

// Delete element
void delete(int key) {
Node temp = head;

while (temp != null && [Link] != key)

temp = [Link];

if (temp == null) {
[Link]("Element Not Found!");
return;
}

if ([Link] != null)
[Link] = [Link];
else
head = [Link];

if ([Link] != null)
[Link] = [Link];

[Link]("Deleted Successfully!");
}

// Display forward
void displayForward() {
Node temp = head;
[Link]("List Forward: ");
while (temp != null) {
[Link]([Link] + " ");
temp = [Link];
}
[Link]();
}

// Display reverse
void displayReverse() {
Node temp = head;
if (temp == null) return;

while ([Link] != null)

temp = [Link];

[Link]("List Reverse: ");

while (temp != null) {
[Link]([Link] + " ");
temp = [Link];
10
}
[Link]();
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

DoublyLinkedList list = new DoublyLinkedList();
int choice, data;

do {
[Link]("\n--- DOUBLY LINKED LIST MENU ---");
[Link]("[Link] Beginning");
[Link]("[Link] End");
[Link]("[Link]");
[Link]("[Link] Forward");
[Link]("[Link] Reverse");
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;
case 2:
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;
case 3:
[Link]("Enter Element to Delete: ");
data = [Link]();
[Link](data);
break;
case 4:
[Link]();
break;
case 5:
[Link]();
break;
case 6:
[Link]("Exiting...");
break;
default:
[Link]("Invalid Choice!");
11
}

} while (choice != 6);

}
}

Output :
Enter Choice: 1
Enter Data: 10
Inserted Successfully!

Enter Choice: 2
Enter Data: 20
Inserted Successfully!

Enter Choice: 4
List Forward: 10 20

Enter Choice: 5
List Reverse: 20 10

12
EXPERIMENT–4
Write a java program to perform various operations on circular linked list.
Operations
1. Insert
2. Delete
3. Display
4. Exit
Program: [Link]
import [Link];

class CircularLinkedList {

class Node {
int data;
Node next;

Node(int d) {
data = d;
next = null;
}
}

Node last = null;

// Insert
void insert(int data) {
Node newNode = new Node(data);

if (last == null) {
last = newNode;
[Link] = last;
} else {
[Link] = [Link];
[Link] = newNode;
last = newNode;
}
[Link]("Inserted Successfully!");
}

// Delete
void delete(int key) {
if (last == null) {
[Link]("List Empty!");
return;
}

[Link]("Element Not Found!");

}

// Display
void display() {
if (last == null) {
[Link]("List Empty!");
return;
}

Node temp = [Link];

[Link]("Circular List: ");
do {
[Link]([Link] + " ");
temp = [Link];
} while (temp != [Link]);
[Link]();
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

CircularLinkedList list = new CircularLinkedList();
int choice, data;

do {
[Link]("\n--- CIRCULAR LINKED LIST MENU ---");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
14
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;
case 2:
[Link]("Enter Element to Delete: ");
data = [Link]();
[Link](data);
break;
case 3:
[Link]();
break;
case 4:
[Link]("Exiting...");
break;
default:
[Link]("Invalid Choice!");
}

} while (choice != 4);

}
}

Output :
Enter Choice: 1
Enter Data: 10
Inserted Successfully!

Enter Choice: 1
Enter Data: 20
Inserted Successfully!

Enter Choice: 3
Circular List: 10 20

15
EXPERIMENT–5

Write a java program for performing various operations on stack using linked list.
Operations
1. Push
2. Pop
3. Peek
4. Display
5. Exit
Program: [Link]
import [Link];

class StackUsingLinkedList {

class Node {
int data;
Node next;

Node(int d) {
data = d;
next = null;
}
}

Node top = null;

// Push
void push(int data) {
Node newNode = new Node(data);
[Link] = top;
top = newNode;
[Link]("Pushed Successfully!");
}

// Pop
void pop() {
if (top == null) {
[Link]("Stack Underflow!");
return;
}
[Link]("Popped Element: " + [Link]);
top = [Link];
}

// Peek
void peek() {
if (top == null)
[Link]("Stack Empty!");
else
16
[Link]("Top Element: " + [Link]);
}

// Display
void display() {
if (top == null) {
[Link]("Stack Empty!");
return;
}

Node temp = top;

[Link]("Stack: ");
while (temp != null) {
[Link]([Link] + " ");
temp = [Link];
}
[Link]();
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

StackUsingLinkedList s = new StackUsingLinkedList();
int choice, data;

do {
[Link]("\n--- STACK MENU ---");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;
case 2:
[Link]();
break;
case 3:
[Link]();
break;
case 4:
17
[Link]();
break;
case 5:
[Link]("Exiting...");
break;
default:
[Link]("Invalid Choice!");
}

} while (choice != 5);

}
}

Output :
Enter Choice: 1
Enter Data: 10
Pushed Successfully!

Enter Choice: 1
Enter Data: 20
Pushed Successfully!

Enter Choice: 4
Stack: 20 10

Enter Choice: 2
Popped Element: 20

Enter Choice: 3
Top Element: 10

18
EXPERIMENT–6
Write a java program for performing various operations on queue using linked list.
Operations
1. Enqueue
2. Dequeue
3. Front
4. Display
5. Exit
Program: [Link]
import [Link];

class QueueUsingLinkedList {

class Node {
int data;
Node next;

Node(int d) {
data = d;
next = null;
}
}

Node front = null, rear = null;

void enqueue(int data) {

Node newNode = new Node(data);

if (rear == null) {
front = rear = newNode;
} else {
[Link] = newNode;
rear = newNode;
}
[Link]("Enqueued Successfully!");
}

void dequeue() {
if (front == null) {
[Link]("Queue Underflow!");
return;
}
[Link]("Dequeued Element: " + [Link]);
front = [Link];
if (front == null)
rear = null;
}

void peek() {
19
if (front == null)
[Link]("Queue Empty!");
else
[Link]("Front Element: " + [Link]);
}

void display() {
if (front == null) {
[Link]("Queue Empty!");
return;
}

Node temp = front;

[Link]("Queue: ");
while (temp != null) {
[Link]([Link] + " ");
temp = [Link];
}
[Link]();
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

QueueUsingLinkedList q = new QueueUsingLinkedList();
int choice, data;

do {
[Link]("\n--- QUEUE MENU ---");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link](data);
break;
case 2:
[Link]();
break;
case 3:
[Link]();
20
break;
case 4:
[Link]();
break;
case 5:
[Link]("Exiting...");
break;
default:
[Link]("Invalid Choice!");
}

} while (choice != 5);

}
}

Output:
Enter Choice: 1
Enter Data: 10
Enqueued Successfully!

Enter Choice: 1
Enter Data: 20
Enqueued Successfully!

Enter Choice: 4
Queue: 10 20

Enter Choice: 2
Dequeued Element: 10

Enter Choice: 3
Front Element: 20

21
EXPERIMENT–7
Write a java program for the following using stack
a) Infix to postfix conversion.
b) Expression evaluation.
c) Obtain the binary number for a given decimal number.
a) Infix to Postfix Conversion Program

import [Link].*;

class InfixToPostfix {

static int precedence(char c) {

if (c == '+' || c == '-') return 1;
if (c == '*' || c == '/') return 2;
return 0;
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
Stack<Character> stack = new Stack<>();
String postfix = "";

[Link]("Enter Infix Expression: ");

String infix = [Link]();

while (![Link]())
postfix += [Link]();

[Link]("Postfix Expression: " + postfix);

}
}

Output
Enter Infix Expression: A+B*C
Postfix Expression: ABC*+

22
b) Postfix Expression Evaluation
import [Link].*;

class PostfixEvaluation {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

Stack<Integer> stack = new Stack<>();

[Link]("Enter Postfix Expression: ");

String exp = [Link]();

[Link]("Result: " + [Link]());

}
}

Output :
Enter Postfix Expression: 23*
Result: 6

C) Decimal to Binary using Stack

import [Link].*;

class DecimalToBinary {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

Stack<Integer> stack = new Stack<>();

23
[Link]("Enter Decimal Number: ");
int num = [Link]();

while (num > 0) {

[Link](num % 2);
num = num / 2;
}

[Link]("Binary: ");
while (![Link]())
[Link]([Link]());
}
}

Output :
Enter Decimal Number: 10
Binary: 1010

24
EXPERIMENT–8
Write a java program to implement various operations on Binary Search Tree Using Recursive and
Non-Recursive methods.

import [Link];

class BST {

class Node {
int data;
Node left, right;
Node(int d) { data = d; }
}

Node root = null;

Node insert(Node root, int data) {

if (root == null)
return new Node(data);

if (data < [Link])

[Link] = insert([Link], data);
else
[Link] = insert([Link], data);

return root;
}

boolean search(Node root, int key) {

if (root == null) return false;
if ([Link] == key) return true;
if (key < [Link])
return search([Link], key);
else
return search([Link], key);
}

void inorder(Node root) {

if (root != null) {
inorder([Link]);
[Link]([Link] + " ");
inorder([Link]);
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

BST tree = new BST();
25
int choice, data;

do {
[Link]("\n--- BST MENU ---");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link] Traversal");
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link] = [Link]([Link], data);
break;
case 2:
[Link]("Enter Key: ");
data = [Link]();
if ([Link]([Link], data))
[Link]("Element Found!");
else
[Link]("Element Not Found!");
break;
case 3:
[Link]([Link]);
[Link]();
break;
case 4:
[Link]("Exiting...");
break;
}
} while (choice != 4);
}
}

Output :
Enter Choice: 1
Enter Data: 50
Enter Choice: 1
Enter Data: 30
Enter Choice: 1
Enter Data: 70
Enter Choice: 3
30 50 70

26
EXPERIMENT–9
Write a java program to implement the following for a graph. a) BFS b) DFS

import [Link].*;

class Graph {

int V;
LinkedList<Integer>[] adj;

Graph(int v) {
V = v;
adj = new LinkedList[v];
for (int i = 0; i < v; i++)
adj[i] = new LinkedList<>();
}

void addEdge(int u, int v) {

adj[u].add(v);
}

void BFS(int s) {
boolean[] visited = new boolean[V];
Queue<Integer> q = new LinkedList<>();
visited[s] = true;
[Link](s);

while (![Link]()) {
s = [Link]();
[Link](s + " ");
for (int n : adj[s]) {
if (!visited[n]) {
visited[n] = true;
[Link](n);
}
}
}
[Link]();
}

void DFS(int s) {
boolean[] visited = new boolean[V];
DFSUtil(s, visited);
[Link]();
}

void DFSUtil(int v, boolean[] visited) {

visited[v] = true;
[Link](v + " ");
27
for (int n : adj[v]) {
if (!visited[n])
DFSUtil(n, visited);
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter number of vertices: ");
int v = [Link]();

Graph g = new Graph(v);

[Link]("Enter number of edges: ");

int e = [Link]();

for (int i = 0; i < e; i++) {

int u = [Link]();
int w = [Link]();
[Link](u, w);
}

[Link]("Enter starting vertex: ");

int start = [Link]();

[Link]("BFS: ");
[Link](start);

[Link]("DFS: ");
[Link](start);
}
}

Output :
Enter number of vertices: 4
Enter number of edges: 3
01
02
13
Enter starting vertex: 0
BFS: 0 1 2 3
DFS: 0 1 3 2

28
EXPERIMENT–10

Write a java program to implement Merge & Heap Sort of given elements

import [Link];

class MergeSort {

void merge(int a[], int l, int m, int r) {

int n1 = m - l + 1;
int n2 = r - m;

int L[] = new int[n1];

int R[] = new int[n2];

for (int i = 0; i < n1; i++)

L[i] = a[l + i];
for (int j = 0; j < n2; j++)
R[j] = a[m + 1 + j];

int i = 0, j = 0, k = l;

while (i < n1 && j < n2) {

if (L[i] <= R[j])
a[k++] = L[i++];
else
a[k++] = R[j++];
}

while (i < n1)

a[k++] = L[i++];

while (j < n2)

a[k++] = R[j++];
}

void sort(int a[], int l, int r) {

if (l < r) {
int m = (l + r) / 2;
sort(a, l, m);
sort(a, m + 1, r);
merge(a, l, m, r);
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

MergeSort ms = new MergeSort();
29
[Link]("Enter number of elements: ");
int n = [Link]();

int a[] = new int[n];

for (int i = 0; i < n; i++)
a[i] = [Link]();

[Link](a, 0, n - 1);

[Link]("Sorted Array: ");

for (int x : a)
[Link](x + " ");
}
}

Sample Output
Enter number of elements: 5
53142
Sorted Array: 1 2 3 4 5

30
EXPERIMENT–11

Write a java program to implement Quick Sort of given elements.

Program: [Link]
import [Link];

class QuickSort {

int partition(int a[], int low, int high) {

int pivot = a[high];
int i = low - 1;

for (int j = low; j < high; j++) {

if (a[j] <= pivot) {
i++;
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}

int temp = a[i + 1];

a[i + 1] = a[high];
a[high] = temp;

return i + 1;
}

void sort(int a[], int low, int high) {

if (low < high) {
int pi = partition(a, low, high);
sort(a, low, pi - 1);
sort(a, pi + 1, high);
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

QuickSort qs = new QuickSort();

[Link]("Enter number of elements: ");

int n = [Link]();

int a[] = new int[n];

for (int i = 0; i < n; i++)
a[i] = [Link]();

[Link](a, 0, n - 1);
31
[Link]("Sorted Array: ");
for (int x : a)
[Link](x + " ");
}
}

Output
Enter number of elements: 5
94162
Sorted Array: 1 2 4 6 9

32
EXPERIMENT–12
Write a java program to implement various operations on AVL trees.

Program: [Link]
import [Link];

class AVLTree {

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

Node(int d) {
data = d;
height = 1;
}
}

Node root = null;

int height(Node n) {
return (n == null) ? 0 : [Link];
}

int getBalance(Node n) {
return (n == null) ? 0 : height([Link]) - height([Link]);
}

Node rightRotate(Node y) {
Node x = [Link];
Node t = [Link];

[Link] = y;
[Link] = t;

[Link] = [Link](height([Link]), height([Link])) + 1;

return x;
}

Node leftRotate(Node x) {
Node y = [Link];
Node t = [Link];

[Link] = x;
[Link] = t;

[Link] = [Link](height([Link]), height([Link])) + 1;

33
[Link] = [Link](height([Link]), height([Link])) + 1;

return y;
}

Node insert(Node node, int key) {

if (node == null)
return new Node(key);

if (key < [Link])

[Link] = insert([Link], key);
else if (key > [Link])
[Link] = insert([Link], key);
else
return node;

[Link] = 1 + [Link](height([Link]), height([Link]));

int balance = getBalance(node);

// LL
if (balance > 1 && key < [Link])
return rightRotate(node);

// RR
if (balance < -1 && key > [Link])
return leftRotate(node);

// LR
if (balance > 1 && key > [Link]) {
[Link] = leftRotate([Link]);
return rightRotate(node);
}

// RL
if (balance < -1 && key < [Link]) {
[Link] = rightRotate([Link]);
return leftRotate(node);
}

return node;
}

void inorder(Node root) {

if (root != null) {
inorder([Link]);
[Link]([Link] + " ");
inorder([Link]);
34
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

AVLTree tree = new AVLTree();
int choice, data;

do {
[Link]("\[Link]");
[Link]("[Link] Inorder");
[Link]("[Link]");
[Link]("Enter Choice: ");
choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link] = [Link]([Link], data);
break;
case 2:
[Link]([Link]);
[Link]();
break;
case 3:
[Link]("Exiting...");
}
} while (choice != 3);
}
}

Output :
Enter Choice: 1
Enter Data: 30
Enter Choice: 1
Enter Data: 20
Enter Choice: 1
Enter Data: 10
Enter Choice: 2
10 20 30

35
EXPERIMENT–13
Write a java program to perform the following operations: a) Insertion into a B-tree b) Searching in a
B-tree
Program: [Link]
import [Link];

class BTree {

class Node {
int data;
Node left, right;

Node(int d) {
data = d;
}
}

Node root = null;

Node insert(Node root, int data) {

if (root == null)
return new Node(data);

if (data < [Link])

[Link] = insert([Link], data);
else
[Link] = insert([Link], data);

return root;
}

boolean search(Node root, int key) {

if (root == null) return false;
if ([Link] == key) return true;
if (key < [Link])
return search([Link], key);
else
return search([Link], key);
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

BTree tree = new BTree();
int choice, data;

do {
[Link]("\[Link]");
[Link]("[Link]");
36
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();

switch (choice) {
case 1:
[Link]("Enter Data: ");
data = [Link]();
[Link] = [Link]([Link], data);
break;

case 2:
[Link]("Enter Key: ");
data = [Link]();
if ([Link]([Link], data))
[Link]("Element Found!");
else
[Link]("Element Not Found!");
break;
}

} while (choice != 3);

}
}

✅Sample Output
Enter Choice: 1
Enter Data: 40
Enter Choice: 1
Enter Data: 20
Enter Choice: 2
Enter Key: 20
Element Found!

37
EXPERIMENT–14
Write a java program to implementation of recursive and non-recursive functions to Binary tree
Traversals
Program: [Link]
import [Link].*;

class TreeTraversal {

static class Node {

int data;
Node left, right;
Node(int d) { data = d; }
}

static void inorder(Node r) {

if (r != null) {
inorder([Link]);
[Link]([Link] + " ");
inorder([Link]);
}
}

static void inorderNR(Node root) {

Stack<Node> s = new Stack<>();
Node curr = root;

public static void main(String[] args) {

Node root = new Node(1);

[Link] = new Node(2);
[Link] = new Node(3);

[Link]("Recursive Inorder: ");

inorder(root);

[Link]("\nNon Recursive Inorder: ");

inorderNR(root);
}
38
}

Output
Recursive Inorder: 2 1 3
Non Recursive Inorder: 2 1 3

39
EXPERIMENT–15
Write a java program to implement all the functions of Dictionary (ADT) using Hashing hi dear
kindly provide Solutions for the above programs along with Sample outputs

Program: [Link]
import [Link].*;

class DictionaryHash {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

HashMap<String, String> dict = new HashMap<>();
int choice;

do {
[Link]("\[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
[Link]("Enter Choice: ");

choice = [Link]();
[Link]();

switch (choice) {

case 1:
[Link]("Enter Key: ");
String k = [Link]();
[Link]("Enter Value: ");
String v = [Link]();
[Link](k, v);
break;

case 2:
[Link]("Enter Key to Search: ");
k = [Link]();
[Link]("Value: " + [Link](k));
break;

case 3:
[Link](dict);
break;
}

} while (choice != 4);

}
}
40
Output
Enter Choice: 1
Enter Key: Apple
Enter Value: Fruit

Enter Choice: 2
Enter Key to Search: Apple
Value: Fruit

Singly Linked List ADT Implementation
No ratings yet
Singly Linked List ADT Implementation
7 pages
Day 6
No ratings yet
Day 6
96 pages
Lab Task - 2
No ratings yet
Lab Task - 2
19 pages
DSAA Lab Manual-M
No ratings yet
DSAA Lab Manual-M
54 pages
Java Linked List Operations Lab Manual
No ratings yet
Java Linked List Operations Lab Manual
61 pages
Dsa Lab Manual M.tech r25 Cse
No ratings yet
Dsa Lab Manual M.tech r25 Cse
61 pages
DSA Lab6
No ratings yet
DSA Lab6
16 pages
Java Linked List and BST Operations
No ratings yet
Java Linked List and BST Operations
7 pages
Java File Handling and Linked List Program
No ratings yet
Java File Handling and Linked List Program
22 pages
Assignment 5
No ratings yet
Assignment 5
11 pages
Stack, Queue, and Linked List in Java
No ratings yet
Stack, Queue, and Linked List in Java
15 pages
Linked List Operations in Java
No ratings yet
Linked List Operations in Java
23 pages
ADS MTech Lab Manual 2020-21
No ratings yet
ADS MTech Lab Manual 2020-21
104 pages
Linked List Operations and Examples
No ratings yet
Linked List Operations and Examples
12 pages
Week 13 - S13 - Lab Problem
No ratings yet
Week 13 - S13 - Lab Problem
12 pages
Linked List Operations in Java
No ratings yet
Linked List Operations in Java
29 pages
ADSA Lab Manual
No ratings yet
ADSA Lab Manual
51 pages
Java Singly Linked List Operations
No ratings yet
Java Singly Linked List Operations
3 pages
Data Structures Alogorithm & Analysis Lab
No ratings yet
Data Structures Alogorithm & Analysis Lab
79 pages
Java Recursion: Linear Search Example
No ratings yet
Java Recursion: Linear Search Example
53 pages
Cse11 (Datastructuresalgorithm Lab)
No ratings yet
Cse11 (Datastructuresalgorithm Lab)
58 pages
Adsa Lab Manual Final
No ratings yet
Adsa Lab Manual Final
43 pages
Linked List Operations in Java
No ratings yet
Linked List Operations in Java
7 pages
Circular Linked List ADT Explained
No ratings yet
Circular Linked List ADT Explained
11 pages
Doubly Linked List Implementation in Java
No ratings yet
Doubly Linked List Implementation in Java
5 pages
Gmailkjjkjfkfdfjdkffffffffffffffffff - DSA 10
No ratings yet
Gmailkjjkjfkfdfjdkffffffffffffffffff - DSA 10
4 pages
Java Linked List and Priority Queue
No ratings yet
Java Linked List and Priority Queue
8 pages
Linked List Operations in Java
No ratings yet
Linked List Operations in Java
8 pages
Java Programming Examples and Solutions
67% (3)
Java Programming Examples and Solutions
67 pages
Linked List
No ratings yet
Linked List
3 pages
Java Linked List Operations Guide
No ratings yet
Java Linked List Operations Guide
7 pages
Java Data Structures Guide
No ratings yet
Java Data Structures Guide
87 pages
Linked List
No ratings yet
Linked List
15 pages
Linked List and Sorting Algorithms Guide
No ratings yet
Linked List and Sorting Algorithms Guide
11 pages
DS Record Programs
No ratings yet
DS Record Programs
63 pages
Java OOP Data Structures Examples
No ratings yet
Java OOP Data Structures Examples
9 pages
Linked List Operations in Java
No ratings yet
Linked List Operations in Java
7 pages
Understanding Linked Lists in Java
No ratings yet
Understanding Linked Lists in Java
27 pages
Java List ADT Implementation Guide
No ratings yet
Java List ADT Implementation Guide
56 pages
Doubly Linked List
No ratings yet
Doubly Linked List
14 pages
Prime Factorization with Linked Lists
No ratings yet
Prime Factorization with Linked Lists
18 pages
Linked List and Stack Operations Code
No ratings yet
Linked List and Stack Operations Code
22 pages
Complete DS Lab Java Programs
No ratings yet
Complete DS Lab Java Programs
12 pages
Linked List Implementation in Java
No ratings yet
Linked List Implementation in Java
11 pages
Java Single Linked List Operations
No ratings yet
Java Single Linked List Operations
7 pages
Java Linked List Implementation Guide
No ratings yet
Java Linked List Implementation Guide
3 pages
Java Operations on Singly Linked List
No ratings yet
Java Operations on Singly Linked List
12 pages
Dsa 3
No ratings yet
Dsa 3
4 pages
Data Structure & Algorithm - I MSC Cs (Pdf2)
No ratings yet
Data Structure & Algorithm - I MSC Cs (Pdf2)
67 pages
Java Linked List Implementation Guide
No ratings yet
Java Linked List Implementation Guide
26 pages
Data Structures & Algorithms Assignment
No ratings yet
Data Structures & Algorithms Assignment
21 pages
Java LinkedList Implementation Guide
No ratings yet
Java LinkedList Implementation Guide
5 pages
Java Linked List Implementation Guide
No ratings yet
Java Linked List Implementation Guide
11 pages
M.Tech MFCS Unit-5
No ratings yet
M.Tech MFCS Unit-5
60 pages
MATHS
No ratings yet
MATHS
3 pages
Mock Test-04 QP & Sol
No ratings yet
Mock Test-04 QP & Sol
24 pages
NSRIT MTECH Syllabus
No ratings yet
NSRIT MTECH Syllabus
47 pages
Bda Sample Mid QP
No ratings yet
Bda Sample Mid QP
1 page
CN Remaining Experiments
No ratings yet
CN Remaining Experiments
18 pages
Class X Second Language Model Paper
No ratings yet
Class X Second Language Model Paper
4 pages
Mathematics Unit Test Questions
No ratings yet
Mathematics Unit Test Questions
13 pages
NEET Biology Unit Test 1 Questions
No ratings yet
NEET Biology Unit Test 1 Questions
5 pages
Class X Biological Science Model Paper
No ratings yet
Class X Biological Science Model Paper
4 pages
Class X English Self Assessment Paper
No ratings yet
Class X English Self Assessment Paper
4 pages
Understanding Inequalities and Functions
No ratings yet
Understanding Inequalities and Functions
2 pages
Visitor Data for TV9 Education Expo 2025
No ratings yet
Visitor Data for TV9 Education Expo 2025
2 pages
1st Year Mathematics Important Questions
No ratings yet
1st Year Mathematics Important Questions
18 pages
ICSE Biology 2026: Sense Organs Guide
No ratings yet
ICSE Biology 2026: Sense Organs Guide
2 pages
Static Equipment Reliability Engineer Role
No ratings yet
Static Equipment Reliability Engineer Role
2 pages
Team Formation in Entrepreneurship
No ratings yet
Team Formation in Entrepreneurship
2 pages
Aircraft Wing Design Overview
100% (1)
Aircraft Wing Design Overview
159 pages
Peirce's Truth Table Analysis Explained
No ratings yet
Peirce's Truth Table Analysis Explained
13 pages
Smart Manufacturing Survey in India
No ratings yet
Smart Manufacturing Survey in India
17 pages
Joule-Thomson Effect Explained
No ratings yet
Joule-Thomson Effect Explained
11 pages
Understanding Timers and Interrupts
No ratings yet
Understanding Timers and Interrupts
8 pages
00000653
No ratings yet
00000653
12 pages
Pages 52 Vs Mini J7 Series YASKAWA
No ratings yet
Pages 52 Vs Mini J7 Series YASKAWA
1 page
Ansys Mechanical APDL Features
No ratings yet
Ansys Mechanical APDL Features
298 pages
Husserl vs. Heidegger: Phenomenology in Nursing
No ratings yet
Husserl vs. Heidegger: Phenomenology in Nursing
3 pages
Pipeline Field Testing Procedures
No ratings yet
Pipeline Field Testing Procedures
2 pages
HP LaserJet 1020 Troubleshooting Guide
No ratings yet
HP LaserJet 1020 Troubleshooting Guide
35 pages
Binomial Nomenclature Explained
No ratings yet
Binomial Nomenclature Explained
10 pages
FLOCTEX 3504 Cationic Polymer Guide
No ratings yet
FLOCTEX 3504 Cationic Polymer Guide
1 page
Dual Layer Recordable DVD by Dr. Wlodek S. Mischke Business Development Manager, Datarius Group
No ratings yet
Dual Layer Recordable DVD by Dr. Wlodek S. Mischke Business Development Manager, Datarius Group
6 pages
Building Transportation Systems Explained
No ratings yet
Building Transportation Systems Explained
14 pages
AEC-124 Printed Notes 1
No ratings yet
AEC-124 Printed Notes 1
19 pages
Flight Control System Overview
No ratings yet
Flight Control System Overview
6 pages
Quebral's Development Communication Insights
No ratings yet
Quebral's Development Communication Insights
3 pages
Open and Closed Loop Control Systems
No ratings yet
Open and Closed Loop Control Systems
59 pages
Annual Performance Appraisal 2011-2012
No ratings yet
Annual Performance Appraisal 2011-2012
7 pages
PHA Contact Information Directory
No ratings yet
PHA Contact Information Directory
23 pages
Language Biography Narrative Essay Guide
No ratings yet
Language Biography Narrative Essay Guide
3 pages
Types of DC-DC Switch-Mode Converters
No ratings yet
Types of DC-DC Switch-Mode Converters
28 pages
Real-Time Granulation Techniques in Sound
No ratings yet
Real-Time Granulation Techniques in Sound
12 pages
Solar PV Cell Manufacturing Process
No ratings yet
Solar PV Cell Manufacturing Process
20 pages
Elan: Lights, Camera, Action Series
100% (2)
Elan: Lights, Camera, Action Series
65 pages
Morning Glory Spillway at Hungry Horse Dam
No ratings yet
Morning Glory Spillway at Hungry Horse Dam
32 pages

ADS With Java Lab Record

Uploaded by

ADS With Java Lab Record

Uploaded by

EXPERIMENT–1

Write a java program to perform various operations on single linked list

Node head = null;

if (temp != null && [Link] == key) {

while (temp != null && [Link] != key) {

while (temp != null) {

Node temp = head;

} while (choice != 6);

static class Node {

static Node head = null;

static void insert(int d) {

static void reverse() {

static void display() {

[Link]("Enter number of nodes: ");

for (int i = 0; i < n; i++) {

[Link]("Original List: ");

[Link]("Reversed List: ");

[Link]("Enter number of elements: ");

for (int i = 0; i < n; i++) {

[Link]("Enter number of elements: ");

for (int i = 0; i < n; i++) {

[Link]("After Removing Duplicates: " + set);

Scanner sc = new Scanner([Link]);

[Link]("Enter size of List1: ");

[Link]("Enter size of List2: ");

[Link]("Merged List: " + list1);

Node head = null;

while (temp != null && [Link] != key)

while ([Link] != null)

[Link]("List Reverse: ");

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

} while (choice != 6);

Node last = null;

Node curr = [Link], prev = last;

[Link]("Element Not Found!");

Node temp = [Link];

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

} while (choice != 4);

Node top = null;

Node temp = top;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

} while (choice != 5);

Node front = null, rear = null;

void enqueue(int data) {

Node temp = front;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

} while (choice != 5);

static int precedence(char c) {

public static void main(String[] args) {

[Link]("Enter Infix Expression: ");

for (char ch : [Link]()) {

[Link]("Postfix Expression: " + postfix);

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Postfix Expression: ");

for (char ch : [Link]()) {

[Link]("Result: " + [Link]());

C) Decimal to Binary using Stack

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

while (num > 0) {

Node root = null;

Node insert(Node root, int data) {

if (data < [Link])

boolean search(Node root, int key) {

void inorder(Node root) {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

void addEdge(int u, int v) {

void DFSUtil(int v, boolean[] visited) {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);