数据结构--队列的实现详解

一、队列的概念

只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特性FIFO(First In First Out) ，入队列：进行插入操作的一端称为队尾（Tail/Rear），出队列：进行删除操作的一端称为队头 （Head/Front）。完整代码放在文章的末尾。

由图可以更好的理解概念 ，在队尾端进行入队操作，在队头的一段进行出队列操作。

二.使用双向链表实现队列

实现思想

利用双向链表的性质，在进行入队操作时在链表的末尾进行插入操作，出队列操作时通过链表头部进行出队列操作。实现一端插入，一端删除。

代码实现

1.定义队列类型

a.定义内部类（链表的节点类）

b.链表的头节点和末尾节点放在链表节点类的外部。（不放在外部会导致每个节点都设置成头节点和尾节点）。

public class MyQueue {    
    public class ListNode {
        public int value;
        public ListNode prev;//前驱节点
        public ListNode next;//下一个节点
        //构造方法
        public ListNode(int value) {
            this.value = value;
        }
    }
    public ListNode head;//头节点
    public ListNode last;//末尾节点
    int size = 0;//元素个数
}

2.判空操作

当链表没有元素时，则队列为空，即队列首元素为空。

    public boolean empty() {
        return head == null;
    }

3.入队操作

首先对链表进行判空操作，链表为空，则需要入队的数据既作为链表的头节点，又是链表的尾节点。

        //实例化一个节点，存放value
        ListNode node = new ListNode(value);
        //如果队列为空，放入的数据既是头节点，又是尾节点
        if(empty()) {
            head = last = node;
            size++;
        }

 否则队列不为空，将节点node插入到双向链表的末尾。让链表的尾节点（last节点）后插入node节点，同时队列元素＋1。

else {
            //从队尾入队列
            last.next = node;
            node.prev = last;
            last = node;
            size++;
        }

 这里的插入是让last节点的下一个节点是node节点，node的前驱节点等于last节点，node节点最后作为尾节点，这样元素的入队操作就结束了。

4.出队操作

首先对链表进行判空，如果链表为空，则队列为空。

//队列为空直接返回-1
        if(empty()) {
            System.out.println("队列为空");
            return -1;
        }

 队列不为空，但只有一个节点的时候，进行出队操作时，先拿到节点的值，然后要将头节点和尾节点置空（不置空元素任然留在链表中）,完成出队操作。

//队列不为空,只有一个节点的情况，出队列后将队列置为空
        int value;
        if(head.next == null) {
            value = head.value;
            head = null;
            last = null;
            size--;
            return value;
        }

 队列有多个节点,先拿到头节点的值，然后头节点往后走，将新的头节点的前驱节点置为0。此时，原来的头节点被回收，返回拿到的值，完成出队操作。

value = head.value;
        //head节点向后走
        head = head.next;
        //head的前驱节点置空
        head.prev = null;
        size--;
        return value;

5.拿到队列首部的元素

队列为空，直接返回-1，队列不为空，直接返回链表头部的值。

 public int peek() {
        //拿到第一个出队列的元素
        if(head == null) {
            System.out.println("队列为空");
            return -1;
        }
        return head.value;
    }

三、使用两个栈实现队列

代码思想

利用栈的性质，后进先出，利用两个栈互相弹出和增加数据来实现队列的入队，出队等基本操作。

代码实现

1.定义队列类型

定义两个栈，在实例化时默认实例化两个栈

public class MyQueue {
    //使用两个栈实现队列
    private Stack<Integer> s1;
    private Stack<Integer> s2;
    //实例化时，默认创建两个队列
    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
}

2.判空操作

如果两个栈都为空，则队列为空。

    public boolean empty() {
        //当两个栈都没有元素时，队列为空
        return s1.isEmpty()&& s2.isEmpty();
    }

3.入队操作

栈s1是入队操作的栈，直接将元素放入栈s1中完成入队列操作。

    //入队操作
    public void offer(int value) {
        s1.push(value);
    }

4.出队操作

进行出队操作，首先进行队列的判空操作，若果是空队列，没有元素，不需要出队操作，这里返回-1。

