No existe información sobre la cantidad de

estados intermedios o el costo de ruta para

pasar del estado actual a la meta.

Sólo se sabe distinguir si estamos en el

estado meta o no.

A esta búsqueda se le conoce también como

búsqueda ciega.

Existen varios métodos:

a)Búsqueda preferente por amplitud

b)Búsqueda preferente por profundidad

c)Búsqueda de costo uniforme

d)Búsqueda limitada por profundidad

e)Búsqueda por profundización iterativa

f) Búsqueda bidireccional

La búsqueda en amplitud, consiste en recorrer el árbol por niveles; es decir,

primero se recorre el padre, luego los hijos de este(de izquierda a derecha),

luego los nietos… y así sucesivamente hasta encontrar el elemento buscado.

Para nuestro algoritmo hemos definido las funciones padre, hd y hi que

devuelven(si es que existen) respectivamente el nodo-padre, el hijo izquierdo y

el hijo derecho. Estas funciones han sido usadas dentro nuestro algoritmo

principal bpa que es iterativo, y consiste en comparar los elementos hasta que la

lista ingresada este vacía. Primero verifica si el padre es elemento buscado y

hace lo mismo con los hijos de este, luego envía como la lista a evaluar todo el

hijo izquierdo y todo el hijo derecho para hacer lo mismo.

CL-USER 1> (defun bpa(elm lst)

(cond ((null lst) nil)((equal nil(padre lst))nil)

(t(if(equal elm(padre lst))t

(if (equal elm (hi lst)) t

(if (equal elm (hd lst)) t

(or (bpa elm (second lst)) (bpa elm(third lst)))))))))

BPA

CL-USER 2> (defun padre(lst))

(if (atom lst) nil

(first lst)))

PADRE

CL-USER 3> (defun hd(lst)

(if (equal nil (third lst)) nil

(if (atom (third lst)) (third lst)

(first (third lst)))))

HD

CL-USER 4> (defun hi(lst)

(if (equal nil (second lst)) nil

(if (atom (second lst)) (second lst)

(first (second lst)))))

HI

CL-USER 5> bpa ‘e’(a(b c d)(e f))

T

CL-USER 6> bpa ‘d’(a(b c d)(e f))

T

La búsqueda por profundidad, consiste en recorrer los nodos de un árbol de la siguiente manera:

Padre- Hijo Izquierdo-Hijo Derecho, es decir primero observa si el «padre» es el elemento

buscado, luego observa a su «hijo izquierdo» y luego su «hijo derecho»; recursivamente a cado

uno de sus hijos, en otras palabras recorre todos los hijos izquierdos y luego los hijos derechos

hasta encontrar el elemento buscado.

En nuestro algoritmo; cuando un árbol se expresa en lista, todos los nodos se ingresan en pre-

orden (Padre- H Izq- H Der), entonces sólo tendremos que recorrer de elemento en elemento de

la «lista» (árbol) ingresada hasta encontrar nuestro elemento.

Se define una función principal «Buscar»; que recibe 2 parámetros, el primero el elemento a

buscar y el segundo el árbol donde se buscara dicho elemento. Luego pasa a la función

«Busq_Prof»; que recibe 3 parámetros, el primero el elemento a buscar, el segundo el primero

(átomo o lista) del árbol y por último el resto del árbol, y así buscara el elemento recursivamente.

CL-USER 1> (defun Busq_Porf(n P R)

(if (atom P) (if (null P) (if (null R) 100 (Busq_Prof n (first R)(rest R)))

(if (equal n P) 1 (if (null R) 100 (+ 1 (Busq_Prof n (first R)(rest R))))))

(Busq_Prof n (first P)(if (null(rest P)) R (cons (rest P) R)))))

BUSQ_PROF

CL-USER 2> (defun Buscar(x A)

(setq Canti_Nod (Busq_Prof x (first A)(rest A)))

(if (> Canti_Nod 100)(format t «No se encontro el elemento ~d» x)

(format t «Se recorrio ~d nodos para habllar el elemento ~d» Canti_Nod x)))

BUSCAR

CL-USER 3> Buscar ‘4’(1(2 4 5)(3 6))

Se recorrió 3 nodos para hallar el elemento 4

CL-USER 4> Buscar ‘10’(1(2 4 5)(3 6))

No se encontró el elemento 10