打印杨辉三角（循环队列、链表）

程序小白，希望和大家多交流，共同学习

//打印杨辉三角，使用栈，用到初始化init入队push出队pop返回队头getHead
//使用链队列（带头结点）。队列是先进先出，使用的方法是尾插法
//输出第5行之前的杨辉三角图形是标准的，再向后，由于最大数的位数不定，
//占用的字节数无法确定，使得图形不规范
#include<iostream>
using namespace std;
//创建结点
struct Node
{
    int data;
    Node *next;
};
//创建队列
struct linkQueue
{
    Node *front, *rear;
};

//初始化
void initQueue(linkQueue &lq);
//入队列
void push(linkQueue &lq, int data);
//出队列
void pop(linkQueue &lq, int &elem);
//返回队顶元素
void getHead(linkQueue lq, int &head);
//判断空队列
bool isEmpty(linkQueue lq);
//判断满队列
bool isFull(linkQueue lq);
//输出杨辉三角
void printYangHuiTriangle();
//测试队列
void testQueue();

int main()
{
    //testQueue();
    printYangHuiTriangle();
    return 0;
}

//初始化
void initQueue(linkQueue &lq)
{
    Node *newNode = new Node;
    if (newNode)
    {
        newNode -> next = NULL;
        lq.front = newNode;
        lq.rear = lq.front;//只有一个结点，所以头指针和尾指针都指向它
    }

}
//入队列
void push(linkQueue &lq, int data)
{
    if (isFull(lq))
    {
        cout << "队列已满，无法入队列\n";
        return ;
    }

    Node *newNode = new Node;
    newNode -> data = data;
    newNode -> next = NULL;
    lq.rear -> next = newNode;
    lq.rear = newNode;
}
//出队列
void pop(linkQueue &lq, int& elem)
{
    if (isEmpty(lq))
    {
        cout << "队列已空，无法出队列\n";
        return ;
    }

    Node *delNode = lq.front -> next;
    lq.front -> next = delNode -> next;
    if (delNode == lq.rear)
    {
        lq.rear = lq.front;
    }
        lq.front -> next = delNode -> next;
    elem = delNode -> data;
    delete delNode;
}
//返回队顶元素
void getHead(linkQueue lq, int &head)
{
    if (isEmpty(lq))
    {
        cout << "队列已空，无对顶元素\n";
        return ;
    }

    head = lq.front -> next -> data;
}
//判断空队列
bool isEmpty(linkQueue lq)
{
    return lq.rear == lq.front;
}
//判断满队列
bool isFull(linkQueue lq)
{
    Node *newNode = new Node;
    if (newNode)
    {
        delete newNode;
        return false;
    }
    else
    {
        return true;
    }
}
//输出杨辉三角
void printYangHuiTriangle()
{
    //初始化队列
    linkQueue lq;
    initQueue(lq);
    //确定输出的行数
    int row;
    cout << "输入要输出的行数：";
    cin >> row;
    //输入第一行元素。唯一的元素1
    push(lq, 1);
    int delData, head;//需要删除的元素和删除后的队首元素
    for (int i = 2; i <= row; i++)//确定并输出前row - 1行，保存第row行
    {
        //输出每行的空格
        for (int k = 0; k < row - i + 1; k++)
        {
            cout << " ";
        }
        //进出每行第一个元素1
        push(lq, 1);
        //确定除去第一个和最后一个元素，其余的元素
        for (int j = 0; j < i - 2; j++)
        {
            pop(lq, delData);
            getHead(lq, head);
            cout << delData << "  ";
            push(lq, (delData + head));
        }

        pop(lq, delData);
        cout << delData << endl;
        //这个时候，仅剩下最后一个元素1
        push(lq, 1);
    }

    //将最后一排元素输出
    while (!isEmpty(lq))
    {
        pop(lq, delData);
        cout << delData << "  ";
    }
    cout << endl;
}
//测试队列
void testQueue()
{
    linkQueue lq;
    initQueue(lq);
    int data;
    cout << "输入队列元素，为1结束";
    cin >> data;
    while (data != -1)
    {
        push(lq, data);
        cin >> data;
    }

    int elem;
    getHead(lq, elem);
    cout << elem << endl;
    while (!isEmpty(lq))
    {
        pop(lq, elem);
        cout << elem << " ";
    }
}

