Ejercicios de estructura de datos: construya un árbol representado por una tabla generalizada y genere una secuencia

Descripción del Título:

【问题描述】
 给定一颗二叉树，要求从下至上按层遍历二叉树，每层的访问顺序是从左到右，每一层单独输出一行。

【输入形式】
 广义表表示的二叉树，结点元素类型为整型，且都大于0，例如：1( 2( 3 ( 4, 5 ) ), 6( 7, 8( 9, 10 ) ) )

【输出形式】
 从下至上，打印每一层的结点元素值，元素间以空格隔开。每层的访问顺序是从左到右，每一层单独输出一行。

【样例输入】
 1(2(3(4,5)),6(7,8(9,10)))，字符串内没有空格

【样例输出】
 4 5 9 10
 3 7 8
 2 6
 1

【样例说明】

【评分标准】
 本题目主要考察两个知识点：
 1.创建二叉树存储结构
 2.按层次遍历二叉树的算法

Idea de pregunta:

• Esta pregunta era un poco tonta cuando la miré por primera vez, porque esta es una tabla generalizada para construir un árbol binario, la trato de la siguiente manera:

1. Si encuentra "(", significa que necesita crear el subárbol izquierdo de este nodo
2. Si encuentra ")", significa que necesita operar en el nodo principal de este nodo
3. Si encuentra ",", significa que se ha creado el nodo izquierdo (es decir, la T actual apunta al nodo izquierdo), y se debe crear el nodo derecho del nodo padre de T

Por lo tanto, está claro que puede usar una pila creada manualmente (de hecho, también he usado la recursividad, pero el código escrito de forma recursiva es un poco problemático)

• Para la salida de la última capa, también podemos pensar en usar el recorrido de la secuencia de la capa, pero ¿cómo modificar el código del recorrido de la secuencia de la capa para la salida de la última capa en línea?

1. Usé una cola (la base del recorrido de la secuencia de capas), pero primero ingrese al nodo derecho, luego ingrese al nodo izquierdo y registre el nivel de cada nodo
2. Luego atraviesa la cola de atrás hacia adelante (esto explica por qué necesitas ingresar primero al nodo derecho y luego al izquierdo) [porque esto atravesará primero el nodo izquierdo del árbol y luego atravesará el nodo derecho cuando se atraviese la cola from back to front Node], para nodos del mismo nivel, salida en una línea y salida en diferentes líneas.

Código:

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

typedef struct tree {
    
    
    int data;
    struct tree* lchild;
    struct tree* rchild;
}*Ptree;

typedef struct quee {
    
    
    Ptree data[100];
    int lay[100];
    int num;
    int rear, front;
}*Pquee;

typedef struct stack {
    
    
    Ptree data[100];
    int rear;
}*Pstack;

void in(Pstack s, Ptree T) {
    
    
    s->data[s->rear++] = T;
}

void pop(Pstack s, Ptree& T) {
    
    
    T = s->data[--s->rear];
}

void creat(Ptree& T, Pstack& s, char string[], int& i) {
    
      // 1(2(3(4,5)),6(7,8(9,10)))
    T = (Ptree)malloc(sizeof(struct tree));
    T->lchild = NULL;   T->rchild = NULL;
    while (string[i] != '\0') {
    
    
        if (string[i] >= '0' && string[i] <= '9') {
    
    
            int num[10], n = 0;
            while (string[i] >= '0' && string[i] <= '9') {
    
    
                num[n++] = string[i] - '0';
                i++;  // 退出循环后i指向的为符号不是数字
            }
            int NUM = 0;
            for (int j = n; j > 0; j--) {
    
    
                int jiec = 1;
                for (int j1 = 1; j1 < j; j1++) {
    
    
                    jiec *= 10;
                }
                NUM += num[n - j] * jiec;
            }
            // printf("NUM = %d\n", NUM);
                //T = (Ptree)malloc(sizeof(struct tree));
                //T->lchild = NULL;   T->rchild = NULL;
            T->data = NUM;
            in(s, T);
        }
        // printf("string%d = %c\n", i, string[i]);

        if (string[i] == '(') {
    
    
            i = i + 1;
            T->lchild = (Ptree)malloc(sizeof(struct tree));
            T->lchild->lchild = NULL;   T->lchild->rchild = NULL;
            T = T->lchild;
        }
        if (string[i] == ')') {
    
    
            i = i + 1;
            pop(s, T);
            T = s->data[s->rear - 1];
        }
        if (string[i] == ',') {
    
    
            i = i + 1;
            pop(s, T);
            T = s->data[s->rear - 1];
            T->rchild = (Ptree)malloc(sizeof(struct tree));
            T->rchild->lchild = NULL;   T->rchild->rchild = NULL;
            T = T->rchild;
        }
    }
}

void print(Ptree T, Pquee q) {
    
    
    Ptree j = NULL;
    q->lay[q->rear] = 0;
    q->data[q->rear++] = T;
    int layer;
    while (q->front != q->rear) {
    
    
        layer = q->lay[q->front];
        j = q->data[q->front++];
        // 先入右结点
        if (j->rchild) {
    
    
            // printf("rch\n");
            q->lay[q->rear] = layer + 1;
            q->data[q->rear++] = j->rchild;
        }
        if (j->lchild) {
    
    
            // printf("lch\n");
            q->lay[q->rear] = layer + 1;
            q->data[q->rear++] = j->lchild;
        }
    }
    layer = q->lay[q->rear - 1];
    // printf("layer %d\n", layer);
    for (int i = q->rear - 1; i >= 0;) {
    
    
        // printf("lay[%d] i = %d\n", q->lay[i], i);
        if (q->lay[i] == layer) {
    
    
            printf("%d ", q->data[i]->data);
            i--;
        }
        else {
    
    
            printf("\n");
            layer--;
        }
    }
}

int main() {
    
    
    char string [100];
    scanf("%s", string);
    Pquee q = (Pquee)malloc(sizeof(struct quee));
    Pstack s = (Pstack)malloc(sizeof(struct stack));
    s->rear = 0;
    q->front = 0; q->rear = 0; q->num = 0;
    Ptree T = (Ptree)malloc(sizeof(struct tree));
    T->lchild = NULL;   T->rchild = NULL;
    int i = 0;
    creat(T->lchild, s, string, i);
    print(T->lchild, q);
    return 0;
}

resultado de la operación: