Implemented Queues + Tests

Lab4/src/main/java/org/lumijiez/Main.java

@@ -0,0 +1,117 @@
+package org.lumijiez;
+
+import org.lumijiez.intf.LumiQueue;
+import org.lumijiez.intf.LumiStack;
+import org.lumijiez.queues.DynamicArrayLumiQueue;
+import org.lumijiez.queues.LinkedListLumiQueue;
+import org.lumijiez.queues.MinHeapLumiQueue;
+import org.lumijiez.stacks.ArrayLumiStack;
+import org.lumijiez.stacks.DynamicArrayLumiStack;
+import org.lumijiez.stacks.LinkedListLumiStack;
+
+public class Main {
+    public static void main(String[] args) {
+        boolean queueTestsPassed = testQueues();
+        boolean stackTestsPassed = testStacks();
+
+        if (queueTestsPassed && stackTestsPassed) {
+            System.out.println("All Test OK");
+        } else {
+            System.out.println("Tests Failed");
+        }
+    }
+
+    public static boolean testQueues() {
+        boolean dynamicArrayTest = true;
+        boolean linkedListTest = true;
+        boolean minHeapTest = true;
+
+        // Test for Dynamic Array Queue
+        LumiQueue<Integer> dynamicArrayQueue = new DynamicArrayLumiQueue<>();
+        dynamicArrayQueue.enqueue(1);
+        dynamicArrayQueue.enqueue(2);
+        dynamicArrayQueue.enqueue(3);
+        dynamicArrayTest &= dynamicArrayQueue.size() == 3;
+        dynamicArrayTest &= dynamicArrayQueue.peek() == 1;
+        dynamicArrayTest &= dynamicArrayQueue.dequeue() == 1;
+        dynamicArrayTest &= dynamicArrayQueue.size() == 2;
+        dynamicArrayTest &= !dynamicArrayQueue.isEmpty();
+
+        System.out.println((dynamicArrayTest) ? "OK : Dynamic Array Queue Test Passed" : "BAD : Dynamic Array Queue Test Failed");
+
+        // Test for Linked List Queue
+        LumiQueue<String> linkedListQueue = new LinkedListLumiQueue<>();
+        linkedListQueue.enqueue("Apple");
+        linkedListQueue.enqueue("Banana");
+        linkedListQueue.enqueue("Cherry");
+        linkedListTest &= linkedListQueue.size() == 3;
+        linkedListTest &= linkedListQueue.peek().equals("Apple");
+        linkedListTest &= linkedListQueue.dequeue().equals("Apple");
+        linkedListTest &= linkedListQueue.size() == 2;
+        linkedListTest &= !linkedListQueue.isEmpty();
+
+        System.out.println((linkedListTest) ? "OK : Linked List Queue Test Passed" : "BAD : Linked List Queue Test Failed");
+
+        // Test for Priority Queue (Min-Heap) Queue
+        LumiQueue<Double> priorityQueueQueue = new MinHeapLumiQueue<>();
+        priorityQueueQueue.enqueue(3.2);
+        priorityQueueQueue.enqueue(1.5);
+        priorityQueueQueue.enqueue(2.1);
+        minHeapTest &= priorityQueueQueue.size() == 3;
+        minHeapTest &= priorityQueueQueue.peek() == 1.5;
+        minHeapTest &= priorityQueueQueue.dequeue() == 1.5;
+        minHeapTest &= priorityQueueQueue.size() == 2;
+        minHeapTest &= !priorityQueueQueue.isEmpty();
+
+        System.out.println((minHeapTest) ? "OK : MinHeap Queue Test Passed" : "BAD : MinHeap Queue Test Failed");
+
+        return dynamicArrayTest && linkedListTest && minHeapTest;
+    }
+
+    public static boolean testStacks() {
+        boolean dynamicArrayTest = true;
+        boolean linkedListTest = true;
+        boolean arrayTest = true;
+
+        // Test for Array Stack
+        LumiStack<Integer> arrayStack = new ArrayLumiStack<>();
+        arrayStack.push(10);
+        arrayStack.push(20);
+        arrayStack.push(30);
+        arrayTest &= arrayStack.size() == 3;
+        arrayTest &= arrayStack.peek() == 30;
+        arrayTest &= arrayStack.pop() == 30;
+        arrayTest &= arrayStack.size() == 2;
+        arrayTest &= !arrayStack.isEmpty();
+
+        System.out.println((arrayTest) ? "OK : Array Stack Test Passed" : "BAD : Array Stack Test Failed");
+
+        // Test for Linked List Stack
+        LumiStack<String> linkedListStack = new LinkedListLumiStack<>();
+        linkedListStack.push("First");
+        linkedListStack.push("Second");
+        linkedListStack.push("Third");
+        linkedListTest &= linkedListStack.size() == 3;
+        linkedListTest &= linkedListStack.peek().equals("Third");
+        linkedListTest &= linkedListStack.pop().equals("Third");
+        linkedListTest &= linkedListStack.size() == 2;
+        linkedListTest &= !linkedListStack.isEmpty();
+
+        System.out.println((linkedListTest) ? "OK : Linked List Stack Test Passed" : "BAD : Linked List Stack Test Failed");
+
+        // Test for Dynamic Array Stack
+        LumiStack<Character> dynamicArrayStack = new DynamicArrayLumiStack<>();
+        dynamicArrayStack.push('A');
+        dynamicArrayStack.push('B');
+        dynamicArrayStack.push('C');
+        dynamicArrayTest &= dynamicArrayStack.size() == 3;
+        dynamicArrayTest &= dynamicArrayStack.peek() == 'C';
+        dynamicArrayTest &= dynamicArrayStack.pop() == 'C';
+        dynamicArrayTest &= dynamicArrayStack.size() == 2;
+        dynamicArrayTest &= !dynamicArrayStack.isEmpty();
+
+        System.out.println((dynamicArrayTest) ? "OK : Dynamic Array Stack Test Passed" : "BAD : Dynamic Array Stack Test Failed");
+
+        return dynamicArrayTest && linkedListTest && arrayTest;
+    }
+}

