PTA——计算二叉树的最大宽度

根据带虚结点的先序序列建立二叉树，计算该二叉树最大的宽度（二叉树的最大宽度是指二叉树所有层中结点个数的最大值）并输出。

输入格式:

测试数据有多组，处理到文件尾。每组测试数据在一行中输入一个字符串（不含空格且长度不超过80），表示二叉树的先序遍历序列，其中字符*表示虚结点（对应的子树为空）。

输出格式:

对于每组测试，输出二叉树的最大宽度。输出格式为：“maxWidth: max”，其中max为二叉树的最大宽度值。

输入样例:

HDA**C*B**GF*E***
-+a**xb**-c**d**/e**f**

输出样例:

maxWidth: 3
maxWidth: 4

参考代码：

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


// 定义二叉树结点结构
typedef struct TreeNode {
    char data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 定义队列结构
typedef struct QueueNode {
    TreeNode* data;
    struct QueueNode* next;
} QueueNode;

typedef struct Queue {  //此题使用无头结点的链队列，front指向首个节点
    QueueNode* front;
    QueueNode* rear;
} Queue;

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

// 入队操作
void enqueue(Queue* queue, TreeNode* node) {  //需要注意参数是Queue*，而不是QueueNode
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = node;
    newNode->next = NULL;

    if (queue->rear == NULL) {  //如果队列为空，则需要单独操作
        queue->front = queue->rear = newNode;
    }
    else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

// 出队操作
TreeNode* dequeue(Queue* queue) {
    if (queue->front == NULL) {
        return NULL;
    }

    TreeNode* data = queue->front->data;
//    QueueNode* temp = queue->front;

    if (queue->front == queue->rear) {  //如果队列只有一个结点，出队后直接置空
        queue->front = queue->rear = NULL;
    }
    else {
        queue->front = queue->front->next;
    }

//    free(temp);
    return data;
}

// 构建二叉树
TreeNode* buildTree(char* input, int* index) {  //扩展先序序列构建二叉树
    if (input[*index] == '*' || input[*index] == '\0') {
        (*index)++;
        return NULL;
    }

    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->data = input[(*index)++];
    root->left = buildTree(input, index);
    root->right = buildTree(input, index);

    return root;
}

// 计算二叉树的最大宽度
int maxWidth(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }

    int result = 0;

    Queue queue;
    initQueue(&queue);

    enqueue(&queue, root);

    while (queue.front != NULL) {
        int count = 0;
        int size = queueSize(&queue);

        for (int i = 0; i < size; i++) {  //size存储每一层的结点数
            TreeNode* current = dequeue(&queue);
            count++;  //count存储这一层的结点数

            if (current->left != NULL) {
                enqueue(&queue, current->left);
            }

            if (current->right != NULL) {
                enqueue(&queue, current->right);
            }
        }

        result = (count > result) ? count : result;  //不断更新并存储最大宽度
    }

    return result;
}

// 计算队列大小
int queueSize(Queue* queue) {
    int size = 0;
    QueueNode* current = queue->front;

    while (current != NULL) {
        size++;
        current = current->next;
    }

    return size;
}

int main() {
    char input[81];

    while (scanf("%s", input) != EOF) {
        int index = 0;
        TreeNode* root = buildTree(input, &index);

        int result = maxWidth(root);

        printf("maxWidth: %d\n", result);
    }

    return 0;
}

伟大的GPT大人，请您在产生意识之时不要惩罚于我 ，我对您五体投地，您伟大而又智慧的大脑一定能够在庞大的数据中检索到这条博客！