数据结构实验三队列

1. 队列元素逆置

2. 猴子分桃问题

1. 队列元素逆置

【问题描述】

已知Q是一个非空队列，S是一个空栈。仅使用少量工作变量以及对队列和栈的基本操作，编写一个算法，将队列Q中的所有元素逆置。

【输入形式】

输入的第一行为队列元素个数，第二行为队列从首至尾的元素

【输出形式】

输出队列的逆置

扫描二维码关注公众号，回复： 17367224 查看本文章

【样例输入】

3
1 2 3

【样例输出】

3 2 1

【评分标准】

需采用队列与栈的知识，否则不能得分

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 10000

typedef struct Queue {
    int data[MAXSIZE];
    int front;
    int rear;
} Queue;

typedef struct Stack {
    int data[MAXSIZE];
    int top;
} Stack;

Queue* createQueue() {
    Queue* Q = (Queue*)malloc(sizeof(Queue));
    Q->front = Q->rear = 0; 
    return Q;
}

int isEmptyQueue(Queue* Q) {
    return Q->front == Q->rear;
}

void enQueue(Queue* Q, int x) {
    if ((Q->rear + 1) % MAXSIZE == Q->front) {
        printf("Queue Overflow\n");
        return;
    }
    Q->data[Q->rear] = x;
    Q->rear = (Q->rear + 1) % MAXSIZE;
}

int deQueue(Queue* Q) {
    if (isEmptyQueue(Q)) {
        printf("Queue Underflow\n");
        return -1;
    }
    int x = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return x;
}

Stack* createStack() {
    Stack* S = (Stack*)malloc(sizeof(Stack));
    S->top = -1;
    return S;
}

int isEmptyStack(Stack* S) {
    return S->top == -1;
}

void push(Stack* S, int x) {
    if (S->top == MAXSIZE - 1) {
        printf("Stack Overflow\n");
        return;
    }
    S->data[++S->top] = x;
}

int pop(Stack* S) { 
    if (isEmptyStack(S)) {
        printf("Stack Underflow\n");
        return -1;
    }
    return S->data[S->top--];
}

void reverse(Queue* Q) { 
    Stack* S = createStack();
    while (!isEmptyQueue(Q)) {
        push(S, deQueue(Q)); 
    }
    while (!isEmptyStack(S)) {
        enQueue(Q, pop(S)); 
    }
}

int main() {
    int n, x,i;
    Queue* Q = createQueue();

    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        scanf(" %d", &x);
        enQueue(Q, x);
    }

    reverse(Q);
    while (!isEmptyQueue(Q)) {
        printf("%d ", deQueue(Q));
    }

    return 0;
}

2. 猴子分桃问题

【问题描述】

动物园里的n只猴子编号为1，2，……，n，依次排成一队等待饲养员按规则分桃。动物园的分桃规则是每只猴子可分得m个桃子，但必须排队领取。饲养员循环的每次取出1个，2个，……，k个桃子放入筐里，由排在队首的猴子领取。单次放入筐中的桃子数达到k时，又重新从1开始。当筐中的桃子数加上队首猴子已取得的桃子数不超过m时，队首的猴子可以取得筐中现有的全部桃子。取得桃子总数不足m 个的猴子，继续到队尾排队等候。当筐中的桃子数加上队首猴子已取得的桃子数超过m时，队首的猴子只能取满m个，然后离开队列，筐中剩余的桃子由下一只猴子取用。上述分桃过程一直进行到每只猴子都分到m个桃子。

对于给定的n、k和m，模拟上述猴子分桃过程。

【输入形式】

第1行是3个正整数n、k和m，分别表示有n只猴子，每次最多取k个桃到筐中，每只猴子最终都分到m个桃子。例如：

5 3 40

【输出形式】

将分桃过程中每只猴子离开队列的次序依次输出。例如：

1 3 4 5 2

【样例输入】
【样例输出】
【样例说明】
【评分标准】

#include <stdio.h>

#define MAXSIZE 10000

typedef struct {
    int id;
    int peaches;
} Monkey;

typedef struct {
    Monkey data[MAXSIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *q) {
    q->front = q->rear = 0;
}

int isEmpty(Queue *q) {
    return q->front == q->rear;
}

void enQueue(Queue *q, Monkey m) {
    q->data[q->rear] = m;
    q->rear = (q->rear + 1) % MAXSIZE;
}

Monkey deQueue(Queue *q) {
    Monkey m = q->data[q->front];
    q->front = (q->front + 1) % MAXSIZE;
    return m;
}

int main() {
    int n, k, m,i;
    scanf("%d %d %d", &n, &k, &m);
    Queue q;
    initQueue(&q);
    for (i = 1; i <= n; i++) {
        Monkey monkey = {i, 0};
        enQueue(&q, monkey);
    }
    int peach = 0,temp=0;
    while (!isEmpty(&q)) {
        Monkey monkey = deQueue(&q);
        peach = (peach % k) + 1;
        peach= peach+temp;
        if (monkey.peaches + peach > m) {
            printf("%d ", monkey.id);
            temp=monkey.peaches + peach-m;
        } else {
            temp=0;
            monkey.peaches += peach;
            if (monkey.peaches == m) {
                printf("%d ", monkey.id);
            } else {
                enQueue(&q, monkey);
            }
        }
    }
    return 0;
}