数据结构(2)：队列

数据结构之队列知识点

1、静态队列（用数组实现）

实现静态队列，我们往往都是做成循环队列，因为这样不会浪费内存资源。

图片来自于红黑联盟。

在设计尾指针rear的时候，并不指向最后一个有效的元素，在循环队列中这样设计是很方便的！因为这样设计可以让我们分得清队头和队尾。

为了防止假溢出，使用front=front%size和rear=(rear+1)%size算法。

代码实现：

public class ArrayQueueDemo {
    private int arr[];
    private int size;//队列的最大容量
    private int items;//队列中实际数据的数量
    private int front;//头指针
    private int rear;//尾指针
    public ArrayQueueDemo() {
        //未设定最大容量时，默认最大容量是20
        this(20);
    }
    //初始化
    public ArrayQueueDemo(int maxSize) {
        this.arr = new int[maxSize];
        this.size = maxSize;
        this.items = 0;
        this.front = 0;
        this.rear = 0;
    }
    //入队
    public boolean push(int data) {
        //判断队列是否已满
        if(isFull()) {
            System.out.println("队列已满。");
            return false;
        }
        arr[rear % size] = data;
        rear = (rear + 1) % size;
        items ++;
        return true;
    }
    //出队
    public int pop() {
        //判断队列是否为空
        if(isEmpty()) {
            System.out.println("队列为空。");
            return -1;
        }
        front = front % size;
        items --;
        return arr[front--];
    }
    //遍历队列
    public void traverseQueue() {
        for(int i = 0;i < items;i++ ) {
            System.out.println(arr[i]);
        }
    }
    //得到队列的数据的个数
    public int size() {
        return items;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return items == 0;
    }
    //判断队列是否已满
    public boolean isFull() {
        return items == size;
    }
}

2、动态队列（用链表实现）

代码实现：

public class LinkedQueueDemo {
    //定义头结点
    private OtherNode front;
    //定义尾节点
    private OtherNode rear;
    //队列中数据的数目
    private int size;
    //初始化
    public LinkedQueueDemo() {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }
    //入队
    public void add(int data) {
        OtherNode OtherNode= new OtherNode(data);
        if(front == null) {
            front = rear = OtherNode;
        }
        //插入尾巴
        rear.next = OtherNode;
        //将尾指针指向新的节点
        rear = OtherNode;
        size++;
    }
    //出队
    public int out() {
        //判断队列是否为空
        if(size == 0) {
            System.out.println("队列为空。");
            return -1;
        }
        int i = front.data;
        front = front.next;
        size--;
        return i;
    }
    //遍历队列
    public void traverseQueue() {
        //定义一个新节点用于遍历
        OtherNode currentOtherNode = front;
        while(currentOtherNode != null) {
            System.out.println(currentOtherNode.data);
            currentOtherNode = currentOtherNode.next;
        }
    }
    //得到队列的长度
    public int size() {
        return size;
    }
}
//定义节点
class OtherNode {
    public int data;
    //指向下一个节点
    public OtherNode next;
    public OtherNode(int data) {
        this.data = data;
    }
}

后续如有更优的方法，会继续补充。