Lab4/src/main/java/org/lumijiez/queues/DynamicArrayLumiQueue.java

@@ -0,0 +1,81 @@
+package org.lumijiez.queues;
+
+import org.lumijiez.intf.LumiQueue;
+
+import java.util.NoSuchElementException;
+
+public class DynamicArrayLumiQueue<E> implements LumiQueue<E> {
+    private Object[] array;
+    private int size;
+    private int front;
+    private int rear;
+    private static final int DEFAULT_CAPACITY = 10;
+
+    public DynamicArrayLumiQueue() {
+        array = new Object[DEFAULT_CAPACITY];
+        size = 0;
+        front = 0;
+        rear = 0;
+    }
+
+    @Override
+    public void enqueue(E item) {
+        ensureCapacity(size + 1);
+        array[rear] = item;
+        rear = (rear + 1) % array.length;
+        size++;
+    }
+
+    @Override
+    public E dequeue() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        E item = (E) array[front];
+        array[front] = null;
+        front = (front + 1) % array.length;
+        size--;
+        return item;
+    }
+
+    @Override
+    public E peek() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return (E) array[front];
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void clear() {
+        for (int i = 0; i < size; i++) {
+            array[(front + i) % array.length] = null;
+        }
+        size = 0;
+        front = 0;
+        rear = 0;
+    }
+
+    private void ensureCapacity(int minCapacity) {
+        if (minCapacity > array.length) {
+            int newCapacity = Math.max(array.length * 2, minCapacity);
+            Object[] newArray = new Object[newCapacity];
+            for (int i = 0; i < size; i++) {
+                newArray[i] = array[(front + i) % array.length];
+            }
+            array = newArray;
+            front = 0;
+            rear = size;
+        }
+    }
+}

Lab4/src/main/java/org/lumijiez/queues/LinkedListLumiQueue.java

@@ -0,0 +1,79 @@
+package org.lumijiez.queues;
+
+import org.lumijiez.intf.LumiQueue;
+
+import java.util.NoSuchElementException;
+
+public class LinkedListLumiQueue<E> implements LumiQueue<E> {
+    private Node<E> front;
+    private Node<E> rear;
+    private int size;
+
+    private static class Node<E> {
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+            this.next = null;
+        }
+    }
+
+    public LinkedListLumiQueue() {
+        front = null;
+        rear = null;
+        size = 0;
+    }
+
+    @Override
+    public void enqueue(E item) {
+        Node<E> newNode = new Node<>(item);
+        if (isEmpty()) {
+            front = newNode;
+        } else {
+            rear.next = newNode;
+        }
+        rear = newNode;
+        size++;
+    }
+
+    @Override
+    public E dequeue() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        E item = front.data;
+        front = front.next;
+        size--;
+        if (front == null) {
+            rear = null;
+        }
+        return item;
+    }
+
+    @Override
+    public E peek() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return front.data;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void clear() {
+        front = null;
+        rear = null;
+        size = 0;
+    }
+}
+

Lab4/src/main/java/org/lumijiez/queues/MinHeapLumiQueue.java

@@ -0,0 +1,50 @@
+package org.lumijiez.queues;
+
+import org.lumijiez.intf.LumiQueue;
+
+import java.util.PriorityQueue;
+import java.util.NoSuchElementException;
+
+public class MinHeapLumiQueue<E extends Comparable<E>> implements LumiQueue<E> {
+    private final PriorityQueue<E> priorityQueue;
+
+    public MinHeapLumiQueue() {
+        priorityQueue = new PriorityQueue<>();
+    }
+
+    @Override
+    public void enqueue(E item) {
+        priorityQueue.offer(item);
+    }
+
+    @Override
+    public E dequeue() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return priorityQueue.poll();
+    }
+
+    @Override
+    public E peek() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return priorityQueue.peek();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return priorityQueue.isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return priorityQueue.size();
+    }
+
+    @Override
+    public void clear() {
+        priorityQueue.clear();
+    }
+}