Programacion

MIGUEL ANGEL ALONSO LAZCANO
JUAN CARLOS OLGUIN ROJAS
SISTEMAS DIGITALES CON MICROPROCESADORES
EXAMEN FINAL

Crea un programa que encuentre la primera ocurrencia de un dato dentro de un
arreglo de
datos de tipo palabra utilizando el algoritmo de búsqueda binaria.
El programa estará formado por dos módulos:
El primer módulo llamado OBBPPAL.C es un módulo en C y contiene la función
main() y
lafunción que lee los datos y los almacena en el arreglo. El listado de ese módulo
es el
siguiente:

/***********************************************************
* OBBPPAL.C
* Este programa lee un conjunto de datos enteros y los
* almacena en un arreglo, los ordena y por ultimo permite
* la búsqueda de un dato dentro del arreglo utilizando el
* algoritmo de búsqueda binaria.***********************************************************/
#include
int leeDatos(int *pDatos);
void ordena(int *pDatos, int nDatos);
int bbinaria(int *pDatos, int nDatos, int llave);
int main(void)
{
int nDatos, llave, pos;
int datos[100];
nDatos = leeDatos(datos);
ordena(datos, nDatos);
printf("\nDato a buscar en el arreglo? ");
scanf("%d", &llave);
pos = bbinaria(datos, nDatos, llave);
if(pos != -1)printf("\nEl dato buscado esta en la posicion %d",pos);
else printf("\nEl dato no se encuentra en el arreglo");
return 0;
}

/***********************************************************
* int leeDatos(int *pDatos)
*
* Esta función lee una serie de enteros y los almacena en el
* arreglo dado por pDatos. La función regresa el numero de
* datos leídos.************************************************************
int leeDatos(int *pDatos)
{
int nDatos, i;
printf("\nNumero de datos: ");
scanf("%d", &nDatos);
for(i = 0; i < nDatos; i++)
{
printf("\nDato %d: ", i+1);
scanf("%d", pDatos+i);
}
return nDatos;
}
El segundo módulo, llamado ORD_BBIN, es en ensamblador y contiene las
definiciones de las funciones: ordena() y bbinaria(). La función ordena() cuya
sintaxis es:
void ordena(int *pDatos, int nDatos);ordena los nDatos elementos del arreglo dado por pDatos.
La función bbinaria() cuya sintaxis es:
int bbinaria(int *pDatos, int nDatos, int llave);
implementa el algoritmo de búsqueda binaria. La función recibe como
parámetros la dirección del arreglo pDatos, el número de datos en el arreglo
nDatos y el dato a buscar en llave. La función regresa la primera ocurrencia de
llave en el arreglo, -1(0FFFFh) en caso contrario.

Lo que implemente en esta segunda parte fue en ensamblador usando la sintaxis
de nasm (netwide asambler), que esencialmente utiliza la sintaxis de Intel 8086,
utilize dos modulos distintos (programas) para que hicieran las dos funciones que
faltantes ordenar, y buscar de forma binaria. Los dos programas pueden
compilarse de forma independiente (quedando en foma de objeto oprogr.o), y
despues enlazarse con el programa principal (obbppal.c) haciendo un makefile

Ordena.cpp

// .cpp (c++ reconoce la sintaxis de nasm y se permite utilizar
//codigo escrtito en c, c++ y nasm en un mismo ptograma)

.Model Small
.Code
//datos[100], ndato, utiliza dos parametros el arreglo a ordenar, y num de
//elmentos del arreglo (ndatos)
public _ordena
mov si,0
_ordena proc
Inicio( ):mov dx, datos[si]

//inicializa el indice sourse en 0

cmp si, nDatos
jmp Fin( )

//Se copia un elemento en dx (el elmento en la
//posic 0, dado si=0)
//Si se llega al final del arreglo
//termina

mov di,si

//Se actualiza el indice dos

Ordena( ):
mov cx, datos[di]
cmp di,nDatos
jmp Fin( )

//Copia otro elemento ahora en cx (elemt 0, dado
//di=si=0)
//Si llega al final del arreglo
//termina

cmpcx,dx,
jmp Cambia( )

//Si dx en menor que cx
//los cambia

cmp dx,cx,
jmp Cambia( )

//Si dx mayor que cx
//ordenar de la otra forma

add di,2
jmp Ordena( )

//indice dos se incrementa en uno
//sigue ordenado

add si,2
jmp Inicio( )

//El indice uno se incrementa en uno
//Empieza de nuevo

Cambia( ):
mov datos[si],cx
mov datos[di],dx

//Se ordenan los numeros
//al intercambiarse

mov dx,cx
jmp...

Leer documento completo

Regístrate para leer el documento completo.