---

// === 1. КЛАСС СТЕК (LIFO) ===
class Stack {
    private int[] stackArray;
    private int top; // Индекс верхнего элемента

    public Stack(int size) {
        stackArray = new int[size];
        top = -1; // -1 означает, что стек пуст
    }

    public void push(int num) {
        stackArray[++top] = num; // Двигаем указатель вверх и кладем число
    }

    public void pop() {
        if (!isEmpty()) {
            top--; // Просто сдвигаем указатель вниз (число затрется следующим push)
        } else {
            System.out.println("Стек пуст");
        }
    }

    public int peek() {
        return stackArray[top];
    }

    public boolean isEmpty() {
        return (top == -1);
    }

    public int size() {
        return top + 1;
    }

    public void printStack() {
        System.out.print("Стек: ");
        for (int i = 0; i <= top; i++) {
            System.out.print(stackArray[i] + " ");
        }
        System.out.println();
    }
}

// === 2. КЛАСС ОЧЕРЕДЬ (FIFO - КОЛЬЦЕВОЙ БУФЕР) ===
class Queue {
    private int[] queueArray;
    private int maxSize;
    private int front;    // Индекс начала очереди
    private int rear;     // Индекс конца очереди
    private int elements; // Количество элементов в данный момент

    public Queue(int size) {
        maxSize = size;
        queueArray = new int[maxSize];
        front = 0;
        rear = -1;
        elements = 0;
    }

    public void push(int num) {
        if (rear == maxSize - 1) {
            rear = -1; // Зацикливаем указатель в начало массива, если дошли до конца
        }
        queueArray[++rear] = num;
        elements++;
    }

    public void pop() {
        if (!isEmpty()) {
            front++;
            if (front == maxSize) {
                front = 0; // Зацикливаем указатель начала
            }
            elements--;
        } else {
            System.out.println("Очередь пуста");
        }
    }

    public int peek() {
        return queueArray[front];
    }

    public boolean isEmpty() {
        return (elements == 0);
    }

    public int size() {
        return elements;
    }

    public void printQueue() {
        System.out.print("Очередь: ");
        int count = 0;
        int current = front;
        while (count < elements) {
            System.out.print(queueArray[current] + " ");
            current++;
            if (current == maxSize) {
                current = 0;
            }
            count++;
        }
        System.out.println();
    }
}

// === 3. КЛАСС ПРИОРИТЕТНАЯ ОЧЕРЕДЬ (СОРТИРОВАННЫЙ МАССИВ) ===
class Priority {
    private int maxSize;
    private int[] priorityArray;
    private int elements; // Количество элементов

    public Priority(int size) {
        maxSize = size;
        priorityArray = new int[maxSize];
        elements = 0;
    }

    public void push(int num) {
        if (elements == 0) {
            priorityArray[0] = num; // Если пуста, просто кладем на первое место
        } else {
            int j;
            // Идем с конца и сдвигаем элементы, которые больше нового числа
            for (j = elements - 1; j >= 0; j--) {
                if (num < priorityArray[j]) {
                    priorityArray[j + 1] = priorityArray[j];
                } else {
                    break; // Нашли правильное место
                }
            }
            priorityArray[j + 1] = num; // Вставляем число
        }
        elements++;
    }

    public void pop() {
        if (!isEmpty()) {
            // Чтобы не делать медленный сдвиг всего массива влево при удалении,
            // мы считаем самым приоритетным элементом тот, что лежит в самом КОНЦЕ.
            // Так мы удаляем элемент за мгновенное уменьшение счетчика!
            elements--; 
        } else {
            System.out.println("Приоритетная очередь пуста");
        }
    }

    // Самый приоритетный (минимальный) элемент теперь всегда в конце заполненной части
    public int peek() {
        return priorityArray[elements - 1];
    }

    public boolean isEmpty() {
        return (elements == 0);
    }

    public int size() {
        return elements;
    }

    public void printPriority() {
        System.out.print("Приоритетная очередь (от больших к меньшим): ");
        for (int i = 0; i < elements; i++) {
            System.out.print(priorityArray[i] + " ");
        }
        System.out.println();
    }
}

// === 4. ОСНОВНОЙ КЛАСС ДЛЯ ЗАПУСКА ===
public class Main {
    public static void main(String[] args) {
        System.out.println("=== СТЕК ===");
        Stack stack = new Stack(5);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.printStack(); // Стек: 1 2 3
        System.out.println("Размер: " + stack.size());
        System.out.println("Вершина (peek): " + stack.peek());
        stack.pop();
        stack.printStack(); // Стек: 1 2

        System.out.println("\n=== ОЧЕРЕДЬ ===");
        Queue queue = new Queue(5);
        queue.push(10);
        queue.push(20);
        queue.push(30);
        queue.printQueue(); // Очередь: 10 20 30
        System.out.println("Размер: " + queue.size());
        System.out.println("Первый элемент (peek): " + queue.peek());
        queue.pop();
        queue.printQueue(); // Очередь: 20 30

        System.out.println("\n=== ПРИОРИТЕТНАЯ ОЧЕРЕДЬ ===");
        Priority pr = new Priority(5);
        pr.push(50);
        pr.push(30);
        pr.push(70);
        pr.push(20);
        pr.printPriority(); // Выведет внутренности массива: 70 50 30 20
        System.out.println("Размер: " + pr.size());
        System.out.println("Приоритетный элемент (peek): " + pr.peek()); // Минимальный элемент: 20
        pr.pop(); // Удалили 20
        pr.printPriority(); // Выведет оставшиеся: 70 50 30
    }
}