Merge pull request #664 from Vika-Permyakova/lab22-24

Лабораторная 22-24

Author: Pastor

students/23K0364/23K0364-p23/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         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>
+    <parent>
+        <artifactId>23K0364</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0364-p23</artifactId>
+    <description>23 задание</description>
+</project>

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueue.java

@@ -0,0 +1,64 @@
+package ru.mirea.practice.s0000001.task1;
+
+public class ArrayQueue {
+    private int capacity = 10;
+    private Object[] queue;
+    private int front = 0;
+    private int rear = 0;
+    private int size = 0;
+
+    public ArrayQueue() {
+        queue = new Object[capacity];
+    }
+
+    public void enqueue(Object element) {
+        if (size == capacity) {
+            throw new IllegalStateException("Queue is full");
+        }
+        queue[rear] = element;
+        rear = (rear + 1) % capacity;
+        size++;
+    }
+
+    public Object element() {
+        if (size == 0) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        return queue[front];
+    }
+
+    public Object dequeue() {
+        if (size == 0) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        Object result = queue[front];
+        front = (front + 1) % capacity;
+        size--;
+        return result;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void clear() {
+        front = 0;
+        rear = 0;
+        size = 0;
+    }
+
+    public static void main(String[] args) {
+        ArrayQueue queue = new ArrayQueue();
+        queue.enqueue(1);
+        queue.enqueue(2);
+        System.out.println(queue.element());
+        System.out.println(queue.dequeue());
+        System.out.println(queue.size());
+        queue.clear();
+        System.out.println(queue.isEmpty());
+    }
+}

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdt.java

@@ -0,0 +1,65 @@
+package ru.mirea.practice.s0000001.task1;
+
+public class ArrayQueueAdt {
+    private int capacity = 10;
+    private Object[] queue;
+    private int front = 0;
+    private int rear = 0;
+    private int size = 0;
+
+    public ArrayQueueAdt() {
+        queue = new Object[capacity];
+    }
+
+    public void enqueue(Object element) {
+        if (size == capacity) {
+            throw new IllegalStateException("Queue is full");
+        }
+        queue[rear] = element;
+        rear = (rear + 1) % capacity;
+        size++;
+    }
+
+    public Object element() {
+        if (size == 0) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        return queue[front];
+    }
+
+    public Object dequeue() {
+        if (size == 0) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        Object result = queue[front];
+        front = (front + 1) % capacity;
+        size--;
+        return result;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void clear() {
+        front = 0;
+        rear = 0;
+        size = 0;
+    }
+
+    public static void main(String[] args) {
+        ArrayQueueAdt queue = new ArrayQueueAdt();
+        queue.enqueue(1);
+        queue.enqueue(2);
+        System.out.println(queue.element());
+        System.out.println(queue.dequeue());
+        System.out.println(queue.size());
+        queue.clear();
+        System.out.println(queue.isEmpty());
+    }
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModule.java

@@ -0,0 +1,60 @@
+package ru.mirea.practice.s0000001.task1;
+
+public abstract class ArrayQueueModule {
+    private static final int CAPACITY = 10;
+    private static Object[] queue = new Object[CAPACITY];
+    private static int front = 0;
+    private static int rear = 0;
+    private static int size = 0;
+
+    public static void enqueue(Object element) {
+        if (size == CAPACITY) {
+            throw new IllegalStateException("Queue is full");
+        }
+        queue[rear] = element;
+        rear = (rear + 1) % CAPACITY;
+        size++;
+    }
+
+    public static Object element() {
+        if (size == 0) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        return queue[front];
+    }
+
+    public static Object dequeue() {
+        if (size == 0) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        Object result = queue[front];
+        front = (front + 1) % CAPACITY;
+        size--;
+        return result;
+    }
+
+    public static boolean isEmpty() {
+        return size == 0;
+    }
+
+    public static int size() {
+        return size;
+    }
+
+    public static void clear() {
+        front = 0;
+        rear = 0;
+        size = 0;
+    }
+
+    public static void main(String[] args) {
+        enqueue(1);
+        enqueue(2);
+        System.out.println(element());
+        System.out.println(dequeue());
+        System.out.println(size());
+        clear();
+        System.out.println(isEmpty());
+    }
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task2/AbstractQueue.java

@@ -0,0 +1,21 @@
+package ru.mirea.practice.s0000001.task2;
+
+public abstract class AbstractQueue implements Queue {
+    protected int size = 0;
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void clear() {
+        size = 0;
+    }
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueue.java

@@ -0,0 +1,39 @@
+package ru.mirea.practice.s0000001.task2;
+
+public class ArrayQueue extends AbstractQueue {
+    private static final int CAPACITY = 10;
+    private Object[] queue = new Object[CAPACITY];
+    private int front = 0;
+    private int rear = 0;
+
+    @Override
+    public void enqueue(Object element) {
+        if (size == CAPACITY) {
+            throw new IllegalStateException("Queue is full");
+        }
+        queue[rear] = element;
+        rear = (rear + 1) % CAPACITY;
+        size++;
+    }
+
+    @Override
+    public Object dequeue() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        final Object result = queue[front];
+        front = (front + 1) % CAPACITY;
+        size--;
+        return result;
+    }
+
+
+    @Override
+    public Object element() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        return queue[front];
+    }
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueue.java

@@ -0,0 +1,74 @@
+package ru.mirea.practice.s0000001.task2;
+
+public class LinkedQueue implements Queue {
+    private Node head;
+    private Node tail;
+    private int size;
+
+    private static class Node {
+        Object data;
+        Node next;
+
+        Node(Object data) {
+            this.data = data;
+            this.next = null;
+        }
+    }
+
+    public LinkedQueue() {
+        this.head = this.tail = null;
+        this.size = 0;
+    }
+
+    @Override
+    public void enqueue(Object element) {
+        Node newNode = new Node(element);
+        if (tail == null) {
+            head = tail = newNode;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+
+    @Override
+    public Object dequeue() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        final Object result = head.data;
+        head = head.next;
+        if (head == null) {
+            tail = null;
+        }
+        size--;
+        return result;
+    }
+
+
+    @Override
+    public Object element() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Queue is empty");
+        }
+        return head.data;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void clear() {
+        head = tail = null;
+        size = 0;
+    }
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task2/Main.java

@@ -0,0 +1,24 @@
+package ru.mirea.practice.s0000001.task2;
+
+public abstract class Main {
+    public static void main(String[] args) {
+        Queue arrayQueue = new ArrayQueue();
+        arrayQueue.enqueue(1);
+        arrayQueue.enqueue(2);
+        System.out.println("ArrayQueue first element: " + arrayQueue.element());  // 1
+        System.out.println("ArrayQueue dequeued element: " + arrayQueue.dequeue());  // 1
+        System.out.println("ArrayQueue size after dequeue: " + arrayQueue.size());  // 1
+        arrayQueue.clear();
+        System.out.println("ArrayQueue is empty after clear? " + arrayQueue.isEmpty());  // true
+
+        Queue linkedQueue = new LinkedQueue();
+        linkedQueue.enqueue(10);
+        linkedQueue.enqueue(20);
+        System.out.println("LinkedQueue first element: " + linkedQueue.element());  // 10
+        System.out.println("LinkedQueue dequeued element: " + linkedQueue.dequeue());  // 10
+        System.out.println("LinkedQueue size after dequeue: " + linkedQueue.size());  // 1
+        linkedQueue.clear();
+        System.out.println("LinkedQueue is empty after clear? " + linkedQueue.isEmpty());  // true
+    }
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task2/Queue.java

@@ -0,0 +1,16 @@
+package ru.mirea.practice.s0000001.task2;
+
+public interface Queue {
+    void enqueue(Object element);
+
+    Object dequeue();
+
+    Object element();
+
+    boolean isEmpty();
+
+    int size();
+
+    void clear();
+}
+

students/23K0364/23K0364-p23/src/main/java/ru/mirea/practice/s0000001/task3/Add.java

@@ -0,0 +1,13 @@
+package ru.mirea.practice.s0000001.task3;
+
+public class Add extends BinaryOperation {
+
+    public Add(Expression left, Expression right) {
+        super(left, right);
+    }
+
+    @Override
+    public double evaluate(double x) {
+        return left.evaluate(x) + right.evaluate(x);
+    }
+}