Recorrido de secuencia del árbol binario II

1. Demanda

• Dado un árbol binario, devuelve el recorrido ascendente de sus valores de nodo. (Es decir, desde la capa donde se encuentra el nodo hoja hasta la capa donde se encuentra el nodo raíz, atravesar de izquierda a derecha capa por capa);

Por ejemplo:
dado un árbol binario [3,9,20,null,null,15,7]

3 
   / \ 
  9 20 
    / \ 
   15 7

Devuelve su recorrido de secuencia ascendente como:

[ 
  [15,7], 
  [9,20], 
  [3] 
]

Dos, método BFS 1

2.1 Análisis de pensamiento

1. Según la idea de imprimir el árbol binario II de arriba a abajo: https://blog.csdn.net/Sruggle/article/details/108064919 , aquí está el último en invertir la lista;

2.2 Implementación del código

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(queue.size() != 0) {
            List<Integer> tmp = new ArrayList<>();
            int count = queue.size();
            while(count != 0) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
                count--;
            }
            res.add(tmp);
        }
        Collections.reverse(res);
        return res;
    }
}

2.3 Análisis de complejidad

• La complejidad del tiempo es O (N), donde N es el número de elementos en el árbol binario y todos los elementos deben atravesarse;
• La complejidad del espacio es O (N) y la cola puede almacenar hasta N / 2 elementos al mismo tiempo;

Tres, método BFS 2

3.1 Análisis de pensamiento

1. Usando LinkedList, cada fila del árbol binario se agrega a la primera posición cada vez, lo que elimina la complejidad causada por la inversión en el Método 2;

3.2 Implementación del código

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> res = new LinkedList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(queue.size() != 0) {
            List<Integer> tmp = new ArrayList<>();
            int count = queue.size();
            while(count != 0) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
                count--;
            }
            res.addFirst(tmp);
        }
        return res;
    }
}