public int poll() {
        //判断队列是否为空,空队列没有元素出队
        if(empty()) {
            System.out.println("队列是空的。。。");
            return -1;
        }

 队列不为空，当栈s2是空栈时，进入while循环，弹出栈s1的元素放入栈s2中，然后弹出栈s2的元素。栈s2不为空，则不进入循环，直接弹出栈s2的元素并返回。

        //队列不为空，进行入栈操作
        //将s1的元素放入s2中，由s2进行出队操作
        //前提是s2内没有元素，否则s2直接出队列
        if(s2.isEmpty()) {
            //s1为空则循环结束
            while (!s1.isEmpty()) {
                s2.push(s1.pop());
            }
        }
        return s2.pop();

 5.拿到队列首部元素

和出队思想差不多，不同的是这里栈s2不需要弹出元素，只需要拿到栈顶元素即可,这里不过多介绍了。

    //拿到队顶元素
    public int peek() {
        if(empty()) {
            System.out.println("队列为空");
            return -1;
        }
        if(s2.isEmpty()) {
            while (s1.isEmpty()) {
                s2.push(s1.pop());
            }
        }
        return s2.peek();
    }

四、全部代码

1.使用双向链表实现队列

public class MyQueue {
    //队列，从队尾插入数据，队头删除数据的一种数据结构
    //这里使用双向链表来实现队列
    //首先定义双线链表的节点
    public class ListNode {
        public int value;
        public ListNode prev;//前驱节点
        public ListNode next;//下一个节点
        //构造方法
        public ListNode(int value) {
            this.value = value;
        }
    }
    public ListNode head;//头节点
    public ListNode last;//末尾节点
    int size = 0;//元素个数
    //入队操作
    public void offer(int value) {
        //实例化一个节点，存放value
        ListNode node = new ListNode(value);
        //如果队列为空，放入的数据既是头节点，又是尾节点
        if(empty()) {
            head = last = node;
            size++;
        }else {
            //从队尾入队列
            last.next = node;
            node.prev = last;
            last = node;
            size++;
        }
    }
    //出队操作
    public int poll() {
        //队列为空直接返回-1
        if(empty()) {
            System.out.println("队列为空");
            return -1;
        }
        //队列不为空,只有一个节点的情况，出队列后将队列置为空
        int value;
        if(head.next == null) {
            value = head.value;
            head = null;
            last = null;
            size--;
            return value;
        }
        value = head.value;
        //head节点向后走
        head = head.next;
        //head的前驱节点置空
        head.prev = null;
        size--;
        return value;
    }
    //队列判空
    public boolean empty() {
        return head == null;
    }
    public int peek() {
        //拿到第一个出队列的元素
        if(head == null) {
            System.out.println("队列为空");
            return -1;
        }
        return head.value;
    }
    //拿到队列元素个数
    public int getSize() {
        return size;
    }
}

2.使用两个栈实现队列

import java.util.Stack;

public class MyQueue {
    //使用两个栈实现队列
    private Stack<Integer> s1;
    private Stack<Integer> s2;
    //实例化时，默认创建两个队列
    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    //判空操作
    public boolean empty() {
        //当两个栈都没有元素时，队列为空
        return s1.isEmpty()&& s2.isEmpty();
    }
    //入队操作
    public void offer(int value) {
        s1.push(value);
    }
    //出队操作
    //利用栈的特性
    public int poll() {
        //判断队列是否为空,空队列没有元素出队
        if(empty()) {
            System.out.println("队列是空的。。。");
            return -1;
        }
        //队列不为空，进行入栈操作
        //将s1的元素放入s2中，由s2进行出队操作
        //前提是s2内没有元素，否则s2直接出队列
        if(s2.isEmpty()) {
            //s1为空则循环结束
            while (!s1.isEmpty()) {
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }
    //拿到队顶元素
    public int peek() {
        if(empty()) {
            System.out.println("队列为空");
            return -1;
        }
        if(s2.isEmpty()) {
            while (s1.isEmpty()) {
                s2.push(s1.pop());
            }
        }
        return s2.peek();
    }
}

到这里便结束了，感谢观看，有问题欢迎在评论区留言。