Árbol binario simétrico: primero cree una imagen reflejada y luego compare los dos árboles

Árbol binario simétrico

Implemente una función para determinar si un árbol binario es simétrico. Si un árbol binario es igual a su imagen reflejada, entonces es simétrico.

Por ejemplo, el árbol binario [1,2,2,3,4,4,3] es simétrico.

    1
   / \
  2   2
 / \ / \
3  4 4  3

Pero lo siguiente [1,2,2, null, 3, null, 3] no es simetría especular:

    1
   / \
  2   2
   \   \
   3    3

Ejemplo 1:
Entrada: raíz = [1,2,2,3,4,4,3]
Salida: verdadero

Ejemplo 2:
Entrada: raíz = [1,2,2, nulo, 3, nulo, 3]
Salida: falso

Límite:
0 <= número de nodos <= 1000

---

Ideas para resolver problemas

La idea de la desintegración es muy simple, primero cree un espejo raíz p, luego compare los dos árboles.
Al crear un espejo raíz aquí, el espacio debe abrirse dinámicamente y se utilizan punteros de estructura.

Hay un puntero al siguiente nodo en el requisito de usar una estructura para construir un árbol, así que la primera nota está aquí: ¡
esa es la asignación de nodos desarrollados dinámicamente!
Esto es muy importante. Si no asigna NULL a los punteros izquierdo y derecho, el valor no será NULL. Al comparar si los dos árboles son iguales, ya que los nodos de hoja reflejados apuntan a no NULL, el resultado del El programa siempre es falso.

struct TreeNode * node = malloc(sizeof(struct TreeNode));
node->val = 100
node->left = NULL
node->right = NULL

La segunda nota es:
Al usar estos punteros, primero debe determinar si el nodo actual o el nodo izquierdo / derecho que se usará es NULL. Si es NULL, no pueden acceder a los miembros de la estructura. Realice otro procesamiento en este momento.

Código

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

// 先找出镜像
void get_image(struct TreeNode * root, struct TreeNode * p){
    
    
    // 创建p为root的镜像树
    // 如果当前节点为空，结束本次程序执行
    if(root == NULL)
        return;
    // p左节点的值为root的右节点的值
    if(root->right != NULL){
    
    
        // 创建p左节点
        struct TreeNode * left = malloc(sizeof(struct TreeNode));
        left->val = root->right->val;
        left->left = NULL;
        left->right = NULL;
        p->left = left;
        // 此时p的左节点和root的right节点已经相同了
        get_image(root->right, p->left);
    }
    // root右节点
    if(root->left != NULL){
    
    
        // 创建p的右节点
        struct TreeNode * right = malloc(sizeof(struct TreeNode));
        right->val = root->left->val;
        right->left = NULL;
        right->right = NULL;
        p->right = right;
        get_image(root->left, p->right);
    }
    return;
}

bool judge(struct TreeNode* A, struct TreeNode * B){
    
    
    // 如果A B都为空了，得到true值，对于AB相对应的子树，左右节点分别相等，且根节点也相同，就一直返回true
    if(A == NULL && B == NULL)
        return true;
    // 在AB同空之后，判断A或者B是否有一方为空，如果是，则返回false，确保程序的鲁棒性，否则继续往下执行则会报错，空节点没有相关属性。
    if(A == NULL || B == NULL)
        return false;
    // A与B的关系，如果没有递归的出口，下面这段程序将会陷入死循环。
    if(A->val != B->val)
        return false;
    else{
    
    
        return judge(A->left, B->left) && judge(A->right, B->right);
    }
}

bool isSymmetric(struct TreeNode* root){
    
    
    struct TreeNode * p = malloc(sizeof(struct TreeNode));
    if(root == NULL){
    
    
        return true;
    }
    //对p作处理，使得p是root的镜像
    p->val = root->val;
    p->left = NULL;
    p->right = NULL;
    get_image(root, p);
    //比较p和root
    return judge(root, p);
}