Round7—队列

知识点：

简单说一下吧，知道队列与栈的区别，队列是先进先出，栈是后进先出。

如果是用顺序表实现栈与队列：

在队列当中有两个指针，分别是front指针指向队首元素，rear指针指向对尾元素的后面，也就是待插入位置。

在栈当中也是有两个指针，分别是base指针指向栈底，top指针指向栈顶元素的上面，也就是待插入位置。

选择题：

2-1为解决计算机主机与打印机之间速度不匹配问题，通常设置一个打印数据缓冲区，主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。该缓冲区的逻辑结构应该是？ (1分)

• 堆栈
• 队列
• 树
• 图

解析：注意题目当中说明了是依次写入依次取出，符合先进先出的原则，因此使用队列。

2-2若已知一队列用单向链表表示，该单向链表的当前状态（含3个对象）是：1->2->3，其中x->y表示x的下一节点是y。此时，如果将对象4入队，然后队列头的对象出队，则单向链表的状态是： (1分)

• 1->2->3
• 2->3->4
• 4->1->2
• 答案不唯一

解析：队列的入队操作都是将入队元素插入队列的尾部，队列元素的出队都是从队首出队列。

因此插入4之后队列为1->2->3->4，队首元素出队列，2->3->4。

2-3在一个链队列中，front和rear分别为头指针和尾指针，则插入一个结点s的操作为（ ）。 (2分)

• front=front->next
• s->next=rear;rear=s
• rear->next=s;rear=s;
• s->next=front;front=s;

解析：首先我们要知道元素入队都是进入队尾，因此一定是对rear指针进行操作，首先在rear的后面插入结点，然后更新rear指针就行了，仿照单链表因此第三个是对的。

2-4依次在初始为空的队列中插入元素a,b,c,d以后，紧接着做了两次删除操作，此时的队头元素是（ ）。 (2分)

• a
• b
• c
• d

解析：删除是从队首删除元素，就变成了c，d，因此对手元素就是c。

2-5在一个不带头结点的非空链式队列中,假设f和r分别为队头和队尾指针,则插入s所指的结点运算是( )。 (2分)

• f->next=s; f=s;
• r->next=s; r=s;
• s->next=s; r=s;
• s->next=f; f=s;

解析：跟上面一个题重了。

编程题：

7-1 银行业务队列简单模拟 (25 分)

 

设某银行有A、B两个业务窗口，且处理业务的速度不一样，其中A窗口处理速度是B窗口的2倍 —— 即当A窗口每处理完2个顾客时，B窗口处理完1个顾客。给定到达银行的顾客序列，请按业务完成的顺序输出顾客序列。假定不考虑顾客先后到达的时间间隔，并且当不同窗口同时处理完2个顾客时，A窗口顾客优先输出。

输入格式:

输入为一行正整数，其中第1个数字N(≤1000)为顾客总数，后面跟着N位顾客的编号。编号为奇数的顾客需要到A窗口办理业务，为偶数的顾客则去B窗口。数字间以空格分隔。

输出格式:

按业务处理完成的顺序输出顾客的编号。数字间以空格分隔，但最后一个编号后不能有多余的空格。

输入样例:

8 2 1 3 9 4 11 13 15

输出样例:

1 3 2 9 11 4 13 15

AC代码：

#include <bits/stdc++.h>
using namespace std;

typedef int ElemType;
const int maxn = 1000 + 10;
struct Queue
{
    ElemType *base;
    int front;
    int top;
    Queue(ElemType *base = nullptr, int front = 0, int top = 0) : base(base), front(front), top(top) {}

    int size()
    {
        return this->top - this->front;
    }

    bool isempty()
    {
        if(this->front == this->top)
            return true;
        return false;
    }

    bool push(ElemType x)
    {
        if(this->top >= maxn)
            return false;
        this->base[top++] = x;
        return true;
    }

    ElemType gettop()
    {
        return this->base[this->front];
    }

    bool pop()
    {
        if(this->front >= this->top)
            return false;
        if(this->front < this->top)
            this->front++;
        return true;
    }
};

void InitQue(Queue &que)
{
    que.base = new ElemType[maxn];
}

int main()
{
    Queue a, b;
    InitQue(a);
    InitQue(b);

    int n;
    cin >> n;
    for(int i = 0; i < n; i++)
    {
        ElemType x;
        cin >> x;
        if(x % 2 == 1)
            a.push(x);
        else
            b.push(x);
    }

    if(a.size() >= 2)
    {
        cout << a.gettop();
        a.pop();
        cout << " " << a.gettop();
        a.pop();
    }
    else if(a.size() == 1)
    {
        cout << a.gettop();
        a.pop();
    }
    else if(b.size() >= 1)
    {
        cout << b.gettop();
        b.pop();
    }

    while(!a.isempty() && !b.isempty())
    {
        if(!b.isempty())
        {
            cout << " " << b.gettop();
            b.pop();
        }
        if(!a.isempty())
        {
            cout << " " << a.gettop();
            a.pop();
        }
        if(!a.isempty())
        {
            cout << " " << a.gettop();
            a.pop();
        }
    }

    while(!a.isempty())
    {
        cout << " " << a.gettop();
        a.pop();
    }

    while(!b.isempty())
    {
        cout << " " << b.gettop();
        b.pop();
    }
    cout << endl;
    return 0;
}

解析：题目不难用队列的线性表的实现来解就可以了，注意空格，前几个元素特别注意把。