CURSOS: PROGRAMACION II

TEMA: METODOS DE BUSQUEDA

DESCRIPCION: Estudio de los métodos de búsqueda lineal y binaria aplicados sobre

arreglos de tipo numérico, con el respectivo diseño e implementación de clases usando
interfaz de usuario con ventanas.

OBJETIVO: Diseñar e implementar clases para efectuar la búsqueda lineal y binaria

sobre arreglos de números enteros, desarrollando la interfaz de usuario con ventanas en
lazarus.

PALABRAS CLAVES: Arreglos, ciclos, búsqueda lineal, búsqueda binaria, uso de

componentes, inspector de propiedades, proyectos o aplicaciones lazarus.

MÉTODOS DE BÚSQUEDA

Los métodos de búsqueda nos permiten recuperar información de un vector o un archivo,

que contenga una lista de datos. Por ejemplo se puede obtener el nombre y el número
telefónico de nuestra agenda de contactos o la nota obtenida por un alumno en la lista de
un curso.

Cuando se realizan búsquedas sobre vectores, se desea es encontrar la posición que

ocupa el elemento buscado dentro de la lista de elementos que contiene el vector. Para la
búsqueda de información en archivos es necesario realizar la búsqueda a partir de un
campo clave dentro del archivo.

Existen diferentes métodos de búsqueda y se puede determinar con cual método trabajar
dependiendo de la cantidad de elementos que existan en el vector o la organización de
dichos elementos.

A continuación para determinar si un elemento pertenece a un conjunto de elementos e

indicar su posición dentro de un vector, utilizaremos los métodos de búsqueda secuencial
(lineal) y búsqueda binaria.

Búsqueda Secuencial o Lineal:

En este método se recorre el vector desde el primer elemento hasta el ultimo,

comparando cada elemento del vector con el valor buscado, hasta que se encuentre el
elemento o se llegue al final del vector. Este método es recomendado para realizar
búsquedas con pocos datos.

Implementación del método que busca lineal o secuencial, y devuelve la posición del dato
a buscar que se pasa como parámetro:

function TBusquedas.busquedaLineal(dato: string): integer;

var
i:integer; //variable para controlar el ciclo while.
 pos:integer; //variable que devuelve la posición en la que se encuentra el elemento en el vector.
begin
//Asigno el valor de -1 a la variable pos para devolver este valor en el supuesto caso de que no se encuentre
//el valor buscado dentro del vector.
pos:=-1;
i:=1;
//Mientras que no se llegue al final del vector y no se haya encontrado el dato buscado en el vector.
while (i <= num) and (pos = -1) do
begin
//Si el contenido del vector en la posición i-esima es igual al dato que se esta buscando entonces el dato si
//esta en el vector y devuelvo la posición en donde se encuentra el dato dentro del vector. Sino el dato no se
//encuentra en esa posición, entonces incremento la posición (i) para realizar una nueva comparación.
if getVector(i) = dato then
begin
pos:=i;
end
else
begin
i:=i+1;
end;
end;
//Al final retorno la posición en donde se encuentra el elemento buscado.
Result:=pos;
end;

Búsqueda Binaria:

Este método es una técnica eficaz para realizar búsquedas en vectores o archivos que
contengan un mayor número de datos. Este método divide el vector en mitades de
manera sucesiva hasta que encuentra el dato buscado, es decir, el método divide el
vector y se examina el elemento central del vector.

Si es el elemento que se busca, entonces la búsqueda finaliza, pero sino se determina si

el dato buscado esta en la primera o la segunda mitad del vector y se repite el proceso en
la nueva mitad, buscando su elemento central. Para realizar la búsqueda binaria el vector
debe estar ordenado y se comienza comparando con el elemento central.

Implementación del método que busca de manera binaria, y devuelve la posición del dato
a buscar que se pasa como parámetro:

function TBusquedas.bsuquedaBinaria(dato: string): integer;

var
//Variables para controlar las diferentes posiciones el vector.
pos, izq, der, centro:integer;
begin
//Es necesario primero ordenar el vector con algún método de ordenamiento.
ordenarIntercambio;
izq:=1;
der:=num;
//Asigno el valor de -1 a la variable pos para devolver este valor en el supuesto caso de que no se encuentre
//el valor buscado dentro del vector.
pos:=-1;
//Mientras que no se llegue al final del vector y no se haya encontrado el dato buscado en el vector.
while (izq <= der) and (pos = -1) do
begin
//Busco cual es la posición del dato que se encuentra en el centro del vector, utilizo div para que la posición
//siempre de un valor entero.
 centro:=(izq+der) div 2;
