árbol binario [Lista] B014_ en (doble recursividad | BFS + DFS)

Uno, Título Descripción

Given a binary tree root and a linked list with head as the first node. 

Return True if all the elements in the linked list starting from the head 
correspond to some downward path connected in the binary tree otherwise return False.

In this context downward path means a path that starts at some node and goes downwards.

, La solución segundo problema

Esta pregunta es título del torneo semana aquí por escrito lado.

Método uno: doble recursividad

rutinas recursivas:

• condición final:
  • Si se recorre el espacio de cabeza, probada para encontrar un camino en el árbol, de vuelta verdad.
  • Si la raíz está vacía, no se puede encontrar un camino para probar.
  • Si head.val root.val ==, podemos continuar la búsqueda desde el nodo de inicio.
  • Si head.val! = Root.val, la lista no se mueve, continúe árbol recursivo a la izquierda.

Hay dos puntos a destacar:

• En el método principal if (head.val == root.val) {no puede escribir directamente la siguiente declaración, tales como casos de prueba demasiado

  [1,10]
  [1,null,1,10,1,9]
  

  Recursiva subárbol derecho, ya head.next.val != root.right.valdirecta return false, lo que lleva a falso, con el resultado opuesto.
• Al escribir una condición de fin recursiva, la lista de la sentencia debe ser escrito en el frente del espacio vacío de unos pocos frase, porque el árbol está vacío, puede haber dos lados en cualquier lado vacío. Esto no garantiza que el árbol está completamente vacío.

return dfs(head.next, root.left) || dfs(head.next, root.right)

public boolean isSubPath(ListNode head, TreeNode root) {
  if (head == null)   return true;
  if (root == null)   return false;
  if (head.val == root.val) {	//1
    if (dfs(head.next, root.left) || dfs(head.next, root.right))
      return true;
  }
  return isSubPath(head, root.left) || isSubPath(head, root.right);
}
private boolean dfs(ListNode head, TreeNode root) {
  if (head == null)		//2
      return true;
  if (root == null)
      return false;
  if (head.val != root.val)
      return false;
  return dfs(head.next, root.left) || dfs(head.next, root.right);
}

---

Método dos: BFS + dfs

Guardar cada nodo capa con una cola, cuando se enfrentan nodo coincidente, el nodo desde el DFS.

public boolean isSubPath(ListNode head, TreeNode root) {
  Queue<TreeNode> queue  = new LinkedList<>();
  queue.add(root);
  while (!queue.isEmpty()) {
      TreeNode node = queue.poll();
      if (node.val == head.val) {
          if (dfs(head, node))
              return true;
      }
      if (node.left != null)  queue.add(node.left);
      if (node.right != null) queue.add(node.right);
  }
  return false;
}
private boolean dfs(ListNode head, TreeNode root) {
  if (head == null)
      return true;
  if (root == null)
      return false;
  if (head.val != root.val)
      return false;
  return dfs(head.next, root.left) || dfs(head.next, root.right);
}

Análisis de la complejidad

• Complejidad de tiempo: $O (n)$ ,
• Espacio de la complejidad: $O (n)$ ,