Binary Search
public class BinarySearch {
// Method to perform binary search
public static int binarySearch(int[] arr, int target) {
int left = 0; // Starting index
int right = arr.length - 1; // Ending index
while (left <= right) {
int mid = left + (right - left) / 2; // Calculate the middle index
// Check if the target is present at mid
if (arr[mid] == target) {
return mid; // Target found, return the index
}
// If target is greater, ignore the left half
if (arr[mid] < target) {
left = mid + 1;
}
// If target is smaller, ignore the right half
else {
right = mid - 1;
}
}
return -1; // Target not found
}
public static void main(String[] args) {
int[] arr = {2, 3, 4, 10, 40}; // Sorted array
int target = 10; // Element to search for
int result = binarySearch(arr, target);
if (result == -1) {
System.out.println("Element not present in the array");
} else {
System.out.println("Element found at index: " + result);
}
}
}
Output: -
Element found at index : 3
Bubble Sort
public class BubbleSort {
// Method to perform bubble sort
public static void bubbleSort (int [] arr) {
int n = arr. length; // Get the length of the array
// Traverse through all array elements
for (int i = 0; i < n - 1; i++) {
// Last i elements are already in place
for (int j = 0; j < n - i - 1; j++) {
// Swap if the element found is greater than the next element
if (arr[j] > arr[j + 1]) {
// Swap arr[j] and arr[j + 1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// Method to print the array
public static void printArray(int[] arr) {
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println(); // Move to the next line
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90}; // Unsorted array
System.out.println("Unsorted array:");
printArray(arr); // Print the original array
bubbleSort(arr); // Sort the array
System.out.println("Sorted array:");
printArray(arr); // Print the sorted array
}
}
Output:-
Unsorted array:
64 34 25 12 22 11 90
Sorted array:
11 12 22 25 34 64 90
Stack
class Stack {
private int maxSize; // Maximum size of the stack
private int[] stackArray; // Array to hold the stack elements
private int top; // Index of the top element
// Constructor to initialize the stack
public Stack(int size) {
this.maxSize = size;
this.stackArray = new int[maxSize];
this.top = -1; // Stack is initially empty
}
// Method to add an element to the stack
public void push(int value) {
if (top < maxSize - 1) {
stackArray[++top] = value; // Increment top and add value
System.out.println(value + " pushed to stack.");
} else {
System.out.println("Stack is full. Cannot push " + value);
}
}
// Method to remove an element from the stack
public int pop() {
if (top >= 0) {
return stackArray[top--]; // Return top value and decrement top
} else {
System.out.println("Stack is empty. Cannot pop.");
return -1; // Return -1 if stack is empty
}
}
// Method to display the elements of the stack
public void display() {
if (top >= 0) {
System.out.print("Stack elements: ");
for (int i = top; i >= 0; i--) {
System.out.print(stackArray[i] + " ");
}
System.out.println();
} else {
System.out.println("Stack is empty.");
}
}
}
public class StackProgram {
public static void main(String[] args) {
Stack stack = new Stack(5); // Create a stack of size 5
stack.push(10); // Push elements onto the stack
stack.push(20);
stack.push(30);
stack.display(); // Display stack elements
System.out.println(stack.pop() + " popped from stack."); // Pop an
element
stack.display(); // Display stack elements again
stack.push(40); // Push another element
stack.push(50);
stack.push(60); // This will show that the stack is full
stack.display(); // Display final stack elements
}
}
Output:
When you run the program, the output will be:
10 pushed to stack.
20 pushed to stack.
30 pushed to stack.
Stack elements: 30 20 10
30 popped from stack.
Stack elements: 20 10
40 pushed to stack.
50 pushed to stack.
Stack is full. Cannot push 60
Stack elements: 50 40 20 10
