Merge pull request #4 from lumijiez/lab3

Lab4

.idea/encodings.xml

@@ -3,5 +3,7 @@
   <component name="Encoding">
     <file url="file://$PROJECT_DIR$/Lab3/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/Lab3/src/main/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/Lab4/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/Lab4/src/main/resources" charset="UTF-8" />
   </component>
 </project>

.idea/misc.xml

@@ -8,6 +8,7 @@
     <option name="originalFiles">
       <list>
         <option value="$PROJECT_DIR$/Lab3/pom.xml" />
+        <option value="$PROJECT_DIR$/Lab4/pom.xml" />
       </list>
     </option>
   </component>

Lab4/pom.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.lumijiez</groupId>
+    <artifactId>Lab4</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

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/intf/LumiQueue.java

@@ -0,0 +1,11 @@
+package org.lumijiez.intf;
+
+public interface LumiQueue<E> {
+    void enqueue(E item);
+    E dequeue();
+    E peek();
+    boolean isEmpty();
+    int size();
+    void clear();
+}
+

Lab4/src/main/java/org/lumijiez/intf/LumiStack.java

@@ -0,0 +1,11 @@
+package org.lumijiez.intf;
+
+public interface LumiStack<E> {
+
+    void push(E item);
+    E pop();
+    E peek();
+    boolean isEmpty();
+    int size();
+    void clear();
+}

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();
+    }
+}

Lab4/src/main/java/org/lumijiez/stacks/ArrayLumiStack.java

@@ -0,0 +1,65 @@
+package org.lumijiez.stacks;
+
+import org.lumijiez.intf.LumiStack;
+
+import java.util.EmptyStackException;
+
+public class ArrayLumiStack<E> implements LumiStack<E> {
+    private final int MAX_CAPACITY_DEFAULT = 10;
+    private Object[] array;
+    private int size;
+
+    public ArrayLumiStack() {
+        array = new Object[MAX_CAPACITY_DEFAULT];
+        size = 0;
+    }
+
+    public ArrayLumiStack(int capacity) {
+        array = new Object[capacity];
+        size = 0;
+    }
+
+    @Override
+    public void push(E item) {
+        if (size == array.length) {
+            throw new StackOverflowError("Stack is full");
+        }
+        array[size++] = item;
+    }
+
+    @Override
+    public E pop() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        E item = (E) array[--size];
+        array[size] = null;
+        return item;
+    }
+
+    @Override
+    public E peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return (E) array[size - 1];
+    }
+
+    @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[i] = null;
+        }
+        size = 0;
+    }
+}

Lab4/src/main/java/org/lumijiez/stacks/DynamicArrayLumiStack.java

@@ -0,0 +1,65 @@
+package org.lumijiez.stacks;
+
+import org.lumijiez.intf.LumiStack;
+
+import java.util.EmptyStackException;
+
+public class DynamicArrayLumiStack<E> implements LumiStack<E> {
+    private Object[] array;
+    private int size;
+    private static final int DEFAULT_CAPACITY = 10;
+
+    public DynamicArrayLumiStack() {
+        array = new Object[DEFAULT_CAPACITY];
+        size = 0;
+    }
+
+    @Override
+    public void push(E item) {
+        ensureCapacity(size + 1);
+        array[size++] = item;
+    }
+
+    @Override
+    public E pop() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        E item = (E) array[--size];
+        array[size] = null;
+        return item;
+    }
+
+    @Override
+    public E peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return (E) array[size - 1];
+    }
+
+    @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[i] = null;
+        }
+        size = 0;
+    }
+
+    private void ensureCapacity(int minCapacity) {
+        if (minCapacity > array.length) {
+            int newCapacity = Math.max(array.length * 2, minCapacity);
+            array = java.util.Arrays.copyOf(array, newCapacity);
+        }
+    }
+}

Lab4/src/main/java/org/lumijiez/stacks/LinkedListLumiStack.java

@@ -0,0 +1,46 @@
+package org.lumijiez.stacks;
+
+import org.lumijiez.intf.LumiStack;
+
+import java.util.EmptyStackException;
+import java.util.LinkedList;
+
+public class LinkedListLumiStack<E> implements LumiStack<E> {
+    private LinkedList<E> list = new LinkedList<>();
+
+    @Override
+    public void push(E item) {
+        list.addFirst(item);
+    }
+
+    @Override
+    public E pop() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return list.removeFirst();
+    }
+
+    @Override
+    public E peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return list.getFirst();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return list.isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return list.size();
+    }
+
+    @Override
+    public void clear() {
+        list.clear();
+    }
+}