队列法求斐波那契数列前20项

使用队列可以比递归更高效地求解斐波那契数列。以下是使用队列法求解斐波那契数列前20项的示例代码：

#include <iostream>
#include <queue>

using namespace std;

int main()
{
    queue<int> q;
    int a = 0, b = 1;
    q.push(a);
    q.push(b);

    for (int i = 2; i < 20; i++)
    {
        int c = a + b;
        q.push(c);
        a = b;
        b = c;
    }

    for (int i = 0; i < 20; i++)
    {
        cout << q.front() << " ";
        q.pop();
    }

    return 0;
}

在上面的代码中，我们使用一个队列来存储斐波那契数列的前两项，然后依次计算后面的项并将它们加入队列中。最后，我们输出队列中的前20项即可。

相关问题

用C语言队列法求斐波那契数列前20项

好的，以下是使用C语言队列法求解斐波那契数列前20项的示例代码：

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

#define MAX 20

typedef struct queue {
    int data[MAX];
    int head;
    int tail;
} Queue;

void init(Queue* q)
{
    q->head = 0;
    q->tail = 0;
}

int empty(Queue* q)
{
    return q->head == q->tail;
}

int full(Queue* q)
{
    return (q->tail + 1) % MAX == q->head;
}

void push(Queue* q, int x)
{
    if (full(q))
    {
        printf("Queue is full!\n");
        return;
    }
    q->data[q->tail] = x;
    q->tail = (q->tail + 1) % MAX;
}

int pop(Queue* q)
{
    if (empty(q))
    {
        printf("Queue is empty!\n");
        return -1;
    }
    int x = q->data[q->head];
    q->head = (q->head + 1) % MAX;
    return x;
}

int main()
{
    Queue q;
    init(&q);
    int a = 0, b = 1;
    push(&q, a);
    push(&q, b);

    for (int i = 2; i < MAX; i++)
    {
        int c = a + b;
        push(&q, c);
        a = b;
        b = c;
    }

    while (!empty(&q))
    {
        printf("%d ", pop(&q));
    }

    return 0;
}

在上面的代码中，我们使用一个定长循环队列来存储斐波那契数列的前两项，然后依次计算后面的项并将它们加入队列中。最后，我们输出队列中的前20项即可。

c语言用队列输出斐波那锲数列的前20项

好的，这是C语言使用队列输出斐波那契数列前20项的代码：

#include <stdio.h>

#define MAX_SIZE 20

// 队列结构体
struct Queue {
    int data[MAX_SIZE];
    int front;  // 队头指针
    int rear;   // 队尾指针
};

// 初始化队列
void initQueue(struct Queue *q) {
    q->front = 0;
    q->rear = 0;
}

// 判断队列是否为空
int isEmpty(struct Queue q) {
    return q.front == q.rear;
}

// 判断队列是否已满
int isFull(struct Queue q) {
    return (q.rear + 1) % MAX_SIZE == q.front;
}

// 入队操作
void enqueue(struct Queue *q, int x) {
    if (isFull(*q)) {
        printf("Queue is full.\n");
        return;
    }
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % MAX_SIZE;
}

// 出队操作
int dequeue(struct Queue *q) {
    if (isEmpty(*q)) {
        printf("Queue is empty.\n");
        return -1;
    }
    int x = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    return x;
}

int main() {
    struct Queue q;
    initQueue(&q);

    int a = 0, b = 1;
    enqueue(&q, a);
    enqueue(&q, b);

    for (int i = 0; i < MAX_SIZE; i++) {
        a = dequeue(&q);
        b = dequeue(&q);
        printf("%d ", a);
        printf("%d ", b);
        enqueue(&q, b);
        enqueue(&q, a + b);
    }

    return 0;
}

代码解释：

1. 定义了一个结构体 `Queue` 表示队列，包含一个数组 `data` 和两个指针 `front` 和 `rear` 分别表示队头和队尾。
2. 定义了初始化队列、判断队列是否为空、判断队列是否已满、入队操作、出队操作等函数。
3. 在 `main` 函数中，首先初始化队列，并将斐波那契数列的前两项（0和1）入队。
4. 使用循环来不断出队并输出队列中的数，同时计算下一项斐波那契数列的值，并将其入队。
5. 最后输出结果。

注意：本代码中的斐波那契数列包含了每个数的前后两项，因此输出了前20项，实际上计算了前40项。如果只需要前20项，可以修改循环条件为 `i < MAX_SIZE / 2`。