first commit

Author: rasmimihub

AndOrNot.class

@@ -0,0 +1,15 @@
+import java.util.Scanner;
+public class AndOrNot {
+    public static void main(String[] agrs)
+    {
+        //making scanner object
+        Scanner sc= new Scanner(System.in);
+        System.out.print("Enter number 1: ");
+        int num1=sc.nextInt();
+        System.out.println("Enter the number 2:");
+        int num2=sc.nextInt();
+
+        int sum = num1 + num2;
+        System.out.println("Sum of num1 and num2 is: " + sum);
+    }
+}

AndOrNot.java

@@ -0,0 +1,146 @@
+// CircularNode class to represent each element in the circular linked list
+class CircularNode {
+    int data;
+    CircularNode next;
+
+    // Constructor to initialize the node with data
+    public CircularNode(int data) {
+        this.data = data;
+        this.next = null;
+    }
+}
+
+// CircularLinkedList class to manage the linked list operations
+public class CircularLinkedList {
+    CircularNode head;
+
+    // Method to add a node at the end of the list
+    public void add(int data) {
+        CircularNode newNode = new CircularNode(data);
+
+        // If the list is empty, make the new node the head
+        if (head == null) {
+            head = newNode;
+            head.next = head; // Point the node to itself
+            return;
+        }
+
+        // Traverse to the end of the list
+        CircularNode temp = head;
+        while (temp.next != head) {
+            temp = temp.next;
+        }
+
+        // Add the new node at the end of the list
+        temp.next = newNode;
+        newNode.next = head; // Link the new node to the head
+    }
+
+    // Method to insert a node at a specific position
+    public void insert(int data, int position) {
+        CircularNode newNode = new CircularNode(data);
+
+        // If inserting at the head
+        if (position == 0) {
+            if (head == null) {
+                head = newNode;
+                head.next = head;
+                return;
+            }
+            CircularNode temp = head;
+            while (temp.next != head) {
+                temp = temp.next;
+            }
+            newNode.next = head;
+            head = newNode;
+            temp.next = head;
+            return;
+        }
+
+        // Traverse to the position
+        CircularNode temp = head;
+        for (int i = 0; i < position - 1 && temp.next != head; i++) {
+            temp = temp.next;
+        }
+
+        // Insert the new node
+        newNode.next = temp.next;
+        temp.next = newNode;
+    }
+
+    // Method to delete a node at a specific position
+    public void delete(int position) {
+        if (head == null) {
+            System.out.println("List is empty.");
+            return;
+        }
+
+        // If deleting the head node
+        if (position == 0) {
+            if (head.next == head) {
+                head = null;
+                return;
+            }
+            CircularNode temp = head;
+            while (temp.next != head) {
+                temp = temp.next;
+            }
+            head = head.next;
+            temp.next = head;
+            return;
+        }
+
+        // Traverse to the position
+        CircularNode temp = head;
+        for (int i = 0; i < position - 1 && temp.next != head; i++) {
+            temp = temp.next;
+        }
+
+        // Delete the node
+        if (temp.next == head) {
+            System.out.println("Invalid position.");
+            return;
+        }
+        temp.next = temp.next.next;
+    }
+
+    // Method to display the list
+    public void display() {
+        if (head == null) {
+            System.out.println("List is empty.");
+            return;
+        }
+
+        CircularNode temp = head;
+        do {
+            System.out.print(temp.data + " ");
+            temp = temp.next;
+        } while (temp != head);
+        System.out.println();
+    }
+
+    // Main method to test the circular linked list implementation
+    public static void main(String[] args) {
+        CircularLinkedList cll = new CircularLinkedList();
+
+        // Add elements to the list
+        cll.add(10);
+        cll.add(20);
+        cll.add(30);
+        cll.add(40);
+
+        // Display the list
+        System.out.println("Circular Linked List:");
+        cll.display();
+
+        // Insert an element at position 2
+        cll.insert(25, 2);
+        System.out.println("After inserting 25 at position 2:");
+        cll.display();
+
+        // Delete the element at position 3
+        cll.delete(3);
+        System.out.println("After deleting the element at position 3:");
+        cll.display();
+    }
+}

CircularLinkedList.class

@@ -0,0 +1,91 @@
+public class CircularQueueExample {
+
+    // CircularQueue class definition
+    static class CircularQueue {
+        private int[] queue; // Array to store the elements of the queue
+        private int front, rear, size; // Variables to keep track of the front, rear, and size of the queue
+
+        // Constructor to initialize the queue with a given size
+        public CircularQueue(int size) {
+            this.size = size;
+            this.queue = new int[size];
+            this.front = -1;
+            this.rear = -1;
+        }
+
+        // Method to check if the queue is full
+        public boolean isFull() {
+            return (front == 0 && rear == size - 1) || (rear == (front - 1) % (size - 1));
+        }
+
+        // Method to check if the queue is empty
+        public boolean isEmpty() {
+            return front == -1;
+        }
+
+        // Method to add an element to the queue
+        public void enqueue(int element) {
+            if (isFull()) {
+                System.out.println("Queue is full");
+                return;
+            }
+            if (front == -1) {
+                front = 0;
+            }
+            rear = (rear + 1) % size;
+            queue[rear] = element;
+        }
+
+        // Method to remove and return the front element from the queue
+        public int dequeue() {
+            if (isEmpty()) {
+                System.out.println("Queue is empty");
+                return -1;
+            }
+            int element = queue[front];
+            if (front == rear) {
+                front = -1;
+                rear = -1;
+            } else {
+                front = (front + 1) % size;
+            }
+            return element;
+        }
+
+        // Method to return the front element without removing it
+        public int peek() {
+            if (isEmpty()) {
+                System.out.println("Queue is empty");
+                return -1;
+            }
+            return queue[front];
+        }
+    }
+
+    // Main method to demonstrate the CircularQueue usage
+    public static void main(String[] args) {
+        CircularQueue cq = new CircularQueue(5); // Create a circular queue with size 5
+
+        // Add elements to the queue
+        cq.enqueue(10);
+        cq.enqueue(20);
+        cq.enqueue(30);
+        cq.enqueue(40);
+        cq.enqueue(50);
+
+        // Remove and print an element from the queue
+        System.out.println("Dequeued element: " + cq.dequeue());
+
+        // Print the front element
+        System.out.println("Front element: " + cq.peek());
+
+        // Add another element to the queue
+        cq.enqueue(60);
+
+        // Remove and print all elements from the queue
+        while (!cq.isEmpty()) {
+            System.out.println("Dequeued element: " + cq.dequeue());
+        }
+    }
+}
+