数据结构与算法实战 3.32.链式队列 （青岛大学 周强）

//链式队列
#include<iostream>

using namespace std;

struct Node{
    int data;
    Node* next;//C++不用写struct Node *next,因为Node可以指代类型
    //构造函数
    Node(int x){
        data = x;
        next = NULL;
    }
}

class Queue{
    private://队首队尾的指针应该是私有的 不是公共的
        Node* front;
        Node* rear;
    public:
    //链表有两种 带“空头结点（不保存数据只有next起引导作用）” 和不带“空头结点的”（一开始就存放数据的）
    //下面采用不带 空头结点 的链表
        Queue(){
            front = rear = NULL;
        }
        
        ~Queue(){
            Node* tmp;
            while(front != NULL){
                tmp = front;
                front = front->next;
                delete tmp;
            }
        }

        bool isEmpty(){
            return front == NULL;
        }

        // bool isFull() 不考虑队满 因为是链式队列 内存有多少用多少...
        //因为内存有多少用多少 不考虑用完的情况 所以enQueue返回类型用了void
        void enQueue(int x){
            /**谨记要考虑空队的情况 rear和front都指向这个元素*/
            Node* tmp;
            tmp = new Node(x);//上面有构造函数了 
            if(isEmpty()){
                //调试语句 cout << "Empty" << tmp->data << endl;
                front = rear = tmp;
            }
            else{
                 //调试语句 cout << "Not Empty" << tmp->data << endl;
                //在队尾挂一个点 不需要tmp->next =NULL了 因为构造函数里面写了
                rear->next = tmp;
                //记住新加入的元素要变成表尾
                rear = tmp;
            }
        }

        bool deQueue(int *px){
            if(isEmpty()) return false;
            else{
                //谨记考虑出队之后队伍为空的情况
                *px = front->data;
                //调试语句 cout << "*px" << *px << endl;
                Node * tmp;
                tmp = front;
                front = front->next;//表头指针往后移动 指向第二个点
                delete tmp;
                if(front == NULL) rear = NULL;//出队前就它一个元素 出队之后空了
                return true;
            }
        }
}

int main(){
    Queue q;
    q.enQueue(11);
    q.enQueue(22);
    q.enQueue(33);
    q.enQueue(44);
    q.enQueue(55);
    int x;
    x = 0;
    cout << q.deQueue(&x) << endl;
    cout << x << endl;
    return 0;
}

银行排队

//银行排队 队列应用 模拟单队列排队
用程序简单模拟一个单队列多窗口的排队模式：
设某银行有一个固定能容纳N个顾客的等候区，顾客想进银行，若等候区有空则可进，否则被拒绝进入。
每当银行柜员叫号时，等候区中最先进入的顾客离开等候区前往柜台办理业务，若叫号时等候区无人，则此次叫号作废。

输入格式:
第一行输入一个不大于20的正整数N，表示银行等候区能容纳的人数，
接下来用若干行表示依时间顺序先后发生的“顾客想进银行”或“叫号”事件，格式分别是：

顾客想进银行，用 In <id> 表示，其中<id>是顾客编号，为不大于100000的正整数；
叫号，用Calling表示。
最后一行是一个#符号，表示输入结束。
注意：

题目输入保证每个顾客的编号是独一无二的，即：不会出现想进银行的顾客与已经在等候区的顾客编号相同的情况。
保证后一个事件一定在前一个事件完成之后才发生，即：不需要考虑事件之间的“同步”问题。
输出格式:
对于输入的每个事件，按同样顺序在一行内输出事件的结果，格式分别是：

顾客想进银行，若顾客进入，则输出 <id> joined. Total:<t> 其中<id>是该顾客的编号，<t>是顾客进入后，等候区的人数
顾客想进银行，若因等候区满而被拒绝，则输出 <id> rejected. 其中<id>是该顾客的编号
叫号，若有顾客前往柜台，则输出 <id> called. Total:<t> 其中<id>是该顾客的编号，<t>是顾客去柜台后，等候区的人数
叫号，等候区无人，则输出 No one!
输入样例:
3
In 101
In 102
In 103
In 104
Calling
In 105
Calling
Calling
Calling
Calling
#
输出样例:
101 joined. Total:1
102 joined. Total:2
103 joined. Total:3
104 rejected.
101 called. Total:2
105 joined. Total:3
102 called. Total:2
103 called. Total:1
105 called. Total:0
No one!

#include<iostream>
#include<queue>

using namespace std;

int main(){
    int N;
    cin >> N;
    queue<string> q;
    string op, id;
    cin >> op;
    while(op != '#'){
        if(op == "IN"){
            cin >> id;
            if(q.size() == N){
                cout << id << " rejected." << endl;
            }
            else{
                q.push(id);
                cout << id << " joined. Total:" << q.size() << endl;
            }
        }
        else{
            if(q.empty()){
                cout << "No one!" << endl;
            }
            else{
                id = q.front();
                q.pop();
                cout << id << " called. Total:" << q.size() << endl;
            }
        }
        cin >> op;
    }
    return 0;
}