Árbol binario del algoritmo LeetCode: 116. Complete el siguiente puntero de nodo derecho de cada nodo

Tabla de contenido

116. Complete el siguiente puntero de nodo derecho de cada nodo

Dado un árbol binario perfecto , todos sus nodos hoja están al mismo nivel y cada nodo padre tiene dos nodos hijos. Un árbol binario se define de la siguiente manera:
estructura Nodo { 
  int val; 
  Nodo *izquierda; 
  Nodo *derecha; 
  Nodo *siguiente; 
}
Complete cada uno de sus siguientes punteros para que este puntero apunte a su siguiente nodo derecho. Si no se encuentra el siguiente nodo derecho, el siguiente puntero se establece en NULL.

Inicialmente, todos los punteros siguientes están configurados en NULL.

Ejemplo 1:
Entrada: raíz = [1,2,3,4,5,6,7]
 Salida: [1,#,2,3,#,4,5,6,7,#]
 Explicación: El árbol binario dado es como como se muestra en la Figura A Como se muestra, su función debe llenar cada uno de sus siguientes punteros para apuntar a su siguiente nodo derecho, como se muestra en la Figura B. La salida serializada está organizada en orden transversal de capas. Los nodos en la misma capa están conectados por los siguientes punteros y '#' marca el final de cada capa.
Ejemplo 2:
Entrada: raíz = []
 Salida: []
pista:

El número de nodos en el árbol está [0, 212 - 1] dentro del rango.

-1000 <= node.val <= 1000

Avanzado:

Sólo puedes utilizar espacio extra constante.

El uso de la recursividad para resolver el problema también cumple con los requisitos: el espacio de pila ocupado por el programa recursivo en este problema no se cuenta como complejidad de espacio adicional.

Solución iterativa al problema:

// Solución iterativa: una observación cuidadosa revela que existen dos métodos de conexión

// 1. Dos puntos de conexión tienen un nodo principal común

// 2. Los nodos padres de los dos puntos de conexión son diferentes: son un nodo y el nodo izquierdo del siguiente vecino de la capa superior.

// Podemos procesar sus nodos secundarios en función del nodo actual, lo que equivale a procesar capa por capa.

// Entonces se necesitan dos bucles anidados. El horizontal dentro maneja la capa y luego ingresa a la siguiente capa verticalmente.

Código:

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    // 迭代解决：仔细观察发现有两种连接方式
    // 1、两个连接点有共同父节点
    // 2、两个连接点父节点不同，分别是一个节点和上一层邻居next的左节点
    // 我们可以根据当前节点处理他的子节点，相当于一层一层处理
    // 所以需要两个循环嵌套，里面的横向处理完该层，再竖向进入下一层
    public Node connect(Node root) {
        // 特判：无节点则不需处理
        if(root==null) return root;
        // 定义一个节点等于root
        Node pre=root;
        // 左节点不为空则这层需要处理，进入循环开始处理这一层
        while(pre.left!=null){
            Node tmp=pre;
            while(tmp!=null){
                // 处理有共同父节点的连接点
                tmp.left.next=tmp.right;
                // 处理父节点不同的连接点
                if(tmp.next!=null){
                    tmp.right.next=tmp.next.left;
                }
                // 横向移动处理这一层未处理的节点
                tmp=tmp.next;
            }
            // 竖向移动处理下一层
            pre=pre.left;
        }
        return root;
    }
}