C语言实现，CLion客户端，实现基于链式队列的操作来实现杨辉三角的不断生成过程。

基于数组实现队列的物理数据结构。
输入形式：输入一个整数n (行数不大于20)
输出形式：打印出来前(n+1)行的杨辉三角数列
功能实现：输出前20层的杨辉三角序列
样例输入输出形式：
输入：6
输出：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1

目录结构：

CMakeList.txt中的内容

头文件LinkQueue.h

//
// Created by ycz 2020/10/27.
//

#ifndef TEST1_LINKQUEUE_H
#define TEST1_LINKQUEUE_H

#endif //TEST1_LINKQUEUE_H


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


typedef int DataType;

/*节点类型定义*/
typedef struct QNode {
    DataType data;
    struct QNode *next;
} LQNode, *QueuePtr;

typedef struct {
    QueuePtr front;
    QueuePtr rear;
} LinkQueue;

/*链式队列初始化*/
void InitQueue(LinkQueue *LQ) {
    LQ->front = LQ->rear = (LQNode *) malloc(sizeof(LQNode)); //为请头结点申请内存空间
    if (LQ->front == NULL)
        exit(-1);
    LQ->front->next = NULL;       //将头结点的指针域置为0
}

/*判断队列是否为空*/
int QueueEmpty(LinkQueue LQ) {
    if (LQ.front == LQ.rear)       //当链式队列为空时
        return 1;       //返回1
    else                    //否则
        return 0;       //返回0
}

/*入队操作*/
int EnQueue(LinkQueue *LQ, DataType e)
//将元素e插入到链式队列LQ中，插入成功返回1
{
    LQNode *s;
    s = (LQNode *) malloc(sizeof(LQNode));      //为将要入队的元素申请一个节点空间
    if (!s)
        exit(-1);       //如果申请空间失败，则退出并返回参数-1
    s->data = e;      //将元素赋值给节点的数据域
    s->next = NULL;       //将节点的指针域置为空
    LQ->rear->next = s;     //将原来队列的队尾指针指向p
    LQ->rear = s;     //将队尾指针指向p
    return 1;
}

/*出队操作*/
int DeQueue(LinkQueue *LQ, DataType *e)
/*删除链式队列中的队头元素，并将该元素赋值给e，删除成功返回1，否则返回0*/

{
    LQNode *s;
    if (LQ->front == LQ->rear)     //再删除元素之前，判断链式队列食肉为空
        return 0;
    else {
        s = LQ->front->next;      //使指针p指向队头元素的指针
        *e = s->data;             //将要删除的队头元素赋值给e
        LQ->front->next = s->next;    //使头结点的指针指向指针p的下一个节点
        if (LQ->rear == s)         //如果要删除的节点是队尾，则使队尾指针指向队头指针
            LQ->rear = LQ->front;
        free(s);            //释放指针p指向的节点
        return 1;
    }
}

/*取队头元素*/

int GetHead(LinkQueue LQ, DataType *e)
/*取链式队列中的队头元素，并将该元素赋值给e，取元素成功返回1，否则返回0*/
{
    LQNode *s;
    if (LQ.front == LQ.rear)       //在取队头元素之前，判断链式队列是否为空
        return 0;
    else {
        s = LQ.front->next;       //将指针p指向队列的第一个元素及队头元素
        *e = s->data;         //将队头元素赋值给e，取出队头元素
        return 1;
    }
}

/*清空队列*/
void ClearQueue(LinkQueue *LQ) {
    while (LQ->front != NULL) {
        LQ->rear = LQ->front->next;   //队尾指针指向队头指针指向的下一个节点
        free(LQ->front);            //释放队头指针指向的节点
        LQ->front = LQ->rear;         //队头指针指向队尾指针
    }
}

main运行函数

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include "LinkQueue.h"

#define MaxSize 100

typedef int DataType;

void PrintArray(int a[], int n, int N);

void YangHuiTriangle(int N);

int main() {
    int n;
    printf("清输入要打印的行数：\n");
    scanf("%d", &n);
    YangHuiTriangle(n);
}

void YangHuiTriangle(int N) {
    /*链式队列打印杨辉三角*/
    int i, k, n;
    DataType e, t;
    int temp[MaxSize];  //定义一个临时数组，用于存放每一行的元素
    LinkQueue Q;
    k = 0;                //
    InitQueue(&Q);      //初始化链队列
    EnQueue(&Q, 1);      //第一行元素入队
    for (int n = 2; n <= N; n++) {       //产生第n行元素病入队，同时将第n-1行的元素保存在临时数组中
        k = 0;
        EnQueue(&Q, 1);          //第n行的第一个元素入队
        for (int i = 1; i <= n - 2; i++) {      //利用队列中第n-1行元素产生的第i行的中间n-2个元素并入队
            DeQueue(&Q, &t);            //
            temp[k++] = t;       //将第n-1行的元素存入临时数组
            GetHead(Q, &e);     //取队头元素
            t = t + e;         //利用队列中的第n-1行元素产生第i行元素
            EnQueue(&Q, t);
        }
        DeQueue(&Q, &t);
        temp[k++] = t;          //将地n-1行的最后一个元素存入临时数组
        PrintArray(temp, k, N);
        EnQueue(&Q, 1);         //第n行的最后一个元素入队
    }
    k = 0;                          //将最后一行元素存入数组前，要将下表k置为0
    while (!QueueEmpty(Q)) {        //将最后一行元素存入临时数组
        DeQueue(&Q, &t);
        temp[k++] = t;
        if (QueueEmpty(Q))
            PrintArray(temp, k, N);
    }
}


/*打印数组中的元素，使能够以正确的形式输出*/
void PrintArray(int a[], int n, int N) {
    int i;
    static int count = 0;       //记录输出的行
    for (int i = 0; i < N - count; i++)     //打印空格
        printf("   ");
    count++;
    for (int i = 0; i < n; i++)         //打印数组中的元素
        printf("%6d", a[i]);
    printf("\n");
}

运行结果