[数据结构与算法]08 队列( Queue )以及队列实现的三种方式( Java 版)

队列

说队列的时候,常常会想到栈,因为栈是后进先出,而队列则是先进先出.
关于栈,前面已经写过了:[数据结构与算法]05 Stack 经典面试题之判断字符串是否合法( Java 版)
这篇文章的主要焦点就在队列上了.

队列,你的第一反应是不是排队?不管是在食堂买饭,还是在银行办理业务,或者进高铁站的时候,都会排队.
排队有一个很明显的特点:早来的人,就会早点儿办完事情.
这就是队列:先进先出.

队列可以用数组实现,叫做顺序队列.也可以用链表实现,叫做链式队列.
在这里,分别用数组和链表来实现一下.

数组实现队列

使用数组来实现队列,相对来说还是比较简单的,因为数组和队列一样都是线性表结构.
废话不多说,咱们直接看代码

/**
 * 用数组实现队列
 * @author 郑璐璐
 * @date 2020-1-29 15:51:32
 */
public class ArrayQueue {
    /**
       数组：items，数组大小：n
     */
    private String[] items;
    private int n = 0;
    /**
       head表示队头下标，tail表示队尾下标
     */
    private int head = 0;
    private int tail = 0;

    /**
       申请一个大小为capacity的数组
     */
    public ArrayQueue(int capacity) {
        items = new String[capacity];
        n = capacity;
    }

    /**
       入队
     */
    public boolean enqueue(String item) {
        // 如果tail == n 表示队列已经满了
        if (tail == n) return false;
        items[tail] = item;
        tail++;
        return true;
    }

    /**
       出队
     */
    public String dequeue() {
        // 如果head == tail 表示队列为空
        if (head == tail) return null;
        String ret = items[head];
        head++;
        return ret;
    }

    public void printAll() {
        for (int i = head; i < tail; i++) {
            System.out.print(items[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayQueue queue=new ArrayQueue(5);
        queue.enqueue("1");
        queue.enqueue("2");
        queue.enqueue("3");
        queue.enqueue("4");
        queue.enqueue("5");
        queue.dequeue();
        queue.enqueue("6");

        queue.printAll();
    }
}

使用数组实现队列有个问题,就是删除不是真的删除,只是在打印的时候将 i 的值指向了 head 而已,但是要删除的数据,仍然在数组中.

链表实现队列

使用链表实现队列也较为简单:

/**
 * 用链表实现队列
 * @author 郑璐璐
 * @date 2020-1-30 09:20:41
 */
public class LinkListQueue {
    /**
        队列的队首和队尾
     */
    private Node head = null;
    private Node tail = null;

    /**
         入队
     */
    public void enqueue(String value) {
        if (tail == null) {
            Node newNode = new Node(value, null);
            head = newNode;
            tail = newNode;
        } else {
            tail.next = new Node(value, null);
            tail = tail.next;
        }
    }

    /**
        出队
     */
    public String dequeue() {
        if (head == null) return null;

        String value = head.data;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        return value;
    }

    public void printAll() {
        Node p = head;
        while (p != null) {
            System.out.print(p.data + " ");
            p = p.next;
        }
        System.out.println();
    }

    private static class Node {
        private String data;
        private Node next;

        public Node(String data, Node next) {
            this.data = data;
            this.next = next;
        }

        public String getData() {
            return data;
        }
    }

    public static void main(String[] args) {
        LinkListQueue queue=new LinkListQueue();
        queue.enqueue("3");
        queue.enqueue("2");
        queue.dequeue();
        queue.printAll();
    }
}

栈实现队列

除了使用数组和链表实现,还有一种方法就是使用栈来实现队列.
使用栈来实现队列,顾名思义就是只能使用栈的操作: pop , push , peek 等,其他操作不允许出现,否则就不是使用栈来实现队列了.
使用数组和链表来实现栈都较为简单,因为在读取数据时,只需要按照顺序读取即可.
但是对于栈来说,顺序读取行不通,为什么呢?假设我的队列数据为 1,2,3,4 依次存入栈中之后再读取的话,则是 4,3,2,1 因为栈是后进先出.
如果使用栈来实现队列的话,需要用到两个栈.一个栈的输出顺序就是 4,3,2,1 在读取之前,我们把读取出来的数据存入到另外一个栈中,然后从后面这个栈读取,那么输出顺序就是 1,2,3,4 和原来队列的数据一致.
在这里要注意一点:当后面的栈中有数据,前面的栈中也有数据时,要先将后面的栈中数据读取完毕,再将前面的数据放到后面的数据中.
接下来看下代码实现:

/**
 * 使用栈实现队列
 * @author 郑璐璐
 * @date 2020-1-30 17:21:19
 */
public class StackQueue {
    private  static Stack<Integer> stackTemp = new Stack<Integer>();
    private static Stack<Integer> stackQueue = new Stack<Integer>();

    /**
       入队
     */
    public void push(int x){
        stackTemp.push(x);
    }

    /**
        出队
     */
    public int pop(){
        // 整个队列不为空时
        if (empty()!=0){
            // 如果 stackQueue 为空时,则将 stackTemp 中的数据放入 stackQueue 中
            // 如果 stackQueue 不为空,直接输出即可
            if (stackQueue.isEmpty()){
                backFill();
            }
            return stackQueue.pop();
        }else {
            // 整个队列为空,则返回 -1 ,代表队列中没有值
            System.out.println("队列为空");
            return -1;
        }
    }
    public int empty(){
        // 判断队列是否为空,如果返回值为 0 ,则代表队列为空
        // 注意,两个栈均为空时,队列才为空
        return stackQueue.size() + stackTemp.size();
    }
    /**
        将 stackTemp 中的数据放入 stackQueue 中
     */
    public void backFill(){
        while (!stackTemp.isEmpty()){
            stackQueue.push(stackTemp.pop());
        }
    }
    public static void main(String[] args){
        StackQueue stack = new StackQueue();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

以上,就是想要分享的内容了
感谢您的阅读哇~