//GenericArrayQueue
public class GenericArrayQueue<T> {
    private T[] queueArray;
    private int front;
    private int rear;
    private int maxSize;
    private int currentSize;

    @SuppressWarnings("unchecked")
    public GenericArrayQueue(int size) {
        maxSize = size;
        queueArray = (T[]) new Object[maxSize];
        front = 0;
        rear = -1;
        currentSize = 0;
    }

    public void enqueue(T value) {
        if (isFull()) {
            System.out.println("Queue is full.");
        } else {
            rear = (rear + 1) % maxSize;
            queueArray[rear] = value;
            currentSize++;
        }
    }

    public T dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            T temp = queueArray[front];
            front = (front + 1) % maxSize;
            currentSize--;
            return temp;
        }
    }

    public T peek() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            return queueArray[front];
        }
    }

    public boolean isEmpty() {
        return (currentSize == 0);
    }
    
    public boolean isFull() {
        return (currentSize == maxSize);
    }

    public int size() {
        return currentSize;
    }
}
//Node.java
public class Node<T> {
    T data;
    Node<T> next;

    public Node(T data) {
        this.data = data;
        this.next = null;
    }
}
//GenericLinkedListQueue
public class GenericLinkedListQueue<T> {
    private Node<T> front;
    private Node<T> rear;
    private int size;

    public GenericLinkedListQueue() {
        front = null;
        rear = null;
        size = 0;
    }

    public void enqueue(T value) {
        Node<T> newNode = new Node<>(value);
        if (isEmpty()) {
            front = newNode;
        } else {
            rear.next = newNode;
        }
        rear = newNode;
        size++;
    }

    public T dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            T value = front.data;
            front = front.next;
            if (front == null) {
                rear = null;
            }
            size--;
            return value;
        }
    }

    public T peek() {
        if (isEmpty()) {
            System.out.println("Queue is empty.");
            return null;
        } else {
            return front.data;
        }
    }

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

    public int size() {
        return size;
    }
}
//Main
public class Main {
    public static void main(String[] args) {
        // Array-based queue
        GenericArrayQueue<Integer> intArrayQueue = new GenericArrayQueue<>(10);
        intArrayQueue.enqueue(1);
        intArrayQueue.enqueue(2);
        System.out.println(intArrayQueue.dequeue());  // Output: 1
        System.out.println(intArrayQueue.peek()); // Output: 2

        GenericArrayQueue<Double> doubleArrayQueue = new GenericArrayQueue<>(10);
        doubleArrayQueue.enqueue(1.1);
        doubleArrayQueue.enqueue(2.2);
        System.out.println(doubleArrayQueue.dequeue());  // Output: 1.1
        System.out.println(doubleArrayQueue.peek()); // Output: 2.2

        GenericArrayQueue<String> stringArrayQueue = new GenericArrayQueue<>(10);
        stringArrayQueue.enqueue("Hello");
        stringArrayQueue.enqueue("World");
        System.out.println(stringArrayQueue.dequeue());  // Output: Hello
        System.out.println(stringArrayQueue.peek()); // Output: World

        // Linked list-based queue
        GenericLinkedListQueue<Integer> intLinkedListQueue = new GenericLinkedListQueue<>();
        intLinkedListQueue.enqueue(1);
        intLinkedListQueue.enqueue(2);
        System.out.println(intLinkedListQueue.dequeue());  // Output: 1
        System.out.println(intLinkedListQueue.peek()); // Output: 2

        GenericLinkedListQueue<Double> doubleLinkedListQueue = new GenericLinkedListQueue<>();
        doubleLinkedListQueue.enqueue(1.1);
        doubleLinkedListQueue.enqueue(2.2);
        System.out.println(doubleLinkedListQueue.dequeue());  // Output: 1.1
        System.out.println(doubleLinkedListQueue.peek()); // Output: 2.2

        GenericLinkedListQueue<String> stringLinkedListQueue = new GenericLinkedListQueue<>();
        stringLinkedListQueue.enqueue("Hello");
        stringLinkedListQueue.enqueue("World");
        System.out.println(stringLinkedListQueue.dequeue());  // Output: Hello
        System.out.println(stringLinkedListQueue.peek()); // Output: World
    }
}