//使用循环队列输出杨辉三角
//各个方法的名字如果和使用链表的一样，那么打印方法也就和链表实现一样了
//因为，还是使用和链表输出杨辉三角相同的思想，只是存储方式不同
//只是因为无法知道具体行数，所以存储的大小收到限制，
//杨辉三角的行数就是它每一行元素的个数，所以允许输出的最大的行数是MAX - 1
#include<iostream>
#define MAX 15
using namespace std;

struct seqQueue
{
    int queue[MAX];
    int front, rear;
};

//初始化
void initQueue(seqQueue &sq);
//入队列
void push(seqQueue &sq, int data);
//出队列
void pop(seqQueue &sq, int &elem);
//返回对顶元素
void getHead(seqQueue sq, int &head);
//判断空队列
bool isEmpty(seqQueue sq);
//判断满队列
bool  isFull(seqQueue sq);
//输出杨辉三角
void printYangHuiTriangle();
//测试循环队列
void testSeqQueue();

int main()
{
    //testSeqQueue();
    printYangHuiTriangle();
    return 0;
}

//初始化
void initQueue(seqQueue &sq)
{
    sq.front = sq.rear = 0;
}
//入队列
void push(seqQueue &sq, int data)
{
    if (isFull(sq))
    {
        cout << "队列已满，无法入队列\n";
        return ;
    }
    sq.queue[sq.front] = data;
    sq.front = (sq.front + 1) % MAX;
}
//出队列
void pop(seqQueue &sq, int &elem)
{
    if (isEmpty(sq))
    {
        cout << "队列已空，无法出队列\n";
        return ;
    }

    elem = sq.queue[sq.rear];
    sq.rear = (sq.rear + 1) % MAX;
}
//返回对顶元素
void getHead(seqQueue sq, int &head)
{
    if (isEmpty(sq))
    {
        cout << "队列已空，没有队顶元素\n";
        return ;
    }
    head = sq.queue[sq.rear];
}
//判断空队列
bool isEmpty(seqQueue sq)
{
    return sq.front == sq.rear;
}
//判断满队列
bool  isFull(seqQueue sq)
{
    return (sq.front + 1) % MAX == sq.rear;
}
//输出杨辉三角
void printYangHuiTriangle()
{
    seqQueue sq;
    initQueue(sq);

    int row;
    cout << "输入要输出的行数(<= 14)：";
    cin >> row;
    while (row >= 15)
    {
        cout << "输入要输出的行数(<= 14)：";
        cin >> row;
    }

    push(sq, 1);//输入第一行元素
    int delData, head;
    for (int i = 2; i <= row; i++)
    {
        //输出每行的空格
        for (int k = 0; k < row - i + 1; k++)
        {
            cout << " ";
        }
        //输入每行的第一个元素1
        push(sq, 1);
        for (int j = 0; j < i - 2; j++)//中间的i - 2 个元素
        {
            pop(sq, delData);
            getHead(sq, head);
            cout << delData << "  ";
            push(sq, (delData + head));
        }

        pop(sq, delData);//上一行的最后一个元素
        cout << delData << endl;
        push(sq, 1);//每一行的最后一个元素
    }

    while (!isEmpty(sq))
    {
        pop(sq, delData);
        cout << delData << "  ";
    }
    cout << endl;
}
//测试循环队列
void testSeqQueue()
{
    seqQueue sq;
    initQueue(sq);
    int data;
    cout << "输入队列元素，为1结束:";
    cin >> data;
    while (data != -1)
    {
        push(sq, data);
        cin >> data;
    }

    getHead(sq, data);
    cout << data << endl;
    while (!isEmpty(sq))
    {
        pop(sq, data);
        cout << data << " " ;
    }
    cout << endl;
}