数据结构实验4.3：利用队列实现杨辉三角的输出

文章目录

一，问题描述
二，基本要求
三，算法设计
四，示例代码
五，实验操作
六，运行效果

一，问题描述

借助队列实现杨辉三角的输出。杨辉三角是一个由数字排列成的三角形数表，其特点是每行的数字是由上一行相邻两个数字相加得到（边界数字为 1）。通过使用队列这种数据结构，我们可以按照一定的逻辑顺序来生成和输出杨辉三角的每一行数字，从而实现杨辉三角的可视化展示。

二，基本要求

（1）设计队列存储结构：
使用结构体来定义队列的存储结构，队列包含一个指向存储元素的指针，队头指针，队尾指针以及队列的容量等信息。例如：

typedef int QElemType;
typedef struct {
    
    
    QElemType *base;
    int front;
    int rear;
    int capacity;
} SqQueue;

（2）编写队列初始化（InitQueue）、入队（EnQueue）、出队（DeQueue）、判断队空、判断队满等基本操作函数：

// 队列初始化函数
Status InitQueue(SqQueue &Q, int maxSize) {
    
    
    Q.base = (QElemType *)malloc(maxSize * sizeof(QElemType));
    if (!Q.base) return ERROR;
    Q.front = Q.rear = 0;
    Q.capacity = maxSize;
    return OK;
}

// 入队函数
Status EnQueue(SqQueue &Q, QElemType e) {
    
    
    if ((Q.rear + 1) % Q.capacity == Q.front) return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % Q.capacity;
    return OK;
}

// 出队函数
Status DeQueue(SqQueue &Q, QElemType &e) {
    
    
    if (Q.front == Q.rear) return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % Q.capacity;
    return OK;
}

// 判断队空函数
int QueueEmpty(SqQueue Q) {
    
    
    return Q.front == Q.rear;
}

// 判断队满函数
int QueueFull(SqQueue Q) {
    
    
    return (Q.rear + 1) % Q.capacity == Q.front;
}

（3）设计用队列实现输出杨辉三角的算法：

初始化一个队列，并将 1 入队，用于生成杨辉三角的第一行（只有一个数字 1）。
对于每一行（从第二行开始）：
- 先记录当前行的元素个数（等于当前行数）。
- 入队一个 1，作为当前行的第一个元素（杨辉三角每行开头为 1）。
- 遍历上一行的元素（通过不断出队和入队操作），将相邻两个元素相加后入队，得到当前行的中间元素。
- 入队一个 1，作为当前行的最后一个元素（杨辉三角每行结尾为 1）。
- 输出当前行的元素（通过不断出队操作）。
重复步骤 2，直到生成并输出完所需行数的杨辉三角。

三，算法设计

队列在输出杨辉三角时的作用分析：
队列在生成杨辉三角的过程中起到了存储和传递数据的作用。通过入队和出队操作，我们可以按顺序处理每一行的元素。每次生成新的一行时，利用队列保存上一行的元素，并通过相邻元素相加的操作来得到当前行的元素。同时，队列保证了元素处理的顺序性，使得我们能够按照杨辉三角的规律依次生成和输出每一行的数字，避免了复杂的数据管理和混乱的计算顺序。

主要步骤如下：

初始化队列并将第一行的 1 入队。
按行数循环，每一行先入队开头的 1，然后处理上一行元素得到中间元素入队，最后入队结尾的 1。
输出当前行元素并清理队列，为下一行做准备。
重复步骤 2 和 3，直到输出完指定行数的杨辉三角。

四，示例代码

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

#define OK 1
#define ERROR 0
#define MAXSIZE 100

typedef int Status;
typedef int QElemType;

// 定义队列结构体
typedef struct {
    
    
    QElemType* base;
    int front;
    int rear;
    int capacity;
} SqQueue;

// 初始化队列
Status InitQueue(SqQueue* Q) {
    
    
    Q->base = (QElemType*)malloc(MAXSIZE * sizeof(QElemType));
    if (!Q->base) {
    
    
        return ERROR;
    }
    Q->front = Q->rear = 0;
    Q->capacity = MAXSIZE;
    return OK;
}

// 入队操作
Status EnQueue(SqQueue* Q, QElemType e) {
    
    
    if ((Q->rear + 1) % Q->capacity == Q->front) {
    
    
        return ERROR;
    }
    Q->base[Q->rear] = e;
    Q->rear = (Q->rear + 1) % Q->capacity;
    return OK;
}

// 出队操作
Status DeQueue(SqQueue* Q, QElemType* e) {
    
    
    if (Q->front == Q->rear) {
    
    
        return ERROR;
    }
    *e = Q->base[Q->front];
    Q->front = (Q->front + 1) % Q->capacity;
    return OK;
}

// 输出n行杨辉三角
void out_number(int n) {
    
    
    SqQueue Q;
    InitQueue(&Q);
    int s1 = 0, s2 = 1;
    int i, j;

    // 输出第一行
    printf("%d\n", s2);
    EnQueue(&Q, s1 + s2);

    for (i = 2; i <= n; i++) {
    
    
        s1 = 0;
        for (j = 1; j <= i - 1; j++) {
    
    
            DeQueue(&Q, &s2);
            printf("%d ", s2);
            EnQueue(&Q, s1 + s2);
            s1 = s2;
        }
        // 输出每行的最后一个 1
        printf("1\n");
        EnQueue(&Q, 1 + s2);
    }
    free(Q.base);
}

int main() {
    
    
    int n;
    printf("请输入要输出的杨辉三角的行数: ");
    scanf("%d", &n);
    out_number(n);
    return 0;
}