Métodos de búsqueda

Búsqueda – busca un elemento en una estructura de datos ordenada, si el valor aparece

dentro de la estructura, nos va a devolver la posición en la que se encuentra y en caso
contrario va a devolver un nulo

Búsqueda secuencial o lineal

Se utiliza cuando el vector no está ordenado o no puede ser ordenado previamente. Consiste
en buscar el elemento comparándolo secuencial-mente (de ahí su nombre) con cada elemento
del arreglo hasta encontrarlo, o hasta que se llegue al final. La existencia se puede asegurar
cuando el elemento es localizado, pero no podemos asegurar la no existencia hasta no haber
analizado todos los elementos del arreglo.

Ejemplo:

def busquedaSecuencial(unaLista, item):
    pos = 0

    encontrado = False

    while pos < len(unaLista) and not encontr
ado:
        if unaLista[pos] == item:
            encontrado = True
        else:
            pos = pos+1

    return encontrado

listaPrueba = [1, 2, 32, 8, 17, 19, 42, 13, 0]
print(busquedaSecuencial(listaPrueba, 3))
print(busquedaSecuencial(listaPrueba, 13))
Datos de entrada:
  vec: vector en el que se desea buscar el dato
  tam: tamaño del vector. Los subíndices válidos van desde 0 hasta tam-1 inclusive.
  dato: elemento que se quiere buscar.
Variables
  pos: posición actual en el arreglo
pos = 0
Mientras pos < tam:
  Si vec[pos] == dato devolver verdadero y/o pos, de lo contrario:
  pos = pos + 1
Fin (Mientras)
Devolver falso,

Búsqueda binaria
La búsqueda binaria, lo que hace es repetidamente apuntar al centro de la estructura de
búsqueda y dividir el espacio restante por la mitad, así hasta encontrar el valor buscado. Esto
es una gran ventaja en cuanto a la búsqueda lineal que, para encontrar el valor buscado, debe
ir descartando elemento por elemento.lo que hace es repetidamente apuntar al centro de la
estructura de búsqueda y dividir el espacio restante por la mitad, así hasta encontrar el valor
buscado. Esto es una gran ventaja en cuanto a la búsqueda lineal que, para encontrar el valor
buscado, debe ir descartando elemento por elemento.

Ejemplo:

list = [1, 2, 3, 4, 5, 6, 7, 8 , 9]
def search(list, item):
low = 0
high = len(list)-1 while low <= high:
mid = (low + high)
aux = list[mid]
if aux == item:
return mid
if aux > item:
high = mid -1
else:
low = mid + 1
return Noneprint(search(list, 5)) # => 4
print(search(list, -5)) # => None

Búsqueda árbol binario

Es un estructura ordenada de datos donde cada registro puede estar relacionado con otros
registros

#define ABB_VACIO NULL

#define TRUE 1
#define FALSE 0

typedef int tEtiqueta /*Algun tipo adecuado*/

typedef struct tipoceldaABB{
struct tipoceldaABB *hizqda,*hdrcha;
tEtiqueta etiqueta;
}*nodoABB;
typedef nodoABB ABB;

ABB Crear(tEtiqueta et)

{
ABB raiz;

raiz = (ABB)malloc(sizeof(struct tceldaABB));

if (raiz == NULL)
error("Memoria Insuficiente.");
raiz->hizda = NODO_NULO;
raiz->hdcha = NODO_NULO;
 raiz->etiqueta = et;
return(raiz);
}

int Pertenece(tElemento x,ABB t)

{

if(!t)
return FALSE
else if(t->etiqueta==x)
return TRUE;
else if(t->etiqueta>x)
return pertenece(x,t->hizqda);
else return pertenece(x,t->hdrcha);
}

void Inserta(tElemento x,ABB *t)

{

if(!(*t)){
*t=(nodoABB)malloc(sizeof(struct tipoceldaABB));
if(!(*t)){
error("Memoria Insuficiente.");
}
(*t)->etiqueta=x;
(*t)->hizqda=NULL;
(*t)->hdrcha=NULL;
} else if(x<(*t)->etiqueta)
inserta(x,&((*t)->hizqda));
else
inserta(x,&((*t)->hdrcha));
}