Amplitud primero algoritmo de búsqueda BFS

Introducción a BFS

Similar al recorrido de la jerarquía de árbol binario, primero recorre los nodos de la misma profundidad y luego recorre a diferentes profundidades después del recorrido

PD: (Después de ver el video miles de veces, no puedo entenderlo. Efectivamente, la forma más rápida de aprender un algoritmo es escribir preguntas ...)

Preguntas de la entrevista de LeetCode 04.03. Lista vinculada de nodos de profundidad específicos

Dado un árbol binario, diseñe un algoritmo para crear una lista vinculada que contenga todos los nodos a una cierta profundidad (por ejemplo, si la profundidad de un árbol es D, entonces se crearán listas vinculadas D). Devuelve una matriz de listas vinculadas de todas las profundidades.

Ejemplo:

Entrada: [1,2,3,4,5, null, 7,8]

       1
  	  /  \ 
 	 2    3
 	/  \   \ 
   4   5    7    
  /   
 8

Resultado: [[1], [2,3], [4,5,7], [8]]

Ideas:

Implementar BFS simple con recursividad + cola

Código:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    vector<ListNode*> listOfDepth(TreeNode* tree) {
    
    
        vector<ListNode*> ans;
        queue<TreeNode*> q;
        q.push(tree);
        while(!q.empty()){
    
    
            int size=q.size();
            TreeNode *node;
            ListNode *head,*prev,*curr;
            for(int i=0;i<size;++i){
    
    
                node=q.front();
                q.pop();
                if(i==0){
    
    
                    head=new ListNode(node->val);
                    prev=head;
                }
                else{
    
    
                    curr=new ListNode(node->val);
                    prev->next=curr;
                    prev=prev->next;
                }
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            ans.push_back(head);
        }
        return ans;

    }
};