diff --git a/.idea/encodings.xml b/.idea/encodings.xml index 228e9f1..fcd3bfa 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -3,5 +3,7 @@ + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index d56e9ca..c449b97 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -8,6 +8,7 @@ diff --git a/Lab4/pom.xml b/Lab4/pom.xml new file mode 100644 index 0000000..18cb798 --- /dev/null +++ b/Lab4/pom.xml @@ -0,0 +1,17 @@ + + + 4.0.0 + + org.lumijiez + Lab4 + 1.0-SNAPSHOT + + + 17 + 17 + UTF-8 + + + \ No newline at end of file diff --git a/Lab4/src/main/java/org/lumijiez/Main.java b/Lab4/src/main/java/org/lumijiez/Main.java new file mode 100644 index 0000000..ee61de5 --- /dev/null +++ b/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 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 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 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 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 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 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; + } +} \ No newline at end of file diff --git a/Lab4/src/main/java/org/lumijiez/intf/LumiQueue.java b/Lab4/src/main/java/org/lumijiez/intf/LumiQueue.java new file mode 100644 index 0000000..d5a94ef --- /dev/null +++ b/Lab4/src/main/java/org/lumijiez/intf/LumiQueue.java @@ -0,0 +1,11 @@ +package org.lumijiez.intf; + +public interface LumiQueue { + void enqueue(E item); + E dequeue(); + E peek(); + boolean isEmpty(); + int size(); + void clear(); +} + diff --git a/Lab4/src/main/java/org/lumijiez/intf/LumiStack.java b/Lab4/src/main/java/org/lumijiez/intf/LumiStack.java new file mode 100644 index 0000000..2066fc3 --- /dev/null +++ b/Lab4/src/main/java/org/lumijiez/intf/LumiStack.java @@ -0,0 +1,11 @@ +package org.lumijiez.intf; + +public interface LumiStack { + + void push(E item); + E pop(); + E peek(); + boolean isEmpty(); + int size(); + void clear(); +} diff --git a/Lab4/src/main/java/org/lumijiez/queues/DynamicArrayLumiQueue.java b/Lab4/src/main/java/org/lumijiez/queues/DynamicArrayLumiQueue.java new file mode 100644 index 0000000..0fa9eb7 --- /dev/null +++ b/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 implements LumiQueue { + 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; + } + } +} diff --git a/Lab4/src/main/java/org/lumijiez/queues/LinkedListLumiQueue.java b/Lab4/src/main/java/org/lumijiez/queues/LinkedListLumiQueue.java new file mode 100644 index 0000000..74a04d4 --- /dev/null +++ b/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 implements LumiQueue { + private Node front; + private Node rear; + private int size; + + private static class Node { + E data; + Node 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 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; + } +} + diff --git a/Lab4/src/main/java/org/lumijiez/queues/MinHeapLumiQueue.java b/Lab4/src/main/java/org/lumijiez/queues/MinHeapLumiQueue.java new file mode 100644 index 0000000..5303424 --- /dev/null +++ b/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> implements LumiQueue { + private final PriorityQueue 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(); + } +} diff --git a/Lab4/src/main/java/org/lumijiez/stacks/ArrayLumiStack.java b/Lab4/src/main/java/org/lumijiez/stacks/ArrayLumiStack.java new file mode 100644 index 0000000..8971046 --- /dev/null +++ b/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 implements LumiStack { + 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; + } +} diff --git a/Lab4/src/main/java/org/lumijiez/stacks/DynamicArrayLumiStack.java b/Lab4/src/main/java/org/lumijiez/stacks/DynamicArrayLumiStack.java new file mode 100644 index 0000000..5a6f1e5 --- /dev/null +++ b/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 implements LumiStack { + 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); + } + } +} diff --git a/Lab4/src/main/java/org/lumijiez/stacks/LinkedListLumiStack.java b/Lab4/src/main/java/org/lumijiez/stacks/LinkedListLumiStack.java new file mode 100644 index 0000000..b571bc5 --- /dev/null +++ b/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 implements LumiStack { + private LinkedList 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(); + } +}