6.1 队列的链表实现 Java版

1.什么是队列？

队列和栈不同，它是一个先进先出表，它的特性是先进先出,先被存进的元素先被取出。

我们可以使用数组去实现队列，但是对于数组实现而言，队列用链表来实现更为简单。

2.应用

• 操作系统的顺序任务调度
• 模拟现实世界中的队列
• 多道程序设计
• 异步数据传输
• 作为辅助数据结构(二叉树层次遍历)

3.Java实现

3.1 基于链表的实现

首先定义队列接口：

public interface Queue {

    boolean isEmpty();

    boolean isFull();

    int size();

    void offer(int data);

    int poll();

}

然后是队列的链表实现

/**
 * 链表实现队列
 */
public class LinkQueue implements Queue{


    //队列头部
    Node head;
    // 队列尾部
    Node tail;
    // 队列元素数量
    int size;
    // 队列容量
    int capacity;

    static class Node {
        int data;
        Node next;
        Node(int data){
            this.data = data;
        }
    }

    public LinkQueue() {
        this.capacity = 16;
        this.size = 0;
    }

    public LinkQueue(int capacity){
        this.capacity = capacity;
        this.size = 0;
    }


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

    @Override
    public boolean isFull() {
        return size == capacity;
    }

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

    @Override
    public void offer(int data) {
        if(head==null){
            head = new Node(data);
            tail = head;
            size++;
        }
        else{
            if(isFull()){
                System.out.println("queue is Full!!");
            }else{
                tail.next = new Node(data);
                tail = tail.next;
                size++;
            }
        }
    }

    @Override
    public int poll() {
        int res  = -1;
        if(isEmpty()) {
            System.out.println("queue is empty!!");
        }
        else{
            res = head.data;
            head = head.next;
            size--;
        }
        return res;
    }

}

性能表：

操作	时间复杂度	空间复杂度
offer()	O(1)	O(n)
poll()	O(1)	O(1)
size()	O(1)	O(1)
isEmpty()	O(1)	O(1)
isFull()	O(1)	O(1)

测试方法：

import org.junit.Assert;
import org.junit.Test;

import java.util.ArrayDeque;
import java.util.Optional;
import java.util.Queue;
import java.util.Random;

public class QueueTest {

    private final Queue<Integer> rightQueue = new ArrayDeque<>();


    @Test
    public void queueTest(){
        LinkQueue queue = new LinkQueue(100);
        for (int i=0;i<1000;i++){
            boolean active = new Random().nextBoolean();
            if(active){
                rightQueue.offer(i);
                queue.offer(i);
            }else {
                Assert.assertEquals(rightQueue.isEmpty(),queue.isEmpty());
                if(!rightQueue.isEmpty()){
                    Assert.assertEquals(Optional.ofNullable(rightQueue.poll()),Optional.of(queue.poll()));
                }
            }
        }
    }
}

运行结果：(没有任何报错)

Process finished with exit code 0