数据结构之队列

数据结构分为：线性结构，非线性结构

线性结构：队列，链表，栈，

非线性结构：树，图

 

 

队列：

1. 队列是个有序线性表，一般有数组或链表实现
2. 队列遵循先入先出（FIFO）原则

结构示意图：

 

使用数组模拟队列：

class ArrayQueue{
    private int maxsize;　　　　　　　　　　　　//队列大小

    private int front;　　　　　　　　　　　　  //指向队列第一个元素的前一个位置
    private int rear;　　　　　　　　　　　　　　//指向队列最后一个元素
    private int[] arr;
    public ArrayQueue(int maxsize) {
        this.maxsize = maxsize;
        arr = new int[maxsize];
        front = -1;
        rear = -1;
    }
    public boolean isfull() {　　　　　　　　　　//队列判满方法   当后引为最大值 即队列已经排到最后一个元素时 为满 即 maxsize == rear
        return (maxsize == rear);
    }
    public boolean isempty() {　　　　　　　　　//队列判空方法
        return (front == rear);
    }
    public void addQueue(int val) {　　　　　　//队列添加元素，后端＋1 后移一位 然后把元素添加到该位置
        if(isfull()) {
            System.out.println("the queue is full");
            return;
        }
        rear++;    
        arr[rear] = val;
        
    }
    public int getQueue() {
        if(isempty()) {
            throw new RuntimeException("the queue is empty");
            }
        front++;　　　　　　　　　　　　　　　　　　//元素出队列 前端后移一位 
        return arr[front];
    }
    public void showQueue() {
        if(isempty()) {
            System.out.println("the queue is empty");
            }
        for(int i = front+1; i <= rear; i++)
            System.out.printf("arr[%d] = %d\n",i,arr[i]);
    }
    public int HeadQueue() {
        if(isempty()) {
            throw new RuntimeException("the queue is empty");
            }
        return arr[front+1];
    }
}

使用数组模拟队列存在一个问题，即当队列满的时候，后端到达数组最大位置，当元素出队列时，前端后移，但是数组中前端之前的内存空间就不能再存数据了，造成资源浪费，且队列效率低，因此一般使用数组模拟环形队列。

 

数组实现环形队列：

1. front改为指向队列的第一个元素
2. rear改为指向队列的最后一个元素的后一个位置
3. 判定队列满的条件 (rear + 1 )%maxsize == front
4. 判空条件  rear == front
5. 队列中元素个数  (rear - front + maxsize) % maxsize
6. rear front 初始值为0

实现如下：

class CircleQueue{
    private int maxsize;
    private int front;
    private int rear;
    private int[] arr;

    public CircleQueue(int maxsize) {
        this.maxsize = maxsize;
        front = 0;
        rear = 0;
        arr = new int[maxsize];
        
    }
    public boolean isfull() {
        return (rear+1)%maxsize == front;
    }
    public boolean isempty() {
        return rear == front;
    }
    public void addCircleQueue(int val) {
        if(isfull()) {
            System.out.println("队列已满");
            return;
        }
        arr[rear] = val;
        rear = (rear + 1) % maxsize;
    }
    
    public int getCircleQueue() {
        if(isempty()) {
            throw new RuntimeException("队列为空");
        }
        int val = arr[front];
        front = (front + 1) % maxsize;
        return val;
    }
    
    public void showCircleQueue() {
        if(isempty()) {
            throw new RuntimeException("队列为空");
        }
        for(int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d] = %d\n",i%maxsize,arr[i%maxsize]);
        }
    }
    public int size() {
        return (rear + maxsize - front) % maxsize;
    }
}