//Si el dato es igual a lo que tiene el vector en la posición del centro, entonces ya encontró el elemento
//buscado y se devuelve la posición en donde se encontró, pero sino entonces se determina si el elemento
//esta a la izquierda o a la derecha del vector. Y se procede a buscar el dato hacia el inicio del vector
//(izquierda) o hacia el final del vector (derecha), esto si el dato buscado es mayor o menor al elemento que
//se encuentra en el centro del vector.
if dato = getVector(centro) then
begin
pos:=centro;
end
else
if dato < getVector(centro) then
begin
//Reducimos el extremo derecho, moviendolo hacia el inicio del vector (izquierda).
der:=centro-1;
end
else
begin
//El elemento esta a la derecha del centro y hacemos el recorrido hacia el final del vector (derecha).
izq:=centro+1;
end;
end;
//Al final retorno la posición en donde se encuentra el elemento buscado.
Result:=pos;
end;

A continuación implementaremos un ejercicio que permite almacenar una cantidad

especifica de teléfonos celulares en un vector y posteriormente implementamos los
métodos de búsqueda descritos anteriormente, para determinar si un número celular se
encuentra almacenado dentro del vector.

Creamos un nuevo proyecto para implementar el ejercicio y automáticamente se crea una

unidad con la clase TForm1. Procedemos a guardar esta unidad con el nombre
UVentanaBusquedas, para implementar todo el cógido que tendrá el formulario.

A continuación se crea la unidad en donde se implementara el código de la clase lógica y

se guarda con el nombre UMetodosBusqueda. En esta clase se declara el vector y sus
respectivos métodos selectores, modificadores, así como los métodos de búsqueda que
solucionan el problema planteado.

Para el diseño del formulario (clase TForm1), en donde se capturan los datos y se
muestra la información, se utilizaran los siguientes componentes con sus respectivos
nombres:

● Tres TEdit (campos de texto), uno para mostrar las diferentes posiciones de cada
indice en el vector, uno para capturar los teléfonos celulares y otro para realizar las
búsquedas. Los nombres que se utilizaran para los TEdit son: posi, val y bus
respectivamente.

● Un TUpDown que llamaremos Up para ir incrementando las posiciones del campo

de texto posi de manera automática. Tenemos que tener en cuenta la propiedad
Associate del TUpDown (Up) para asociarlo con el TEdit (posi) e iniciar la
propiedad Min en 1.

● Cuatro TButton (botones), para ir guardando los elementos, mostrar los elementos
 del vector, limpiar y salir de la aplicación. Los nombres que se utilizaran para los
TButton son: bGuardar, bMostrar, bLimpiar y bSalir respectivamente.

● Un TListBox de nombre lisvec para visualizar el contenido del vector, a medida

que se almacenen elementos en el vector.

● Un TComboBox de nombre op para seleccionar con que método (secuencial o

binaria) queremos realizar la búsqueda en el vector. El TComboBox (op) en la
propiedad Items tendrá las opciones: Secuencial y Binaria.

● También se utilizaran varios TLabel para colocar los diferentes comentarios que
aparecen en el formulario.

La apariencia del formulario sera lago parecida a la siguiente ventana:

Implementación de la clase lógica TBusquedas en la unidad UMetodosBusqueda:

unit UMetodosBusqueda;

{$mode objfpc}{$H+}

interface

uses
Classes, SysUtils;
const
num=20;
type
 { TBusquedas }

TBusquedas=class
private
vector:array[1..num] of string;
public
constructor create;
procedure setVector(p:integer; ve:string);
function getVector(p:integer):string;
//Declaración del método que retorna la posición del dato buscado, utilizando el método de búsqueda lineal
//o secuencial. El método recibe como parámetro el dato que se desea buscar dentro del arreglo.
function busquedaLineal(dato:string):integer;
//Declaración del método de ordenamiento por intercambio, este método se utilizara en la implementación
//del método de búsqueda binaria ya que para la búsqueda binaria se requiere que los elementos del vector
//estén ordenados.
procedure ordenarIntercambio;
//Declaración del método que retorna la posición del dato buscado, utilizando el método de búsqueda binaria
//el método recibe como parámetro el dato que se desea buscar dentro del arreglo.
function bsuquedaBinaria(dato:string):integer;
end;

implementation

{ TBusquedas }

constructor TBusquedas.create;
var
i:integer;
begin
for i:=1 to num do
begin
vector[i]:='0';
end;
end;

procedure TBusquedas.setVector(p: integer; ve: string);

begin
vector[p]:=ve;
end;

function TBusquedas.getVector(p: integer): string;

begin
Result:=vector[p];
end;
//Implementación del método que busca lineal o secuencialmente los datos en el vector. Ya se documento el
//código anteriormente.
function TBusquedas.busquedaLineal(dato: string): integer;
var
i:integer;
pos:integer;
begin
pos:=-1;
i:=1;
while (i <= num) and (pos = -1) do
begin
if getVector(i) = dato then
begin
pos:=i;
end
else
begin
i:=i+1;
 end;
