Array implementation of stacks

PROGRAM

import [Link];

class Stack

private int top;

private int size;

private int arr[];

Stack(int size)

[Link]=size;

[Link]=new int[size];

[Link]=-1;

boolean isEmpty()

return(top<0);

boolean push(int val)

if(top==size-1)

[Link]("Stack Overflow!!");
 return false;

else

top++;

arr[top]=val;

[Link]("Item pushed: "+val);

return true;

boolean pop()

if(top==-1)

[Link]("Stack Underflow!!");

return false;

else

int poppedValue=arr[top];

top--;

[Link]("Item Popped: "+poppedValue);

return true;

}
}

void display()

if(top==-1)

[Link]("No elements in the Stack");

else

[Link]("The Elements in the Stack");

for(int i=top;i>=0;i--)

[Link](arr[i]);

void peek()

if(top==-1)

[Link]("Stack is empty");

else

{
 [Link]("Top Element is: "+arr[top]);

public class StackOperations

public static void main(String[] args)

Scanner sc=new Scanner([Link]);

[Link]("Enter the size of the Stack: ");

int size=[Link]();

Stack s=new Stack(size);

int ch=0;

[Link]("ARRAY IMPLEMENTATION OF STACK \n");

[Link]("\n----------------------------\n");

while(ch!=5)

[Link]("\n CHOOSE ONE FOR THE BELOW OPTIONS:

");

[Link]("\n1. PUSH \n2. POP \n3. PEEK \n4. DISPLAY \n5.

EXIT");

[Link]("\nEnter your choice: ");

ch=[Link]();

switch(ch)

{
case 1:

[Link]("Enter the value to push: ");

int value=[Link]();

[Link](value);

break;

case 2:

[Link]();

break;

case 3:

[Link]();

break;

case 4:

[Link]();

break;

case 5:

{
 [Link]("EXIT");

break;

default:

[Link]("Enter a valid choice: ");

[Link]();

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Array implementation of Queues

PROGRAM

import [Link];

class ArrayQueue

private int front, rear, capacity;

private int[] queue;

public ArrayQueue(int size)

capacity=size+1;

queue=new int[capacity];

front=rear=0;

public void enqueue(int item)

if(isFull())

[Link]("Queue is Full");

return;

queue[rear]=item;

rear=(rear+1)%capacity;

}
public int dequeue()

if(isEmpty())

[Link]("Queue is empty");

return-1;

int item=queue[front];

front=(front+1)%capacity;

return item;

public boolean isEmpty()

return front==rear;

public boolean isFull()

return(rear+1)%capacity==front;

public void display()

if(isEmpty())

[Link]("Queue is Empty");
 return;

for(int i=front;i!=rear;i=(i+1)%capacity)

[Link](queue[i]+" ");

[Link]();

public class QueueImplementation

public static void main(String args[])

Scanner scanner=new Scanner([Link]);

[Link]("Enter the capacity of the queue: ");

int capacity=[Link]();

ArrayQueue queue=new ArrayQueue(capacity);

while(true)

[Link]("\nQUEUE OPERATIONS: \[Link]

\[Link] \[Link] \[Link] \nCHOOSE A OPTION: ");

int choice=[Link]();

switch(choice)

case 1:
 [Link]("Enter the element to enqueue: ");

[Link]([Link]());

break;

case 2:

int dequeuedElement=[Link]();

if(dequeuedElement!=-1)

[Link]("Dequeued element: "+dequeuedElement);

break;

case 3:

[Link]();

break;

case 4:

[Link]();

return;

default:

[Link]("Enter a valid choice.");

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Linked list implementation of stacks

PROGRAM
import [Link];
public class LinkedListStack {
private Node top;
private class Node {
int data;
Node next;
}
public LinkedListStack() {
top = null;
}
public void push(int data) {
Node newNode = new Node();
[Link] = data;
[Link] = top;
top = newNode;
}
public int pop() {
if (top == null) throw new RuntimeException("Stack is Empty");
int data = [Link];
top = [Link];
return data;
}
public boolean isEmpty() {
 return top == null;
}
public int peek() {
if (top == null) throw new RuntimeException("Stack is Empty");
return [Link];
}
public void display() {
if (top == null) {
[Link]("Stack is Empty");
return;
}
[Link]("Stack Elements:");
Node current = top;
while (current != null) {
[Link]([Link] + " ");
current = [Link];
}
[Link]();
}
public static void displayMenu() {
[Link]("\nEnter your choice:");
[Link]("1. PUSH");
[Link]("2. POP");
[Link]("3. PEEK");
[Link]("4. DISPLAY STACK ELEMENTS");
[Link]("5. EXIT");
}
public static void main(String[] args) {
LinkedListStack stack = new LinkedListStack();
Scanner scanner = new Scanner([Link]);
while (true) {
displayMenu();
String choiceStr = [Link]();
int choice;
try {
choice = [Link](choiceStr);
switch (choice) {
case 1:
[Link]("Enter a value to push:");
int value = [Link]([Link]());
[Link](value);
break;
case 2:
try {
[Link]("Popped: " + [Link]());
} catch (RuntimeException e) {
[Link]([Link]());
}
break;
case 3:
try {

[Link]("Top element: " + [Link]());

} catch (RuntimeException e) {
 [Link]([Link]());
}
break;
case 4:
[Link]();
break;
case 5:
[Link]("Exiting...");
return;
default:
[Link]("Invalid choice, please try again.");
}
} catch (NumberFormatException e) {
[Link]("Enter a valid number.");
}
}
}
}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Linked list implementation of Queues

PROGRAM

import [Link];

// Node class for the queue elements

class Node {

int data;

Node next;

Node(int data) {

[Link] = data;

[Link] = null;

// Queue class using a linked list

class LinkedListQueue {

private Node front, rear;

LinkedListQueue() {

front = rear = null;

// Add an element to the queue

void enqueue(int value) {

Node newNode = new Node(value);

if (rear == null) {
 front = rear = newNode;

} else {

[Link] = newNode;

rear = newNode;

[Link]("Enqueued: " + value);

// Remove an element from the queue

void dequeue() {

if (front == null) {

[Link]("Queue is empty.");

} else {

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

front = [Link];

if (front == null) rear = null;

// View the front element

void peek() {

if (front == null) {

[Link]("Queue is empty.");

} else {

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

 }

// Display all elements in the queue

void display() {

if (front == null) {

[Link]("Queue is empty.");

} else {

[Link]("Queue: ");

for (Node current = front; current != null; current = [Link]) {

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

[Link]();

public class QueueOperations {

public static void main(String[] args) {

LinkedListQueue queue = new LinkedListQueue();

Scanner sc = new Scanner([Link]);

while (true) {

[Link]("\n1. Enqueue 2. Dequeue 3. Peek 4. Display

5. Exit");

[Link]("Choose an option: ");

int choice = [Link]();

 switch (choice) {

case 1:

[Link]("Enter value: ");

[Link]([Link]());

break;

case 2:

[Link]();

break;

case 3:

[Link]();

break;

case 4:

[Link]();

break;

case 5:

[Link]("Exiting...");

[Link]();

return;

default:

[Link]("Invalid choice. Try again.");

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Conversion of infix expression to postfix.

PROGRAM

import [Link];

import [Link];

public class InfixToPostfix {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Welcome to the Infix to Postfix Converter!");

[Link]("Type 'exit' to quit the program at any time.");

while (true) {

[Link]("Enter an infix expression: ");

String infix = [Link]().trim();

if ([Link]("exit")) {

[Link]("Exiting the program. Goodbye!");

break;

if ([Link]()) {

[Link]("Error: Expression cannot be empty.");

continue;

String postfix = convertToPostfix(infix);

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

}
 [Link]();

private static String convertToPostfix(String infix) {

StringBuilder postfix = new StringBuilder();

Stack<Character> stack = new Stack<Character>(); // Older syntax

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

if ([Link](c)) {

[Link](c);

} else if (c == '(') {

[Link](c);

} else if (c == ')') {

processClosingParenthesis(stack, postfix);

} else if (isOperator(c)) {

processOperator(c, stack, postfix);

} else {

return "Error: Invalid character " + c;

// Pop all remaining operators from the stack

while (![Link]()) {

char op = [Link]();

if (op == '(') {

return "Error: Mismatched parentheses";

}
 [Link](op);

return [Link]();

private static void processClosingParenthesis(Stack<Character> stack,

StringBuilder postfix) {

while (![Link]() && [Link]() != '(') {

[Link]([Link]());

if (![Link]()) {

[Link](); // Remove the '(' from the stack

private static void processOperator(char operator, Stack<Character>

stack, StringBuilder postfix) {

while (![Link]() && precedence(operator) <=

precedence([Link]())) {

[Link]([Link]());

[Link](operator);

private static int precedence(char op) {

switch (op) {

case '+':

case '-':
 return 1;

case '*':

case '/':

return 2;

case '^':

return 3;

default:

return -1;

private static boolean isOperator(char c) {

return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Binary Tree Traversals (Inorder, Preorder, Postorder)

PROGRAM

import [Link];

import [Link];

import [Link];

// Node class for the binary tree

class TreeNode {

int data;

TreeNode left, right;

TreeNode(int data) {

[Link] = data;

left = right = null;

// Binary Tree class

class BinaryTree {

TreeNode root;

// Method to insert nodes in the binary tree

void insertLevelOrder(int[] elements) {

if ([Link] == 0) return;

root = new TreeNode(elements[0]);

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

 [Link](root);

int i = 1;

while (i < [Link]) {

TreeNode current = [Link]();

if (i < [Link]) {

[Link] = new TreeNode(elements[i++]);

[Link]([Link]);

if (i < [Link]) {

[Link] = new TreeNode(elements[i++]);

[Link]([Link]);

// Inorder traversal

void inorder(TreeNode node) {

if (node != null) {

inorder([Link]);

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

inorder([Link]);

// Preorder traversal

void preorder(TreeNode node) {

 if (node != null) {

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

preorder([Link]);

preorder([Link]);

// Postorder traversal

void postorder(TreeNode node) {

if (node != null) {

postorder([Link]);

postorder([Link]);

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

// Display the binary tree

void display() {

if (root == null) {

[Link]("The tree is empty.");

return;

// Level order traversal to print the tree

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

[Link](root);

int level = 0;
 while (![Link]()) {

int levelSize = [Link]();

[Link]("Level " + level + ": ");

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

TreeNode node = [Link]();

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

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

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

[Link]();

level++;

public class BinaryTreeTraversals {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

BinaryTree tree = new BinaryTree();

[Link]("Enter the elements of the tree level by level:");

String input = [Link]();

String[] inputStrings = [Link](" ");

int[] elements = new int[[Link]];

// Convert input to integers

int count = 0;
 for (String s : inputStrings) {

if ([Link]("done")) {

break;

elements[count++] = [Link](s);

// Build the tree

[Link](elements);

while (true) {

[Link]("\n1. Inorder Traversal 2. Preorder Traversal

3. Postorder Traversal 4. Display Tree 5. Exit");

[Link]("Choose an option: ");

int choice = [Link]();

switch (choice) {

case 1:

[Link]("Inorder Traversal: ");

[Link]([Link]);

[Link]();

break;

case 2:

[Link]("Preorder Traversal: ");

[Link]([Link]);

[Link]();

break;
 case 3:

[Link]("Postorder Traversal: ");

[Link]([Link]);

[Link]();

break;

case 4:

[Link]("Tree Structure:");

[Link]();

break;

case 5:

[Link]("Exiting...");

[Link]();

return;

default:

[Link]("Invalid choice. Try again.");

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Linear Search

PROGRAM

import [Link];

public class SimpleLinearSearch {

// Method to find the index of a number

public static int find(int[] numbers, int target) {

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

if (numbers[i] == target) {

return i; // Found the target

return -1; // Target not found

// Main method

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

// Get the array size and elements

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

int[] numbers = new int[[Link]()];

[Link]("Enter the elements:");

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

numbers[i] = [Link]();

}
 // Get the target number

[Link]("Enter number to search: ");

int target = [Link]();

// Search and show result

int index = find(numbers, target);

[Link](index == -1 ? "Number not found." : "Number found at

index: " + index);

[Link]();

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Binary search

PROGRAM

import [Link];

public class EasyBinarySearch {

// Method to search for a number

public static int search(int[] arr, int target) {

int start = 0, end = [Link] - 1;

while (start <= end) {

int mid = (start + end) / 2;

if (arr[mid] == target) {

return mid; // Target found

if (arr[mid] < target) {

start = mid + 1; // Search right half

} else {

end = mid - 1; // Search left half

return -1; // Target not found

// Main method to interact with the user

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

 // Get array size

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

int size = [Link]();

int[] arr = new int[size];

// Get array elements

[Link]("Enter sorted elements:");

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

arr[i] = [Link]();

// Get number to find

[Link]("Enter number to find: ");

int target = [Link]();

// Perform the search

int result = search(arr, target);

// Display result

if (result == -1) {

[Link]("Number not found.");

} else {

[Link]("Number found at index: " + result);

[Link]();

}
OUTPUT

RESULT

Thus the given program has been executed successfully.

Implementation of Depth-First Search & Breadth-First Search of Graphs.

PROGRAM

import [Link].*;
public class SimpleGraphSearch {
// Adjacency list representation of the graph
private static Map<Integer, List<Integer>> graph = new HashMap<Integer,
List<Integer>>();
// Function to add an edge to the graph
private static void addEdge(int u, int v) {
if () {
[Link](u, new ArrayList<Integer>());
}
if () {
[Link](v, new ArrayList<Integer>());
}
[Link](u).add(v);
[Link](v).add(u);
}
// Depth-First Search (DFS)
private static void dfs(int start, Set<Integer> visited) {
if ([Link](start)) return;
[Link](start);
[Link](start + " ");
List<Integer> neighbors = [Link](start);
if (neighbors != null) {
for (int neighbor : neighbors) {
dfs(neighbor, visited);
}
}
}
// Breadth-First Search (BFS)
private static void bfs(int start) {
Set<Integer> visited = new HashSet<Integer>();
Queue<Integer> queue = new LinkedList<Integer>();
[Link](start);
[Link](start);
while (![Link]()) {
int node = [Link]();
[Link](node + " ");
List<Integer> neighbors = [Link](node);
if (neighbors != null) {
for (int neighbor : neighbors) {
if ([Link](neighbor)) {
[Link](neighbor);
}}
}}
[Link]();
}
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
while (true) {
[Link]("1. Add Edge\n2. DFS\n3. BFS\n4. Exit");
[Link]("Choose: ");
int choice = [Link]();
switch (choice) {
case 1:
[Link]("Enter edge (u v): ");
int u = [Link]();
int v = [Link]();
addEdge(u, v);
[Link]("Edge added.");
break;
case 2:
[Link]("Enter start node for DFS: ");
Set<Integer> visitedDFS = new HashSet<Integer>();
dfs([Link](), visitedDFS);
[Link]();
break;
case 3:
[Link]("Enter start node for BFS: ");
bfs([Link]());
break;
case 4:
[Link]();
return;
default:
[Link]("Invalid choice.");
}
}
}}
OUTPUT

RESULT

Thus the given program has been executed successfully.

 Single source shortest path of a Graph.

PROGRAM

import [Link].*;

public class SimpleDijkstra {

static class Node {

int vertex, weight;

Node(int vertex, int weight) {

[Link] = vertex;

[Link] = weight;

} }

private static Map<Integer, List<Node>> graph = new

HashMap<Integer, List<Node>>();

private static void addEdge(int u, int v, int weight) {

if () {

[Link](u, new ArrayList<Node>());

if () {

[Link](v, new ArrayList<Node>());

[Link](u).add(new Node(v, weight));

[Link](v).add(new Node(u, weight));

private static void dijkstra(int source) {

 Map<Integer, Integer> distances = new HashMap<Integer,
Integer>();

PriorityQueue<Node> pq = new PriorityQueue<Node>(10, new

Comparator<Node>() {

public int compare(Node a, Node b) {

if ([Link] < [Link]) return -1;

if ([Link] > [Link]) return 1;

return 0;

});

for (int node : [Link]()) {

[Link](node, Integer.MAX_VALUE);

[Link](source, 0);

[Link](new Node(source, 0));

while (![Link]()) {

Node curr = [Link]();

int currNode = [Link];

int currDist = [Link];

if (currDist > [Link](currNode)) continue;

List<Node> neighbors = [Link](currNode);

if (neighbors != null) {

for (Node neighbor : neighbors) {

int newDist = currDist + [Link];

if (newDist < [Link]([Link])) {

 [Link]([Link], newDist);

[Link](new Node([Link], newDist));

} }

} }

[Link]("Shortest distances from node " + source + ":");

for ([Link]<Integer, Integer> entry : [Link]()) {

[Link]("To node " + [Link]() + ": " +

[Link]());

}}

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

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

int edges = [Link]();

[Link]("Enter edges (node1 node2 weight):");

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

int u = [Link]();

int v = [Link]();

int weight = [Link]();

addEdge(u, v, weight);

[Link]("Enter the source node:");

int source = [Link]();

dijkstra(source);

}
OUTPUT

RESULT

Thus the given program has been executed successfully.