一起学数据结构与算法深度学习队列

Posted 摸鱼王胖嘟嘟

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了一起学数据结构与算法深度学习队列相关的知识，希望对你有一定的参考价值。

目录

一、什么是队列？

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 – 来源百度

队头(front)：允许删除的一端，称为队首
队尾(rear)：允许插入的一端
空队列：不包含任何元素的空表

二、 队列的基本操作

在Java中，Queue是个接口，底层是通过链表来实现的。

  • offer：入队若队列未满，将x加入，使之称为新的队尾。
  • poll：出队，若队列未空，删除队头元素，并用x返回。
  • peek：获取队头元素，若队列未空，则将队头元素赋值给x。
  • isEmpty：判断队列是否为空，若队列为空返回true，否则返回false。
  • size：获取队列中有效元素个数

  • 2.1 offer - 入队

    public class Test 
    public static void main(String[] args) 
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        System.out.println(queue);

    2.2 poll - 出队

    public class Test 
    public static void main(String[] args) 
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        System.out.println(queue);
        queue.poll();
        queue.poll();
        System.out.println(queue);

    2.3 peek - 获取队头元素

    public static void main(String[] args) 
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        
        System.out.println(queue.peek());

    2.4 isEmpty - 判断队列是否为空

    public static void main(String[] args) 
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        System.out.println(queue.peek());
        System.out.println(queue.isEmpty());

    2.5 size - 获取队列长度

    public static void main(String[] args) 
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        System.out.println(queue.peek());
        System.out.println(queue.isEmpty());
        System.out.println(queue.size());

    三、队列的模拟实现

    3.1 isEmpty

    public boolean isEmpty() 
        return this.head == null;

    3.2 offer

    /**
     * 尾插法
     * @param val
     */
    public void offer(int val) 
        Node node = new Node(val);
        if (head == null) 
            head = node;
            last = node;
         else 
            last.next = node;
            last = last.next;

    3.3 poll

    /**
     * 出队
     * @return
     */
    public int poll() 
        if (isEmpty()) 
            throw new RuntimeException("队列为空");
        
        int oldVal = head.val;
        this.head = head.next;
        return oldVal;

    3.4 peek

     public int peek() 
        if (isEmpty()) 
            throw new RuntimeException("队列为空");
        
        return head.val;

    3.5 MyQueue.java

    @SuppressWarnings("all")
class Node 
    public int val;
    public Node next;
    public Node(int val) 
        this.val = val;
    


public class MyQueue 
    public Node head;
    public Node last;

    /**
     * 尾插法
     * @param val
     */
    public void offer(int val) 
        Node node = new Node(val);
        if (head == null) 
            head = node;
            last = node;
         else 
            last.next = node;
            last = last.next;
        
    

    /**
     * 出队
     * @return
     */
    public int poll() 
        if (isEmpty()) 
            throw new RuntimeException("队列为空");
        
        int oldVal = head.val;
        this.head = head.next;
        return oldVal;
    

    public boolean isEmpty() 
        return this.head == null;
    

    public int peek() 
        if (isEmpty()) 
            throw new RuntimeException("队列为空");
        
        return head.val;

    四、循环队列

    为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。 - 来源百度
    队列头尾相连的顺序存储结构称为循环队列。

    使用循环队列的时候，我们会发现一个问题，如何去区分空与满？

    其实是有三种解决方法的

    1. 通过添加size属性记录
    2. 保留一个位置
    3. 使用flag标记

    我们使用第二种方法来实现

    4.1 isEmpty - 判空

     public boolean isEmpty() 
        return front == rear;

    4.2 isFull - 判满

    public boolean isFull() 
        if ((this.rear+1) % elem.length == front) 
            return true;
        
        return false;

    4.3 front - 队头

    public int front() 
        if (isEmpty()) return -1;
        return elem[front];

    4.4 rear - 队尾

    public int rear() 
        if (isEmpty()) return -1;
        int index = -1;
        if (rear == 0) 
            index = elem.length-1;
         else 
            index = rear-1;
        
        return elem[index];

    4.5 enQueue - 入队

    public boolean enQueue(int value) 
        if (isFull()) return false;
        this.elem[rear] = value;
        rear = (rear + 1) % elem.length;
        return true;

    4.6 deQueue - 出队

    public boolean deQueue() 
        if (isEmpty()) return false;
        front = (front+1) % elem.length;
        return true;

    4.7 MyCircularQueue.java

    