end;
Result:=pos;
end;
//Implementación del método de ordenamiento por intercambio. Este método es necesario para ordenar el
//vector en el método de búsqueda binaria.
procedure TBusquedas.ordenarIntercambio;
var
i,j:integer;
temp:string;
begin
for i:=1 to num do
begin
for j:=i+1 to num do
begin
if getVector(i) > getVector(j) then
begin
temp:=getVector(i);
setVector(i, getVector(j));
setVector(j, temp);
end;
end;
end;
end;

//Implementación del método de búsqueda binaria.

function TBusquedas.bsuquedaBinaria(dato: string): integer;
var
pos, izq, der, centro:integer;
begin
ordenarIntercambio;
izq:=1;
der:=num;
pos:=-1;
while (izq <= der) and (pos = -1) do
begin
centro:=(izq+der) div 2;
if dato = getVector(centro) then
begin
pos:=centro;
end
else
if dato < getVector(centro) then
begin
der:=centro-1;
end
else
begin
izq:=centro+1;
end;
end;
Result:=pos;
end;

end.

Implementación de la clase lógica TForm1 en la unidad UVentanaBusquedas:

unit UVentanaBusquedas;

{$mode objfpc}{$H+}
interface

uses
Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, UMetodosBusqueda,StdCtrls,
ComCtrls;

type

{ TForm1 }

TForm1 = class(TForm)
bGuardar: TButton;
bus: TEdit;
bMostrar: TButton;
bLimpiar: TButton;
bSalir: TButton;
op: TComboBox;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
lisvec: TListBox;
val: TEdit;
Label3: TLabel;
posi: TEdit;
Label1: TLabel;
Label2: TLabel;
Up: TUpDown;
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure bGuardarClick(Sender: TObject);
procedure bLimpiarClick(Sender: TObject);
procedure bMostrarClick(Sender: TObject);
procedure bSalirClick(Sender: TObject);
procedure opChange(Sender: TObject);
private
//Declaramos la instancia global (para que la usen todos los botones) y privada (atributo de la ventana).
vec:TBusquedas;
//Método para mostrar los elementos del vector en el TListBox (lisvec).
procedure mostrar;
public
{ public declarations }
end;

var
Form1: TForm1;

implementation

{ TForm1 }
//Implementación del evento OnShow para colocar el cursor en el TEdit de nombre val.
procedure TForm1.FormShow(Sender: TObject);
begin
val.SetFocus;
end;

//implementación del código para el evento del botón guardar.

procedure TForm1.bGuardarClick(Sender: TObject);
begin
vec.setVector(Up.Position, val.Text);
if Up.Position < num then
begin
 Up.Position:=Up.Position+1;
end;
mostrar;
val.Clear;
val.setFocus;
end;

//implementación del evento para el botón limpiar.

procedure TForm1.bLimpiarClick(Sender: TObject);
var
i:integer;
begin
lisvec.Clear;
for i:=1 to num do
begin
vec.setVector(i, '');
end;
Up.Position:=1;
val.Clear;
bus.Clear;
val.SetFocus;
end;

//implementación del evento para el botón mostrar.

procedure TForm1.bMostrarClick(Sender: TObject);
begin
mostrar;
end;

//implementación del evento para el botón salir.

procedure TForm1.bSalirClick(Sender: TObject);
begin
Close;
end;

//Método que permite seleccionar el método de búsqueda deseado (secuencial o binaria).

procedure TForm1.opChange(Sender: TObject);
var
dato:string;
pos:integer;
begin
if op.Text = 'Secuencial' then
begin
dato:=bus.Text;
pos:=vec.busquedaLineal(dato);
if pos <> -1 then
begin
ShowMessage('El No. celular '+dato+' se encuentra en la posiscion '+IntToStr(pos));
end
else
begin
ShowMessage('El No. celular '+dato+' No se encuentra en el vector');
end;
end
else
begin
dato:=bus.Text;
pos:=vec.bsuquedaBinaria(dato);
if pos <> -1 then
begin
ShowMessage('El No. celular '+dato+' se encuentra en la posiscion '+IntToStr(pos));
end
else
 begin
ShowMessage('El No. celular '+dato+' No se encuentra en el vector');
end;
end;
end;

//implementación del método para el evento constructor del formulario. Para implementar este código solo
//basta con seleccionar el formulario y escoger en el inspector de objetos, el evento OnCreate.
procedure TForm1.FormCreate(Sender: TObject);
begin
vec:=TBusquedas.create;
Up.Max:=num;
end;

//implementación del método que libera la instancia, para implementar este código solo basta con
//seleccionar el formulario y escoger en el inspector de objetos, el evento OnClose.
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
vec.Free;
end;

//implementación del método que muestra los elementos del vector en TListBox (lisvec).
procedure TForm1.mostrar;
var
i:integer;
begin
lisvec.Clear;
for i:=1 to num do
begin
lisvec.Items.Add('Posicion '+IntToStr(i)+'= '+ vec.getVector(i));
end;
end;

initialization
{$I uventanabusquedas.lrs}

end.