队列

最新推荐文章于 2024-12-01 23:55:34 发布

原创最新推荐文章于 2024-12-01 23:55:34 发布 · 249 阅读

0 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了队列这一数据结构的抽象数据类型定义，并通过顺序存储和链式存储两种方式实现了队列。包括队列的基本操作如入队、出队等，并提供了完整的Java代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这里写图片描述

1.抽象数据类型

这里写图片描述

/**
 * 
 * 队列接口
 *
 */
public interface Queue {
    //返回队列大小
    public int getSize();
    //判断是否为空
    public boolean isEmpty();
    //e入队
    public void enqueue(Object e);
    //队首元素出队
    public Object dequeue() throws QueueEmptyException;
    //取队首元素
    public Object peek() throws QueueEmptyException;
}

class QueueEmptyException extends RuntimeException{
    public QueueEmptyException(String err) {
        super(err);
    }
}

2.顺序存储实现

这里写图片描述

/**
 * 
 * 队列的顺序存储
 *
 */
public class QueueArray implements Queue {

    private static final int CAP = 7;//默认大小
    private Object[] elements;
    private int capacity;//数组大小
    private int front;//队首指针
    private int rear;//队尾指针

    public QueueArray() {
        this(CAP);
    }
    public QueueArray(int cap) {
        capacity = cap+1;
        elements = new Object[capacity];
        front = rear = 0;
    }

    @Override
    public int getSize() {
        return (rear - front + capacity) % capacity;
    }

    @Override
    public boolean isEmpty() {
        return front == rear;
    }

    @Override
    public void enqueue(Object e) {
        if(getSize() == capacity-1){
            expandSpace();
        }
        elements[rear] = e;
        rear = (rear + 1)%capacity;
    }
    private void expandSpace(){
        Object[] a = new Object[elements.length*2];
        int i=front;
        int j=0;
        while(i != rear){
            a[j++] = elements[i];
            i = (i+1)%capacity;
        }
        elements = a;
        capacity = elements.length;
        front = 0;
        rear = j;
    }

    @Override
    public Object dequeue() throws QueueEmptyException {
        if(isEmpty()){
            throw new QueueEmptyException("错误，队列为空");
        }
        Object obj = elements[front];
        elements[front] = null;
        front  = (front+1)%capacity;
        return obj;
    }

    @Override
    public Object peek() throws QueueEmptyException {
        if(isEmpty()){
            throw new QueueEmptyException("错误，队列为空");
        }
        return elements[front];
    }

}

3.队列的链式存储

这里写图片描述

/**
 * 
 * 队列的链式存储实现
 *
 */
public class QueueSLinked implements Queue {

    private SLNode front;
    private SLNode rear;
    private int size;

    public QueueSLinked() {
        front = new SLNode();
        rear = front;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

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

    @Override
    public void enqueue(Object e) {
        SLNode p = new SLNode(e,null);
        rear.setNext(p);
        rear = p;
        size++;
    }

    @Override
    public Object dequeue() throws QueueEmptyException {
        if(size < 1){
            throw new QueueEmptyException("错误，队列为空");
        }
        SLNode p = front.getNext();
        front.setNext(p.getNext());
        size--;
        if(size < 1){
            rear = front;
        }
        return p.getData();
    }

    @Override
    public Object peek() throws QueueEmptyException {
        if(size < 1){
            throw new QueueEmptyException("错误，队列为空");
        }
        return front.getNext().getData();
    }

}