public class MyCircularQueue 

    public int[] elem;
    public int front;//队头下标
    public int rear;//队尾下标

    public MyCircularQueue(int k) 
        this.elem = new int[k+1];
    

    /**
     * 入队
     *
     * @param value
     * @return
     */
    public boolean enQueue(int value) 
        if (isFull()) return false;
        this.elem[rear] = value;
        rear = (rear + 1) % elem.length;
        return true;
    

    public boolean deQueue() 
        if (isEmpty()) return false;
        front = (front+1) % elem.length;
        return true;
    

    /**
     * 得到队头元素
     * @return
     */
    public int front() 
        if (isEmpty()) return -1;
        return elem[front];
    

    public int rear() 
        if (isEmpty()) return -1;
        int index = -1;
        if (rear == 0) 
            index = elem.length-1;
         else 
            index = rear-1;
        
        return elem[index];
    

    public boolean isEmpty() 
        return front == rear;
    

    public boolean isFull() 
        if ((this.rear+1) % elem.length == front) 
            return true;
        
        return false;

    五、双端队列

    deque（double-ended queue，双端队列）是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，相比list增加[]运算符重载。

    在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时，无论是前端还是后端出队，先出的元素排列在后出的元素的前面。

    Deque是一个接口，使用时必须创建LinkedList的对象。由于在实际开发中Deque使用的并不是非常多，所以大家只需了解一下即可！

    六、面试题

    6.1 用队列实现栈

    6.1.1 解题思路

    因为栈是后进先出结构，而我们的队列是先进先出结构，我们可以用两个队列来模拟实现栈的结构，qu1用来进栈，当我们需要出栈时，将qu1里面的元素出栈size-1个元素，就能得到我们的栈顶元素，注意，进栈的时候先判断两个队列谁不为空往哪个队列进，只有两个队列都为空的时候我们的栈也为空。

    6.1.2 代码

    class MyStack 

    private Queue<Integer> qu1;
    private Queue<Integer> qu2;

    public MyStack() 
        qu1 = new LinkedList<>();
        qu2 = new LinkedList<>();
    

    public void push(int x) 
        if (!qu1.isEmpty()) 
            qu1.offer(x);
         else if (!qu2.isEmpty()) 
            qu2.offer(x);
         else 
            qu1.offer(x);
        
    

    public int pop() 
        if(empty()) return -1;
        if (!qu1.isEmpty()) 
            int size = qu1.size();
            for (int i = 0; i < size-1; i++) 
                int val = qu1.poll();
                qu2.offer(val);
            
            return qu1.poll();
        

        if (!qu2.isEmpty()) 
            int size = qu2.size();
            for (int i = 0; i < size-1; i++) 
                int val = qu2.poll();
                qu1.offer(val);
            
            return qu2.poll();
        
        return -1;

    

    public int top() 
        if(empty()) return -1;
        if (!qu1.isEmpty()) 
            int val = -1;
            int size = qu1.size();
            for (int i = 0; i < size; i++) 
                val = qu1.poll();
                qu2.offer(val);
            
            return val;
        

        if (!qu2.isEmpty()) 
            int val = -1;
            int size = qu2.size();
            for (int i = 0; i < size; i++) 
                val = qu2.poll();
                qu1.offer(val);
            
            return val;
        
        return -1;
    

    public boolean empty() 
        return qu2.isEmpty() && qu1.isEmpty();

    6.2 用栈实现队列

    6.2.1 解题思路

    1. 用两个栈实现队列，先将元素全部入栈到第一个栈s1当中。
    2. pop()操作，先判断s1是否为空，如果为空则返回-1，接着判断条件为s2为空,s1不为空，将s1中的元素全部进栈到s2当中，然后return s2.pop()便是出队操作。
    3. 跟操作2类似，最后返回s2.peek()便可！

    6.2.2 代码

    class MyQueue 

    public Stack<Integer> stack1;
    public 信息学赛培 | 08 不可不知的搜索与回溯——深度优先搜索算法与实例详解
    

     豆瓣评分9.4！跟邱锡鹏教授一起学「神经网络与深度学习」，7月19日开课
    

     《深度学习与计算机视觉算法原理框架应用》PDF+《深度学习之PyTorch实战计算机视觉》PDF
    

     从零入门机器学习之开宗明义：编程与数据思维
    

     从零入门机器学习之开宗明义：编程与数据思维
    

     画解数据结构：队列