[已解决]循环队列

zsxxn

请编程完成泛型类CircularQueue（循环队列），CircularQueue的基本功能设计要求：创建循环队列、入队、出队、获取队头元素、判队空、获取队列元素个数，并测试全部功能

最佳答案

月排行榜 / 总排行榜

isdkz

2023-11-13 17:39:52

public class CircularQueue<T> {
    private int front;
    private int rear;
    private int size;
    private T[] elements;

    public CircularQueue(int capacity) {
        elements = (T[]) new Object[capacity];
        front = 0;
        rear = 0;
        size = 0;
    }

    public void enqueue(T element) {
        if (size == elements.length) {
            throw new IllegalStateException("Queue is full");
        }
        elements[rear] = element;
        rear = (rear + 1) % elements.length;
        size++;
    }

    public T dequeue() {
        if (size == 0) {
            throw new NoSuchElementException("Queue is empty");
        }
        T element = elements[front];
        elements[front] = null;
        front = (front + 1) % elements.length;
        size--;
        return element;
    }

    public T getFront() {
        if (size == 0) {
            throw new NoSuchElementException("Queue is empty");
        }
        return elements[front];
    }

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

    public int size() {
        return size;
    }
}

public class Main {
    public static void main(String[] args) {
        CircularQueue<Integer> queue = new CircularQueue<>(5);
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        System.out.println(queue.dequeue()); // Output: 1
        System.out.println(queue.getFront()); // Output: 2
        System.out.println(queue.isEmpty()); // Output: false
        System.out.println(queue.size()); // Output: 2
    }
}

跳转到最佳答案楼层

isdkz

public class CircularQueue<T> {
    private int front;
    private int rear;
    private int size;
    private T[] elements;

    public CircularQueue(int capacity) {
        elements = (T[]) new Object[capacity];
        front = 0;
        rear = 0;
        size = 0;
    }

    public void enqueue(T element) {
        if (size == elements.length) {
            throw new IllegalStateException("Queue is full");
        }
        elements[rear] = element;
        rear = (rear + 1) % elements.length;
        size++;
    }

    public T dequeue() {
        if (size == 0) {
            throw new NoSuchElementException("Queue is empty");
        }
        T element = elements[front];
        elements[front] = null;
        front = (front + 1) % elements.length;
        size--;
        return element;
    }

    public T getFront() {
        if (size == 0) {
            throw new NoSuchElementException("Queue is empty");
        }
        return elements[front];
    }

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

    public int size() {
        return size;
    }
}

public class Main {
    public static void main(String[] args) {
        CircularQueue<Integer> queue = new CircularQueue<>(5);
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        System.out.println(queue.dequeue()); // Output: 1
        System.out.println(queue.getFront()); // Output: 2
        System.out.println(queue.isEmpty()); // Output: false
        System.out.println(queue.size()); // Output: 2
    }
}

Mike_python小

很高兴能帮助你完成泛型类CircularQueue的编程任务。以下是根据你的要求编写的Java代码：

[/code]java
public class CircularQueue<T> {
    private T[] queue;
    private int capacity;
    private int size;
    private int head;
    private int tail;

    // 创建循环队列
    public CircularQueue(int capacity) {
        this.capacity = capacity;
        queue = (T[]) new Object[capacity];
        size = 0;
        head = 0;
        tail = 0;
    }

    // 入队
    public void enqueue(T item) {
        if (size == capacity) {
            throw new RuntimeException("Queue is full");
        }
        queue[tail] = item;
        tail = (tail + 1) % capacity;
        size++;
    }

    // 出队
    public T dequeue() {
        if (size == 0) {
            throw new RuntimeException("Queue is empty");
        }
        T item = queue[head];
        queue[head] = null;
        head = (head + 1) % capacity;
        size--;
        return item;
    }

    // 获取队头元素
    public T peek() {
        if (size == 0) {
            throw new RuntimeException("Queue is empty");
        }
        return queue[head];
    }

    // 判队空
    public boolean isEmpty() {
        return size == 0;
    }

    // 获取队列元素个数
    public int size() {
        return size;
    }

    // 测试方法
    public static void main(String[] args) {
        CircularQueue<Integer> queue = new CircularQueue<>(5);

        // 入队
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(5);

        // 输出队列状态
        System.out.println("队列元素个数：" + queue.size());
        System.out.println("队头元素：" + queue.peek());

        // 出队
        System.out.println("出队元素：" + queue.dequeue());
        System.out.println("出队元素：" + queue.dequeue());

        // 输出队列状态
        System.out.println("队列元素个数：" + queue.size());
        System.out.println("队头元素：" + queue.peek());

        // 再次入队
        queue.enqueue(6);
        queue.enqueue(7);

        // 输出队列状态
        System.out.println("队列元素个数：" + queue.size());
        System.out.println("队头元素：" + queue.peek());

        // 判断队列是否为空
        System.out.println("队列是否为空：" + queue.isEmpty());
    }
}
[/code]

在以上代码中，我们定义了一个泛型类CircularQueue，它使用一个数组来表示循环队列。通过构造函数指定队列的容量，然后实现了入队、出队、获取队头元素、判队空和获取队列元素个数等基本功能。在测试方法中，我们创建了一个循环队列对象，并对其进行了一系列操作，以验证其功能的正确性。

请注意，为了确保我们可以在代码中使用泛型数组，我们使用了类型转换 (T[]) new Object[capacity]。这种方式在编译时会产生警告，但我们可以确保在代码运行时不会出现类型转换错误。

希望以上代码能满足你的要求，如有任何疑问，请随时询问。