Java算法_队列和queue——HDU 1702：ACboy needs your help again!

队列和queue

Java中定义了java.util.Queue接口用来表示队列

java队列特性

队列主要分为阻塞和非阻塞，有界和无界、单向链表和双向链表之分；

阻塞和非阻塞

阻塞队列

​ 入列(添加元素)时，如果元素数量超过队列总数，会进行等待（阻塞），待队列的中的元素出列后，元素数量未超过队列总数时，就会解除阻塞状态，进而可以继续入列；
​ 出列(删除元素)时，如果队列为空的情况下，也会进行等待（阻塞），待队列有值的时候即会解除阻塞状态，进而继续出列；
​ 阻塞队列的好处是可以防止队列容器溢出；只要满了就会进行阻塞等待；也就不存在溢出的情况；
​ 只要是阻塞队列，都是线程安全的；

非阻塞队列

​ 不管出列还是入列，都不会进行阻塞，
​ 入列时，如果元素数量超过队列总数，则会抛出异常，
​ 出列时，如果队列为空，则取出空值；

 一般情况下，非阻塞式队列使用的比较少，一般都用阻塞式的对象比较多；阻塞和非阻塞队列在使用上的最大区别就是阻塞队列提供了以下2个方法：

• 出队阻塞方法 ： take()
• 入队阻塞方法 ： put()

有界和无界

有界：有界限，大小长度受限制
无界：无限大小，其实说是无限大小，其实是有界限的，只不过超过界限时就会进行扩容，就行ArrayList 一样，在内部动态扩容

单向链表和双向链表

单向链表 ： 每个元素中除了元素本身之外，还存储一个指针，这个指针指向下一个元素；

双向链表 ：除了元素本身之外，还有两个指针，一个指针指向前一个元素的地址，另一个指针指向后一个元素的地址；

队列常用方法

函数	说明
add	增加一个元索，如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove	移除并返回队列头部的元素，如果队列为空，则抛出一个NoSuchElementException异常
element	返回队列头部的元素，如果队列为空，则抛出一个NoSuchElementException异常
offer	添加一个元素并返回true， 如果队列已满，则返回false
poll	移除并返问队列头部的元素，如果队列为空，则返回null
peek	返回队列头部的元素， 如果队列为空，则返回null
put	添加一个元素， 如果队列满，则阻塞
take	移除并返回队列头部的元素 ，如果队列为空，则阻塞
drainTo(list)	一次性取出队列所有元素

remove、element、offer 、poll、peek 其实是属于Queue接口。

下面这道题中同时应用了栈和队列，对栈不了解的小伙伴可以点击这里：
链接: Java算法_栈和stack——HDU 1062：Text Reverse

HDU 1702：ACboy needs your help again!

http://acm.hdu.edu.cn/showproblem.php?pid=1702

Problem Description
ACboy was kidnapped!!
he miss his mother very much and is very scare now.You can’t image how dark the room he was put into is, so poor 😦.
As a smart ACMer, you want to get ACboy out of the monster’s labyrinth.But when you arrive at the gate of the maze, the monste say :" I have heard that you are very clever, but if can’t solve my problems, you will die with ACboy."
The problems of the monster is shown on the wall:
Each problem’s first line is a integer N(the number of commands), and a word “FIFO” or “FILO”.(you are very happy because you know “FIFO” stands for “First In First Out”, and “FILO” means “First In Last Out”).
and the following N lines, each line is “IN M” or “OUT”, (M represent a integer).
and the answer of a problem is a passowrd of a door, so if you want to rescue ACboy, answer the problem carefully!

ACboy被绑架了！！
他非常想念他的母亲，现在非常害怕。你无法想象他被放进的房间有多暗，那么可怜:(。
作为一个聪明的ACMer，你想让ACboy摆脱怪物的迷宫。当您到达迷宫的大门时，蒙斯特说：“我听说您很聪明，但是如果不能解决我的问题，您将会死于ACboy。”
怪物的问题显示在墙上：
每个问题的第一行是整数N（命令数），以及单词“ FIFO”或“ FILO”。（您非常高兴，因为您知道“ FIFO”代表“先进先出”和“ FILO”表示“先进后出”）
，随后的N行，每行是“ IN M”或“ OUT”，
问题的答案是一扇门，所以如果您想营救ACboy，请仔细回答问题！

Input
The input contains multiple test cases.
The first line has one integer,represent the number oftest cases.
And the input of each subproblem are described above.

输入包含多个测试用例。
第一行有一个整数，代表测试用例的数量。
并且上面描述了每个子问题的输入。

Output
For each command “OUT”, you should output a integer depend on the word is “FIFO” or “FILO”, or a word “None” if you don’t have any integer.

对于每个命令“ OUT”，您应该输出一个整数，具体取决于单词“ FIFO”或“ FILO”，如果没有任何整数，则输出单词“ None”。

Sample Input

4
4 FIFO
IN 1
IN 2
OUT
OUT
4 FILO
IN 1
IN 2
OUT
OUT
5 FIFO
IN 1
IN 2
OUT
OUT
OUT
5 FILO
IN 1
IN 2
OUT
IN 3
OUT

Sample Output

1
2
2
1
1
2
None
2
3

package com.hhhyixin.book.cp03.hdu_1702;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();   //输入测试的轮数
            for (int i = 0; i < n; i++) {
                int m = sc.nextInt();   //输入测试用例数
                String str = sc.next(); //输入FIFO或者FILO
                stack s = new stack();  //定义栈
                queue q = new queue();  //定义队列
                for (int j = 0; j < m; j++) {
                    if (str.equals("FIFO")) { //队列操作
                        String ss = sc.next();  //输入IN M或者OUT
                        if (ss.equals("IN")) {  //如果ss包含IN，就加入队列
                            Node node = new Node(sc.nextInt());
                            q.add(node);
                        } else {    //如果ss包含OUT，就输出最先进队列的,如果队列为空就输出None
                            if (q.isEmpty()) System.out.println("None");
                            else System.out.println(q.remove());
                        }
                    } else { //栈操作
                        String ss = sc.next();  //输入IN，或者OUT
                        if (ss.equals("IN")) {  //如果ss包含IN，就加入栈
                            Node node = new Node(sc.nextInt());
                            s.add(node);
                        } else {    //如果ss包含OUT，就输出最后进栈的，如果栈为空就输出None
                            if (s.isEmpty()) System.out.println("None");
                            else System.out.println(s.pop());
                        }
                    }
                }
            }
        }
    }

}

//栈
class stack {
    Node head = new Node(0);

    public void add(Node newNode) {
        newNode.next = head.next;
        head.next = newNode;
    }

    public int pop() {
        int num = head.next.data;
        head.next = head.next.next;
        return num;
    }

    //判空
    public boolean isEmpty() {
        if (head.next == null) return true;
        else return false;
    }
}

//队列
class queue {
    Node head = new Node(0);

    public void add(Node newNode) {
        Node temp = head;

        while (true) {
            if (temp.next == null) break;
            temp = temp.next;
        }
        temp.next = newNode;
    }

    public int remove() {
        int num = head.next.data;
        head.next = head.next.next;
        return num;
    }

    //判空
    public boolean isEmpty() {
        if (head.next == null) return true;
        else return false;
    }
}

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
    }
}