UNIDAD Nº 1:

Vectores de
Registros
TEMAS:
Consultas por clave múltiple.
Menú de opciones.
Función random()
Clase
3
Consultas por clave múltiple
Concepto de consultas por clave múltiple
En la clase número 2, se explicó como se realiza una Consulta por
Legajo, en ese caso, las consultas se denominan por Clave Única, que
significa que solamente existe una componente que contiene el valor buscado
en todo el vector. Ejemplos de Clave Única son: Legajos de Personas,
Códigos de Artículos, Números de Orden de productos, Documento de
identidad, etc. Es decir, son datos que no se repiten en el vector.

En las consultas por Clave Múltiples, el dato a buscar puede estar

incluido en varios componentes del vector, es decir, que puede repetirse en
distintos registros. Las consultas por Clave Múltiple son llamados también:
Listados por Condición, porque el algoritmo utilizado es similar al listado en
el cual se agrega una condición que es la que decidirá si se deben mostrar los
datos o no. Ejemplos de Clave Múltiple son: Rubro de Artículos, Profesión de
Personas, Materia de Alumnos, Editorial de Libros, etc.

Generalmente, en una Consulta por clave única, se imprimen los

datos del registro buscado, uno por cada renglón, ya que es un único registro
encontrado, mientras que en una Consulta por clave múltiple, se imprimen
todos los datos de un registro por renglón, de la misma forma que en un
listado.

Ejemplos:

Consultas por Legajo Consultas por Rubro

Ingrese Legajo: 472 Ingrese Rubro: Bebidas

Nombre: Martinez Alberto Código Nombre Precio

Profesión: Empleado 174 Fanta 3.60
Sueldo: $ 5472 532 Pepsi 3.80
721 Coca Cola 4.90
438 Vodka 29.60
Otra Consulta (s/n):

Observar que en las Consultas por Legajo (Clave única) la impresión se

realiza a modo de un Dato por renglón, mientras que en las Consultas por
Rubro (Clave múltiple), la impresión se realiza a modo de un Registro por
renglón.

I.S.S.D. – Algoritmos y Estructuras de Datos II -1-

Ejemplo Nº: 6: Un comercio mantiene los datos de sus productos
almacenados en un vector, en el cual cada componente tiene la siguiente
estructura:

Struct TProducto
{
int Numero;
char Nombre[20];
char Rubro[20];
float Precio;
};

Desarrollar las siguientes operatorias:

a) Carga y Listado de 5 Productos.

b) Consulta por Número.
c) Consulta por Nombre. (Como clave única)
d) Consulta por Rubro. (Como clave múltiple)
e) Cantidad de productos que se encuentran por debajo del precio
promedio.
f) Desarrollar un Menú de opciones.

#include<conio.h>
#include<iostream.h>
#include<stdio.h>
#include<string.h>

struct TProducto
{
int Numero;
char Nombre[20];
char Rubro[20];
float Precio;
};

void CargarVector(TProducto V[100], int n)

{
for(int i=0; i<n; i++)
{
clrscr();
cprintf("Ingrese Numero: "); cin>>V[i].Numero;
cprintf("Ingrese Nombre: "); gets(V[i].Nombre);
cprintf("Ingrese Rubro : "); gets(V[i].Rubro);
cprintf("Ingrese Precio: "); cin>>V[i].Precio;
}
}

void Listado(TProducto V[100], int n)

{
clrscr();

// Titulos
gotoxy(25,1);cprintf("Listado Completo");
gotoxy(25,2);cprintf("------- --------");
gotoxy( 5,3);cprintf("Numero");
gotoxy( 5,4);cprintf("------");
-2- I.S.S.D. – Algoritmos y Estructuras de Datos II
 gotoxy(20,3);cprintf("Nombre");
gotoxy(20,4);cprintf("------");
gotoxy(38,3);cprintf("Rubro");
gotoxy(38,4);cprintf("-----");
gotoxy(55,3);cprintf("Precio");
gotoxy(55,4);cprintf("------");

// Impresion de datos

int L = 5;
for(int i=0; i<n; i++)
{
gotoxy( 5,L);cprintf("%i",V[i].Numero);
gotoxy(20,L);cprintf("%s",V[i].Nombre);
gotoxy(38,L);cprintf("%s",V[i].Rubro);
gotoxy(55,L);cprintf("%7.2f",V[i].Precio);
L++;
}
getch();
}

