循环队列实现杨辉三角C++

循环队列实现杨辉三角的C++代码如下：

#include <iostream>
using namespace std;

const int MAXN = 100;
int q[MAXN];
int front = 0, rear = 0;

void enqueue(int x) {
    q[rear] = x;
    rear = (rear + 1) % MAXN;
}

int dequeue() {
    int x = q[front];
    front = (front + 1) % MAXN;
    return x;
}

int main() {
    int n;
    cout << "请输入杨辉三角的行数：";
    cin >> n;

    enqueue(1);
    for (int i = 1; i <= n; i++) {
        int last = 0;
        for (int j = 0; j < i; j++) {
            int x = dequeue();
            cout << x << " ";
            enqueue(x + last);
            last = x;
        }
        cout << endl;
        enqueue(1);
    }

    return 0;
}

相关问题

循环队列实现杨辉三角C++语言

循环队列是一种特殊的线性表结构，用于在队列的两端添加和删除元素，常用于需要频繁插入和删除数据并且元素个数不确定的情况，比如杨辉三角。杨辉三角是一个数学上的数组，每一行都是前一行的数加上它对角线相邻的数。

在C++中，我们可以用循环队列来动态地生成并存储杨辉三角，因为其特性正好可以处理这种按需增长的需求。以下是基本的步骤：

1. 定义一个循环队列，可以用`std::queue<int>`或自定义模板队列来实现；
2. 初始化队列，放上三角形的第一行和第二行；
3. 使用嵌套循环生成后续行，对于每个位置的值，先从队首取出前两个位置的值相加，然后放入队尾，并更新队列长度；
4. 遍历队列并将所有元素打印出来，形成完整的杨辉三角。

下面是一个简单的示例代码片段：

#include <queue>
#include <iostream>

// 自定义循环队列模板
template <typename T>
class CircularQueue {
public:
    // 添加元素到队尾
    void enqueue(T val) {
        if (size == max_size) {
            data[front] = val;
            front = (front + 1) % max_size;
        } else {
            data[size++] = val;
        }
    }

    // 取出队首元素
    T dequeue() {
        if (empty()) return T();
        T ret = data[back];
        data[back] = T();  // 清空
        back = (back - 1 + max_size) % max_size; // 更新指向下一个元素的位置
        size--;
        return ret;
    }

private:
    T data[max_size];
    int front, back, size, max_size;
};

void printPascalTriangle(int rows) {
    CircularQueue<int> cq(max_size);  // 设置最大容量，如50足够大
    cq.enqueue(1);
    for (int i = 1; i <= rows; ++i) {
        for (int j = 0; j < i; ++j) {
            int current = cq.dequeue();
           cq.enqueue(current + (j > 0 ? cq.dequeue() : 0));  // 加上对角线相邻的数
            std::cout << current << " ";
        }
        std::cout << "\n";
        cq.enqueue(1);  // 为下一行预留空间
    }
}

int main() {
    int rows;
    std::cout << "Enter the number of rows for Pascal's Triangle: ";
    std::cin >> rows;
    printPascalTriangle(rows);
    return 0;
}

c++循环队列实现杨辉三角

在C++中，我们可以使用数组来实现循环队列，并利用动态内存分配和索引来创建一个模拟循环结构的队列。对于杨辉三角，这是一个经典的递归和动态规划问题，它的每一行都是前一行的数字之和，通常用二维数组表示。下面是使用循环队列实现杨辉三角的一个简单示例：

#include <iostream>
#include <vector>

class CircularQueue {
private:
    int capacity;
    std::vector<int> queue;
    int front, rear;

public:
    CircularQueue(int size) : capacity(size), front(-1), rear(-1) {}

    void enqueue(int value) {
        if ((rear + 1) % capacity == front) {
            // 队满，扩大容量
            expand();
        }
        queue[rear % capacity] = value;
        rear = (rear + 1) % capacity;
    }

    int dequeue() {
        if (isEmpty()) {
            throw std::runtime_error("Queue is empty");
        }
        int value = queue[front];
        queue[front] = 0; // Mark as removed for next iteration
        front = (front + 1) % capacity;
        return value;
    }

    bool isEmpty() const {
        return front == rear;
    }

private:
    void expand() {
        capacity *= 2;
        std::vector<int> temp(capacity);
        for (int i = front; i <= rear; ++i) {
            temp[i] = queue[(i + capacity / 2 - front) % capacity]; // Shift elements
        }
        queue.swap(temp);
        front = rear = 0;
    }
};

// 杨辉三角函数
void printPascalTriangle(CircularQueue& cq) {
    int n = 5; // 示例层数，可以根据需要修改
    for (int row = 0; row < n; ++row) {
        for (int col = 0; col <= row; ++col) {
            cq.enqueue(col == 0 || col == row ? 1 : cq.dequeue() + cq.dequeue());
            std::cout << cq.dequeue() << " ";
        }
        std::cout << "\n";
    }
}

int main() {
    CircularQueue pq(10); // 初始化一个大小为10的队列
    printPascalTriangle(pq);
    return 0;
}

在这个例子中，我们首先定义了一个`CircularQueue`类，它有一个内部循环队列用于存储三角形的元素。然后`printPascalTriangle`函数利用这个队列构建杨辉三角。每次添加或删除元素时，我们都确保队列保持循环结构。

运行这个程序将打印出前5层的杨辉三角。