Queues

/**
 * To run this code, you need to have Java installed on your computer, then:
 * - Create a file named `Queue.java` in a directory of your choice.
 * - Copy this code in the file.
 * - Open a terminal in the directory where the file is located.
 * - Run the command `javac Queue.java` to compile the code.
 * - Run the command `java -ea Queue` to execute the compiled code.
 * Note: '-ea' is an option to enable assertions in Java.
 */

// Needed imports

import java.util.ArrayList;
import java.util.List;


/**
 * This is a possible implementation of a queue.
 * Here, the stack manipulates a dynamically sized ArrayList.
 * This class should be put in a file named 'Queue.java'.
 */
public class Queue<T> {

    /**
     * Here is the attribute we need to define for data.
     */
    private List<T> data;


    /**
     * This is the constructor of the class.
     * It initializes the empty queue.
     */
    public Queue() {
        // Initialize data
        this.data = new ArrayList<>();
    }


    /**
     * This method returns a string representation of the queue.
     *
     * @return A string representation of the queue.
     */
    public String toString() {
        // Create string
        StringBuilder string = new StringBuilder("[");
        for (T d : data) {
            string.append(d).append(", ");
        }
        if (!data.isEmpty()) {
            string.setLength(string.length() - 2);
        }
        string.append("]");
        return string.toString();
    }


    /**
     * This method adds an element to the queue.
     * The element is added at the end.
     *
     * @param item Element to add.
     */
    public void enqueue(T item) {
        // Add element
        data.add(item);
    }


    /**
     * This method removes the first element of the queue.
     *
     * @return The first element of the stack.
     */
    public T dequeue() {
        // Make sure the stack is not empty
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }

        // Remove element
        return data.remove(0);
    }


    /**
     * This method checks if the queue is empty.
     *
     * @return True if the queue is empty, False otherwise.
     */
    public boolean isEmpty() {
        // Check data size
        return data.isEmpty();
    }

    /**
     * This is the entry point of your program.
     * It contains the first codes that are going to be executed.
     *
     * @param args Command line arguments received.
     */
    public static void main(String[] args) {
        // A few tests
        Queue<Integer> queue = new Queue<>();
        queue.enqueue(1);
        System.out.println(queue);
        queue.enqueue(2);
        System.out.println(queue);
        queue.enqueue(3);
        System.out.println(queue);
        int element = queue.dequeue();
        System.out.println(element + " " + queue);
        element = queue.dequeue();
        System.out.println(element + " " + queue);
        element = queue.dequeue();
        System.out.println(element + " " + queue);
    }

}

/**
 * To run this code, you need to have Java installed on your computer, then:
 * - Create a file named `Main.java` in a directory of your choice.
 * - Copy this code in the file.
 * - Open a terminal in the directory where the file is located.
 * - Run the command `javac Main.java` to compile the code.
 * - Run the command `java -ea Main` to execute the compiled code.
 * Note: '-ea' is an option to enable assertions in Java.
 */

// Needed imports

/**
 * This class represents a node in a doubly linked list.
 * Each node contains data, a reference to the next node, and a reference to the previous node.
 * This class should be put in a file named 'Node.java'.
 */
class Node<T> {

    /**
     * Here are the attributes we need to define for data and the number of elements.
     */
    T data;
    Node<T> next;
    Node<T> prev;


    /**
     * This is the constructor of the class.
     * It initializes a node with the given data.
     *
     * @param data Data to store in the node.
     */
    public Node(T data) {
        // Here we initialize the node with the given data
        this.data = data;
        this.next = null;
        this.prev = null;
    }

}


/**
 * This is a possible implementation of a queue using a doubly linked list.
 * The queue can grow dynamically as elements are added.
 * This class should be put in a file named 'Queue.java'.
 */
public class Queue<T> {

    /**
     * Here are the attributes we need to define for the front, rear, and the number of elements.
     */
    private Node<T> front;
    private Node<T> rear;
    private int nbElements;


    /**
     * This is the constructor of the class.
     * It initializes an empty queue using a doubly linked list.
     */
    public Queue() {
        // Here we initialize the queue with no elements
        this.front = null;
        this.rear = null;
        this.nbElements = 0;
    }


    /**
     * This method returns a string representation of the queue.
     *
     * @return A string representation of the queue.
     */
    public String toString() {
        // Create string
        StringBuilder string = new StringBuilder("[");
        Node<T> current = front;
        while (current != null) {
            string.append(current.data).append(", ");
            current = current.next;
        }
        if (nbElements > 0) {
            string.setLength(string.length() - 2);
        }
        string.append("]");
        return string.toString();
    }


    /**
     * This method adds an element to the queue.
     * The element is added at the rear, and the counter is incremented.
     *
     * @param item Element to add.
     */
    public void enqueue(T item) {
        // Create a new node with the item
        Node<T> newNode = new Node<>(item);

        // Link the new node with the current rear node
        if (rear != null) {
            rear.next = newNode;
            newNode.prev = rear;
        }

        // Set the new node as the rear node
        rear = newNode;

        // If the queue was empty, set the front to the new node
        if (front == null) {
            front = newNode;
        }

        // Increment the number of elements
        nbElements++;
    }


    /**
     * This method removes the front element of the queue.
     * The element is removed and the counter is decremented.
     *
     * @return The front element of the queue.
     */
    public T dequeue() {
        // Make sure the queue is not empty
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }

        // Remove the front element
        T element = front.data;
        front = front.next;
        if (front != null) {
            front.prev = null;
        } else {
            rear = null;
        }

        // Decrement the number of elements
        nbElements--;
        return element;
    }


    /**
     * This method checks if the queue is empty.
     *
     * @return True if the queue is empty, False otherwise.
     */
    public boolean isEmpty() {
        // Check if the queue is empty
        return nbElements == 0;
    }

    /**
     * This is the entry point of your program.
     * It contains the first codes that are going to be executed.
     *
     * @param args Command line arguments received.
     */
    public static void main(String[] args) {
        // A few tests
        Queue<Integer> queue = new Queue<>();
        queue.enqueue(1);
        System.out.println(queue);
        queue.enqueue(2);
        System.out.println(queue);
        queue.enqueue(3);
        System.out.println(queue);
        int element = queue.dequeue();
        System.out.println(element + " " + queue);
        element = queue.dequeue();
        System.out.println(element + " " + queue);
        element = queue.dequeue();
        System.out.println(element + " " + queue);
    }

}

// Needed imports
import java.util.Scanner;



/**
 * To run this code, you need to have Java installed on your computer, then:
 * - Create a file named `Main.java` in a directory of your choice.
 * - Copy this code in the file.
 * - Open a terminal in the directory where the file is located.
 * - Run the command `javac Main.java` to compile the code.
 * - Run the command `java -ea Main` to execute the compiled code.
 * Note: '-ea' is an option to enable assertions in Java.
 */
public class Main
{

    /**
     * This is the entry point of your program.
     * It contains the first codes that are going to be executed.
     * 
     * @param args Command line arguments received.
     */
    public static void main (String[] args)
    {
        // Initialize the queue
        Queue<Character> queue = new Queue<>();

        // Read input from user
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a name of a city (e.g., Brest): ");
        String sentence = scanner.nextLine();
        scanner.close();

        // Add elements inside
        for (char c : sentence.toCharArray())
        {
            queue.enqueue(c);
            System.out.println("Added: " + c + " ==> Queue: " + queue);
        }

        // Remove elements from the queue
        while (!queue.isEmpty())
        {
            System.out.println("Delete: " + queue.dequeue() + " ==> Queue: " + queue);
        }
    }
    
}