void ConsultasPorNumero(TProducto V[100], int n)

{
int Nx, b;
char op;
do
{
b=0;
clrscr();
gotoxy(20,2); cprintf("Consultas Por Numero
de Producto");
gotoxy(20,3); cprintf("--------- --- ------ -
- --------");
gotoxy(10,5);
cprintf("Ingrese el Numero a buscar: "); cin>>Nx;
for (int i=0; i<n; i++)
{
if(Nx==V[i].Numero)
{
gotoxy(10,7); cprintf("Nombre: %s",V[i].Nombre);
gotoxy(10,9); cprintf("Rubro : %s",V[i].Rubro);
gotoxy(10,11); cprintf("Precio: %0.2f",V[i].Precio);
b=1;
}
}
if (b==0)
{
gotoxy(10,7); cprintf("No existe ese Numero de Producto");
}
gotoxy(10,20); cprintf("Otra Consulta (s/n): ");
cin>>op;
}
while(op=='s'||op=='S');
}

void ConsultasPorNombre(TProducto V[100], int n)

{
int b;
char Nx[20];
char op;

I.S.S.D. – Algoritmos y Estructuras de Datos II -3-

 do
{
b=0;
clrscr();
gotoxy(20,2); cprintf("Consultas Por Nombre");
gotoxy(20,3); cprintf("--------- --- ------");
gotoxy(10,5);
cprintf("Ingrese el Nombre a buscar: ");gets(Nx);
for (int i=0; i<n; i++)
{
if(strcmpi(Nx,V[i].Nombre)==0)
{
gotoxy(10,7);
cprintf("Numero: %i",V[i].Numero);
gotoxy(10,9);
cprintf("Rubro: %s",V[i].Rubro);
gotoxy(10,11);
cprintf("Precio: %0.2f",V[i].Precio);
b=1;
}
}
if (b==0)
{
gotoxy(10,7);
cprintf("No existe ese Nombre de Producto");
}
gotoxy(10,20);cprintf("Otra Consulta (s/n): ");
cin>>op;
}
while(op=='s'||op=='S');
}

void ConsultasPorRubro(TProducto V[100], int n)

{
int b;
char Rx[20];
char op;
b=0;
clrscr();
gotoxy(20,1); cprintf("Consultas Por Rubro");
gotoxy(20,2); cprintf("--------- --- -----");
gotoxy(10,3);
cprintf("Ingrese el Rubro a buscar: ");gets(Rx);

// Titulos
gotoxy( 5,4);cprintf("Numero");
gotoxy( 5,5);cprintf("------");
gotoxy(20,4);cprintf("Nombre");
gotoxy(20,5);cprintf("------");
gotoxy(40,4);cprintf("Precio");
gotoxy(40,5);cprintf("------");

// Impresion de datos
int L = 6;

for (int i=0; i<n; i++)

{
if(strcmpi(Rx,V[i].Rubro)==0)
{
gotoxy(5,L); cprintf("%i",V[i].Numero);

-4- I.S.S.D. – Algoritmos y Estructuras de Datos II

 gotoxy(20,L); cprintf("%s",V[i].Nombre);
gotoxy(40,L); cprintf("%0.2f",V[i].Precio);
L++;
b=1;
}
}
if (b==0)
{
gotoxy(10,7); cprintf("No existe ese Rubro");
}
getch();
}

void Cantidad(TProducto V[100], int n)

{
float Suma = 0;
float Promedio;
int C = 0;
int i;
for(i=0; i<n; i++)
{
Suma = Suma + V[i].Precio;
}
Promedio = Suma/n;
for(i=0; i<n; i++)
{
if(V[i].Precio<Promedio) C++;
}

cprintf("\n\n\r");
cprintf("La cantidad de productos por debajo
del promedio es: %i",C);
getch();
}

void main()
{
TProducto V[100];
int n=5;
int op;
do
{
clrscr();
gotoxy(25,2);cprintf("Menu Principal");
gotoxy(25,3);cprintf("---- ---------");
gotoxy(10,5);cprintf("1-Carga de Productos");
gotoxy(10,6);cprintf("2-Listado de Productos");
gotoxy(10,7);cprintf("3-Consultas por Numero");
gotoxy(10,8);cprintf("4-Consultas por Nombre");
gotoxy(10,9);cprintf("5-Consultas por Rubro");
gotoxy(10,10);cprintf("6-Cantidad por debajo del
Promedio");
gotoxy(10,11);cprintf("7-Salir del Programa");
gotoxy(10,15);cprintf("Digite la opcion: "); cin>>op;
switch(op)
{
case 1: CargarVector(V,n); break;
case 2: Listado(V,n); break;
case 3: ConsultasPorNumero(V,n); break;
case 4: ConsultasPorNombre(V,n); break;

I.S.S.D. – Algoritmos y Estructuras de Datos II -5-

 case 5: ConsultasPorRubro(V,n); break;
case 6: Cantidad(V,n); break;
}
}
while (op !=7);
}

En la consulta por nombre, se utilizó la función strcmpi para

comparar dos cadenas de caracteres: Nx con V[i].Nombre. Esta
función es similar a la strcmp, con la diferencia de que ignora mayúsculas de
minúsculas.

Observar que la consulta por Nombre es distinta a la consulta por

Rubro, ya que en la primera se utilizó el concepto de clave única y en la
segunda, el concepto de clave múltiple.

Función Random()

Esta función tiene por objeto generar un número aleatorio entero de acuerdo a
un valor pasado como parámetro. El formato es el siguiente:

int n = random(valor);

El número que devuelve esta comprendido entre cero y el valor menos 1. Por
ejemplo, si valor = 100, generará números entre cero y 99.

Ejemplo Nº: 7: Definir un vector de “n” componentes de un tipo registro con

dos campos de enteros (coordenadas x e y). Realizar la carga de las
componentes en forma aleatoria (de acuerdo con el tamaño de la pantalla). Se
deberá imprimir los valores de las coordenadas generadas y colocar un
asterisco en la pantalla de acuerdo con cada coordenada del vector.
#include <stdlib.h>
#include <stdio.h>
#include <iostream.h>
#include <conio.h>

struct TPunto
{
int x,y;
};

void Cargar(TPunto V[100], int n)

{
for (int i=0; i<n; i++)
{
V[i].x = random(78)+1;
V[i].y = random(22)+1;
}
}

void Imprimir(TPunto V[100], int n)

{
for(int i=0; i<n; i++)
{
cprintf("(%2i,%2i)", V[i].x, V[i].y);

-6- I.S.S.D. – Algoritmos y Estructuras de Datos II

 cprintf("\n\r");
}
}

void Graficar(TPunto V[100], int n)

{
for(int i=0; i<n; i++)
{
gotoxy(V[i].x,V[i].y);
cprintf("%s","*");
}
}

void main()
{
textcolor(14);
clrscr();
randomize();
TPunto Vector[100];
int n;
cprintf("Ingrese la cantidad de puntos a mostrar:
");
cin>>n;
Cargar(Vector, n);
gotoxy(1,10); cprintf(" x , y\n\r");
Imprimir(Vector, n);
getchar();
Graficar(Vector, n);
getchar();
}

I.S.S.D. – Algoritmos y Estructuras de Datos II -7-

Ejercicios Propuestos

1.- Se tiene la siguiente declaración de datos:

Struct TEmpleado
{
int Legajo;
char Nombre[20];
char Profesion[20];
float Sueldo;
};

Realizar las siguientes operatorias:

a) Cargar 10 componentes de TEmpleado.

b) Mostrar un Listado en 4 columnas, indicando además el sueldo total.
c) Mostrar los datos del empleado de menor sueldo e incrementarlo en
un 10%.
d) Desarrollar una Consulta por Profesión.
e) Ingresar un número de legajo y decrementarle el sueldo en un 15%.
f) Realizar un Menú de opciones.

2.- Simular el sorteo de 2 quinielas en el día, creando un vector de 20

componentes con la siguiente estructura:

Struct TSorteo
{
int quiniela1;
int quiniela2;
};

Generar valores aleatorios de dos cifras (del cero al 99) en las dos quinielas y
desarrollar los siguientes puntos:

a) Mostrar los números salidos de las dos quinielas en tres columnas, en

la primera mostrar el número de orden (del 1 hasta el 20) y en las
otras dos los números salidos.
b) Indicar si salieron los números: 5 – 28 – 34 – 45 y 76, en caso de ser
verdadero, indicar en que quiniela y en que posición.
c) Indicar cuales fueron los menores números en las dos quinielas.

-8- I.S.S.D. – Algoritmos y Estructuras de Datos II