关于JAVA数据结构_队列(通过顺序和链式实现)

2-2 队列

2-2-1 队列的特点及抽象数据类型
队列(Queue)简称为队,也是一种受限的线性表,值允许在线性表的一端进行插入,而在表的另一端进行删除
称插入数据的一端为队尾(rear),称删除数据的一端为队首 (front).
向队列添加数据称为入队或进队,新入队的元素称为队尾元素,在队列中删除元素称为出队或离队,元素出队之后,它的后续元素称为新的队首元素.
队列是一种先进先出(First in First Out 简称 FIFO)
 队列抽象数据类型的定义:
       ADT Queue{
            数据对象:D={a0,a1,a2...an,ai 都是同一数据类型的 元素}
            数据关系:R={ai,ai+1}
            数据操作:
                getSize():返回元素个数
                isEmpty():判断队列是否为空
                enQueue(e):入队
                deQueue():出队
                peek():返回队首的元素

            }ADT Queue

2-2-2 队列的顺序存储实现
在队列的实现中,可以把数组设想成一个圆环,这种数组称为循环数组,用循环数组晒西安的队列称为循环队列
用front指针指向 队首元素所在的单位,使用rear指针指向队尾元素所在的后一个单元
在元素入队时,将新入队的元素保存到rear指向的单元,然后rear指向后移;在出队时,将队首指针指向front指向的元素返回,然后front后移
一般情况下,我们用以下两种方式表示队列已满:
1.少用一个存储单元,当队尾指针rear指向下一个单元是队首指针front时,停止入队,(rear+1)%capacity==front时表示队列已满,当front==rear时表示队列为空
2.增设一个标志表示队列为空还是满,通常用size变量表示元素的个数,当size==0时队列为空,当size==capacity时表示队列已满.

package demo4.queue;
/**
 * 队列的顺序存储实现 通过数组
 * @author ASUS
 *
 */
public class MyArrayQueue {
    private Object[] elements;
    private static final int DEFAULT_CAPACITY=8;
    private int front;
    private int rear;
    private int size;
    
    
    public MyArrayQueue(){
        elements =new Object[DEFAULT_CAPACITY];
        
    }
    public MyArrayQueue(int initialCapacity){
        elements=new Object[initialCapacity];
                
    }
    //返回元素的个数
    public int getSize(){
        return size;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //入队
    public void enQueue(Object e){
        //如果队列已满,数组扩容
        if(size>=elements.length){
            expandQueue();
        }
        elements[rear]=e;           //把元素存储到rear指向的单元
        rear=(rear+1)%elements.length;   //rear指针后移1
        size++;
    }
    //对数组进行扩容
    private void expandQueue() {
        //定义更大的数组
        Object[] newElements=new Object[elements.length*2];
        
        //把原来的内容复制到新数组,从队首开始依次复制到新数组索引0开始的位置
        for(int i=0;i<elements.length;i++){
            newElements[i]=elements[front];
            front=(front+1%elements.length);
                    }
        //把原来的数组名指向新的数组
        elements=newElements;
        //调整新的队首位置
        front=0;
        rear=size;
            }
    //出队
    public Object deQueue(){
        //如果队列为空
        if(size<=0){
            //抛异常
            throw new QueueEmptyException("队列为空");
        }
        //如果队列不为空,把front指向元素返回
        Object old =elements[front];
        front=(front+1)%elements.length;
        size--;
        return old;
    }
    public Object peek(){
        //队列为空,跑异常
        if(size<=0){
            throw new QueueEmptyException("队列为空");
            
        }
        return elements[front];
    }
    
}

package demo4.queue;
/**
 * 测试顺序存储的队列
 * @author ASUS
 *
 */
public class TestQueue {

    public static void main(String[] args) {
        System.out.println("测试顺序存储");
        MyArrayQueue queue=new MyArrayQueue();
        queue.enQueue("a");
        queue.enQueue("b");
        queue.enQueue("c");
        queue.enQueue("d");
        System.out.println(queue.getSize());
        System.out.println(queue.peek());
        System.out.println(queue.deQueue());
        
    }

}

运行截图:

package demo4.queue;
/**
 * 自定义队列为空的异常
 * 该异常为一个运行异常
 * RuntimeException的子类就是运行异常
 * @author ASUS
 *
 */
public class QueueEmptyException extends RuntimeException{

    public QueueEmptyException() {
        super();
        
    }

    
    //String 参数,传递异常的信息
    public QueueEmptyException(String message) {
        super(message);
        
    }

    

    
}

2-2-3 队列的链式存储

package demo4.queue;

/**
 * 队列的链式存储
 * @author ASUS
 *
 */
public class MyLinkQueue {
    private Node front;
    private Node rear;
    private int size;
    
    //返回元素个数
    public int getSize(){
        return size;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //入队
    public void enQueue(Object e){
        //根据添加的元素生成一个结点
        Node newNode=new Node(e,null);
        //把结点连接到队列中
        if(rear==null){
            //这是添加的第一个元素,即是头结点也是尾结点
            rear = newNode;
            front=newNode;
        }else{
            //把结点链拉到尾部
            rear.next=newNode;
            rear=newNode;    //rear指针指向新添加的元素
        }
        size++;  //元素个数加1
    }
    
    //出队
    public Object deQueue(){
        //判断队列是否为空
        if(size<=0){
            throw new QueueEmptyException("队列为空");
        }
        Object old=front.elements;
        front =front.next;
        //如果出队后,队列为空,调整尾指针
        if(front==null){
            rear=null;
        }
        size --;
        return old;        
    }
    //返回队首元素
    public Object peek(){
        if(size<=0){
            throw new QueueEmptyException("队列为空");
            
        }
        return front.elements;
    }
    //通过内部类表示单向链表的结点
    private class Node{
        Object elements;
        Node next;
        public Node(Object elements, Node next) {
            super();
            this.elements = elements;
            this.next = next;
        }
        
    }
    
}

package demo4.queue;
/**
 * 测试顺序存储的队列
 * @author ASUS
 *
 */
public class TestQueue {

    public static void main(String[] args) {
       
        
        System.out.println("测试链式存储");
        MyLinkQueue lqueue=new MyLinkQueue();
        lqueue.enQueue("aa");
        lqueue.enQueue("bb");
        lqueue.enQueue("cc");
        lqueue.enQueue("dd");
        lqueue.enQueue("ee");
        System.out.println(lqueue.getSize());
        //返回队首
        System.out.println(lqueue.peek());
        System.out.println(lqueue.deQueue());
        System.out.println(lqueue.getSize());
        
        
    }

}

运行截图: