Pregunta 26 de la entrevista de Leetcode. Subestructura de árbol

Descripción del problema

Ingrese dos árboles binarios A y B para determinar si B es una subestructura de A. (Se acuerda que un árbol vacío no es una subestructura de ningún árbol)
B es una subestructura de A, es decir, A tiene la misma estructura y valor de nodo que B.

Informe de resolución de problemas.

B es una subestructura de A, hay tres casos:

El nodo raíz de B es el mismo que el nodo raíz de A, pero después de bifurcar, B se detiene primero; este caso corresponde a la helper()función.
B es la subestructura del subárbol izquierdo de A; este caso corresponde a la isSubStructure()función.
B es la subestructura del subárbol derecho de A; este caso corresponde a la isSubStructure()función.

Código de implementación

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==NULL||B==NULL){
            return false;
        }
        if(B->val==A->val){
            return helper(A->left,B->left)&&helper(A->right, B->right);
        }
        else{
            return isSubStructure(A->left,B)||isSubStructure(A->right, B);
        }
    }
    bool helper(TreeNode* A, TreeNode* B){
        // 边界条件
        if(A==NULL||B==NULL){
            return B==NULL?true:false;
        }
        
        if(A->val==B->val){
            return helper(A->left,B->left)&&helper(A->right, B->right);
        }
        else{
            return false;
        }
        return true;
    }
};

Referencias

[1] Pregunta 26 de la entrevista de Leetcode . Subestructura del árbol

Leetcode 617. Fusionar árbol binario

Descripción del problema

Dados dos árboles binarios, imagine que cuando superpone uno de ellos en el otro, algunos nodos de los dos árboles binarios se superpondrán.
Debe fusionarlos en un nuevo árbol binario. La regla de fusión es que si dos nodos se superponen, sus valores se agregan como el nuevo valor después de que se fusionen los nodos; de lo contrario, el nodo que no sea NULL se usará directamente como el nodo del nuevo árbol binario.

Informe de resolución de problemas.

Cuando el mismo nodo de ambos árboles no está vacío , los empujamos en la pila;
Cuando el nodo posterior del árbol izquierdo [correspondiente al árbol de la derecha] está vacío, dirija su seguimiento al nodo posterior del árbol derecho;
Cuando el nodo posterior del árbol izquierdo [correspondiente al árbol de la derecha] no está vacío, y el nodo posterior del nodo correspondiente de la derecha está vacío, no se procesa.

Código de implementación

No recursivo

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
	TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
		if (t1 == NULL) return t2;
		if (t2 == NULL) return t1;
		stack<TreeNode*>s;
		s.push(t1);
		s.push(t2);
		while (!s.empty()){
			TreeNode* s2 = s.top();
			s.pop();
			TreeNode* s1 = s.top();
			s.pop();
			s1->val = s1->val + s2->val;
			if (s1->left == NULL) s1->left = s2->left;
			else if (s1->left != NULL && s2->left != NULL){
				s.push(s1->left);
				s.push(s2->left);
			}
			if (s1->right == NULL) s1->right = s2->right;
			else if (s1->right != NULL && s2->right != NULL){
				s.push(s1->right);
				s.push(s2->right);
			}
		}
		return t1;
	}
};

Recursivo

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2)
    {
        if(!t1)
            return t2;
        if(!t2)
            return t1; 
        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        return t1;
    }
};

Referencias

Pregunta 28 de la entrevista de Leetcode. Árbol binario simétrico

Descripción del problema

Implemente una función para determinar si un árbol binario es simétrico. Si un árbol binario es igual a su imagen especular, entonces es simétrico.
Por ejemplo, el árbol binario [1,2,2,3,4,4,3]es simétrico. Pero no [1,2,2,null,3,null,3]es simétrico.

Informe de resolución de problemas.

El análisis de los recursivas subárboles izquierdo y derecho es simétrico.
La simetría de los subárboles izquierdo y derecho debe satisfacer las siguientes tres condiciones:

El valor del nodo raíz del subárbol izquierdo es igual al valor del nodo raíz del subárbol derecho;
El subárbol izquierdo del subárbol izquierdo y el subárbol derecho del subárbol derecho son simétricos;
El subárbol derecho del subárbol izquierdo y el subárbol izquierdo del subárbol derecho son simétricos.

Código de implementación

No recursivo

class Solution{
    public:
        bool isSymmetric(TreeNode *root){
            TreeNode *left, *right;
            if(root==NULL) return true;
            queue<TreeNode*>q;
            q.push(root->left);
            q.push(root->right);
            while(!q.empty()){
                left=q.front();
                q.pop();
                right=q.front();
                q.pop();
                if(left==NULL&&right==NULL) continue;
                if(left==NULL||right==NULL) return false;
                if(left->val != right->val) return false;

                q.push(left->left);
                q.push(right->right);

                q.push(left->right);
                q.push(right->left);
            }
            return true;
        }
};

Recursivo

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root!=NULL){
            return helper(root->left, root->right);
        }
        return true;
    }
    bool helper(TreeNode*left, TreeNode*right){
        if(left==NULL&&right==NULL) return true;
        if(left==NULL||right==NULL) return false;
        if(left->val != right->val) return false;
        return helper(left->left, right->right)&&helper(left->right,right->left);
    }
};