java编程队列数据结构代码示例

下面是“Java编程队列数据结构代码示例”的完整攻略。

什么是队列

队列是一种有序的数据结构，特点是先进先出（FIFO）。队列中不管是插入操作还是删除操作，都是在队列的两端进行的，插入操作在队列的尾部进行，删除操作在队列的头部进行。队列的一个重要用途是在计算机的操作系统中，实现进程和所有需要等待资源的实体之间的交互。

队列的实现

队列数据结构可以采用数组或链表两种方式进行实现。

如果使用数组实现队列，需要提前设定一个合理的大小，具有固定的容量，同时需要用一个变量来记录队列当前元素的数量。

如果使用链表实现队列，既可以实现单向链表，也可以实现双向链表。

Java代码示例

下面是一个Java用数组实现的队列数据结构的代码示例：

public class MyQueue {
    private int capacity;   // 队列容量
    private int[] queueArr; // 队列数组
    private int head;       // 队列头部
    private int tail;       // 队列尾部
    private int currentSize;// 队列当前大小

    public MyQueue(int queueSize){
        this.capacity = queueSize;
        queueArr = new int[this.capacity];
        head = 0;
        tail = -1;
        currentSize = 0;
    }

    public void enqueue(int item) {
        if (isQueueFull()) {
            System.out.println("Overflow ! Unable to add element: "+item);
        } else {
            tail++;
            if(tail == capacity-1){
                tail = 0;
            }
            queueArr[tail] = item;
            currentSize++;
            System.out.println("Element " + item+ " is pushed to Queue !");
        }
    }

    public void dequeue() {
        if (isQueueEmpty()) {
            System.out.println("Underflow ! Unable to remove element from Queue");
        } else {
            head++;
            if(head == capacity-1){
                System.out.println("Pop operation done ! removed: "+queueArr[head-1]);
                head = 0;
            } else {
                System.out.println("Pop operation done ! removed: "+queueArr[head-1]);
            }
            currentSize--;
        }
    }

    public boolean isQueueFull(){
        boolean status = false;
        if (currentSize == capacity){
            status = true;
        }
        return status;
    }

    public boolean isQueueEmpty(){
        boolean status = false;
        if (currentSize == 0){
            status = true;
        }
        return status;
    }
}

这个队列数据结构的实现包括一下功能：

• 创建队列
• 向队列尾部加入元素
• 从队列头部删除元素
• 判断队列是否已满
• 判断队列是否为空

下面是例子：

MyQueue queue = new MyQueue(5);
queue.enqueue(12);
queue.enqueue(22);
queue.enqueue(32);
queue.enqueue(42);
queue.dequeue();
queue.dequeue();

这个例子向队列中加入了四个元素（12，22，32和42），然后将前两个元素删除。最后队列中应该有两个元素（32和42）。

下面是Java用链表实现的队列数据结构的代码示例：

public class MyQueue {  
    private ListNode front;  
    private ListNode rear;  
    private int length;  

    private class ListNode {  
        int val;  
        ListNode next;  

        ListNode(int x) {  
            val = x;  
            next = null;  
        }  
    }  

    public MyQueue(){  
        front = null;  
        rear = null;  
        length = 0;  
    }  

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

    public int peek(){  
        if (isEmpty()) {  
            throw new RuntimeException("Queue underflow!");  
        }  
        return front.val;  
    }  

    public void enqueue(int n){  
        ListNode newNode = new ListNode(n);  
        if (rear == null) {  
            front = newNode;  
            rear = newNode;  
        }else {  
            rear.next = newNode;  
            rear = newNode;  
        }  
        length++;  
    }  

    public int dequeue(){  
        if (isEmpty()) {  
            throw new RuntimeException("Queue underflow!");  
        }  
        int result = front.val;  
        front = front.next;  
        if (front == null) {  
            rear = null;  
        }  
        length--;  
        return result;  
    }  
}  

这个队列数据结构的实现包括一下功能：

• 创建队列
• 判断队列是否为空
• 返回队列顶部元素
• 将元素添加到队列尾部
• 从队列头部删除元素

下面是一个例子：

MyQueue queue = new MyQueue();
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
System.out.println("Dequeue Operation : Dequeued Element : "+queue.dequeue());

在这个例子中，我们向这个队列中添加了三个元素（10、20和30），然后删除了队列中的第一个元素10。此时队列中应该有两个元素（20和30）。

希望这个攻略对你有所帮助！