Arreglos en Paralelo v.2012 PDF

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.
PROCESAMIENTO DE DATOS
(PD)
Uso de Arreglos en Paralelo

Temas:

Introduccin.

Estructura de datos arreglos

Conceptos bsicos
Arreglos unidimensionales vectores
Arreglos bidimensionales matrices
Arreglos en paralelo
Arreglos de gran tamao.

Manejo de Datos en Arreglos (Sin Modificar tamao de Arreglo)

Ingreso de Datos: Utilizando Estructura de Repeticin for
Visualizacin de Datos.

Bsqueda de Datos

Bsqueda Secuencial o Lineal
Bsqueda Binaria.
Captulo

2


Clasificacin de Datos

Ordenamiento de Datos por Seleccin
Ordenamiento de Datos por Insercin
Ordenamiento de Datos por Intercambio o Burbuja
Ordenamiento Rpido de Datos Quicksort.

Modificacin de Datos

Eliminacin de Datos

Eliminacin Lgica
Eliminacin Fsica.

Manejo de Datos en Arreglos (Modificando tamao de Arreglo)

Ingreso de Datos: Utilizando Estructura de Repeticin
Aumento del Tamao del Arreglo
Insercin de Datos
Reduccin del Tamao del Arreglo
Visualizacin de Datos.

Problemas propuestos
Se presentan 10 problemas propuestos para que usted pueda resolverlos, los
cuales permitirn que analice mejor cada uno de los temas tratados en el
presente captulo.


Proyectos sugeridos
Se sugiere el desarrollo de 15 problemas propuestos planteados como proyectos
finales para que pueda aplicar todos los conceptos tratados.

Intntalo
Finalmente, se propone un problema para que intente desarrollarlo en base a las
soluciones implementadas en el presente captulo.


Pg. 92

CAPTULO II

ESTRUCTURA DE DATOS ARREGLOS

INTRODUCCIN

Un algoritmo constituye una lista completa de pasos secuenciales y una descripcin de datos
necesarios para resolver un determinado problema. Dichos datos deben almacenarse en una
estructura de datos.

Los arreglos permiten almacenar varios valores a la vez y constituyen las estructuras de datos
ms sencillas despus de la variable. Cuando se utilizan mltiples arreglos en las soluciones
podemos manejar los datos almacenados utilizando un algoritmo de bsqueda, clasificacin,
modificacin y eliminacin de datos con la finalidad de mantener actualizados los datos.

Definicin
Solucin
Etapa 02
Diseo
Solucin
Desarrollo
Solucin
Etapa 04
ENUNCIADO
DEL
PROBLEMA
MARCO DE TRABAJO

Pg. 93

En este captulo se presenta un resumen sobre los conceptos ms importantes relacionados
con las estructuras de datos conocidas como arreglos y se trata en detalle los algoritmos que
permiten manejar los datos almacenados en arreglos en paralelo. Se estudian detalladamente
el algoritmo de bsqueda secuencial y de bsqueda binaria, el ordenamiento por seleccin,
insercin e intercambio, as como la modificacin y eliminacin de datos lgica y fsica.

DECLARACIN Y
DEFINICIN DE
DATOS
LISTA DE PASOS
DESCRIPCIN
DE DATOS
SENTENCIAS
ALMACENADOS EN:
Estructuras de datos tipo variables.
Estructuras de datos tipo arreglo.
SE DESARROLLAN UTILIZANDO:
Estructuras lgicas de secuencia.
Estructuras lgicas de decisin.
Estructuras lgicas de repeticin.
Instrucciones de bifucacin.

TAMBIN:
Clases incorporadas en el lenguaje
de programacin utilizado.
MANEJO DE DATOS:
Bsquedas y Ordenamientos.
Modificacin y Eliminacin.

Pg. 94

ESTRUCTURA DE DATOS - ARREGLOS

CONCEPTOS BSICOS

Definicin:

Los arreglos conocidos tambin como arrays, son estructuras de datos que permiten
almacenar ms de un dato del mismo tipo a la vez. Es decir, un arreglo contiene un conjunto
de datos, todos del mismo tipo. Un arreglo puede almacenar un conjunto limitado de datos.
Cada dato perteneciente al arreglo se almacena en una posicin y puede ser mostrado,
modificado o eliminado.

Ventajas:

Los datos estn almacenados en una sola estructura de datos siendo ms fcil el
acceso a los mismos.

Se utiliza un nico nombre (nombre del arreglo) para referirse al conjunto de datos
almacenados en el arreglo. Esto nos permite reducir el uso de variables y constantes.

Los arreglos permiten almacenar datos de entrada y datos utilizados durante el
procesamiento.

Al igual que otras estructuras de datos (como las variables y constantes), los arreglos
tienen un tiempo de vida, por lo que pueden ser considerados como globales o
locales.

Desventajas:

Un arreglo no puede almacenar datos de diferente tipo. Se puede tener un arreglo de
nmeros enteros, o un arreglo de cadenas, pero no se puede tener un arreglo que
contenga, por ejemplo, cadenas y nmeros enteros a la vez.

Dependiendo del tipo de arreglo, unidimensional o bidimensional, se necesitar uno o
dos ndices para acceder a los datos almacenados en el arreglo.

Antes de crear un arreglo es necesario conocer el nmero exacto de datos que se
necesitan almacenar (esto no es tan cierto ya que se pueden crear algoritmos que
permiten redimensionar los arreglos. Tambin, existe una clase en Java, denominada
Vector, que pertenece al paquete java.util, que tiene mtodos que permiten crear un
vector y redefinir su tamao cada vez que sea necesario).

Pg. 95

i
ARREGLOS UNIDIMENSIONALES - VECTORES

Definicin:

Los arreglos unidimensionales conocidos tambin como vectores o registros, son
estructuras de datos que permiten almacenar ms de un dato del mismo tipo a la vez. Es
decir, un vector contiene un conjunto de datos, todos del mismo tipo, a los cuales se puede
acceder a travs de un ndice.

Representacin grfica:

A continuacin se muestra la representacin grfica de un arreglo unidimensional llamado
nombre:

nombre

Declaracin:

Para declarar un arreglo unidimensional es necesario, en primer lugar, definir un nombre.
Para definir un nombre de un arreglo unidimensional se siguen las mismas reglas utilizadas
para la definicin de nombres de variables y constantes.

En segundo lugar, se debe determinar qu tipo de dato podr almacenar el arreglo
unidimensional. Un arreglo unidimensional slo puede almacenar datos del mismo tipo. Los
tipos de datos vlidos para declarar un arreglo unidimensional son los mismos tipos de datos
vlidos definidos para declarar variables y constantes.

En general, para declarar un arreglo unidimensional se utiliza el siguiente formato:

En Java:
TipoDeDato arreglo[ ] ;

En Pseudocdigo y Diagrama de Flujo:

TipoDeDato[ ] arreglo;
X 0 X 1 X 2 ... X I-1

0 1 2 ... i -1
Donde:

nombre = Nombre del vector.
X0...X i -1 = Datos almacenados en el vector.
i = Tamao del vector.


Pg. 96

Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato vlido y arreglo es el
nombre del arreglo unidimensional (puede existir ms de un arreglo, los cuales sern
separados por comas).

Para declarar un arreglo unidimensional se utiliza slo un corchete de apertura y cierre [ ] al
final del nombre del arreglo.

Tambin se puede declarar un arreglo unidimensional colocando los corchetes de apertura y
cierre despus del tipo de dato y no despus del nombre del arreglo unidimensional, segn se
muestra a continuacin:

En Java:
TipoDeDato[ ] arreglo ;

En Pseudocodigo y Diagrama de Flujo:
TipoDeDato[ ] arreglo;

Creacin:

Para crear un arreglo unidimensional, es necesario que el arreglo unidimensional
previamente haya sido declarado, tal y como se explic anteriormente.

Antes de crear un arreglo unidimensional se debe determinar cul va ser el tamao del
mismo. Es decir, cul va a ser la cantidad total de datos que se podr almacenar.

Para crear un arreglo unidimensional se utiliza el siguiente formato:

En Java:
arreglo = new TipoDeDato [tamao] ;

En Pseudocodigo y Diagrama de Flujo:

CREAR arreglo[tamao]

Donde TipoDeDato debe ser un tipo de arreglo unidimensional o tipo de dato vlido y
arreglo es el nombre del arreglo.

El operador new nos permite crear un arreglo unidimensional. Cuando se crea un arreglo
unidimensional con el operador new, se debe indicar el tamao, es decir cuntos datos podr
almacenar.

Es importante mencionar que el tipo de dato utilizado para crear un arreglo unidimensional
deber ser el mismo tipo de dato con el cual se declar y que para crearlo es necesario
especificar un ndice.


Pg. 97

En Java, existe tambin una forma directa para declarar y crear arreglos
unidimensionales, utilizando el siguiente formato:

En Java:
TipoDeDato arreglo[ ] = new TipoDeDato [tamao];

Donde TipoDeDato debe ser un tipo de arreglo unidimensional o tipo de dato vlido y
arreglo es el nombre del arreglo unidimensional.

Utilizando este formato se declara y crea el arreglo unidimensional en forma directa (esto es
conocido como Definicin de un arreglo).

Inicializacin:

Cuando se crea un arreglo unidimensional utilizando el operador new es recomendable,
aunque no necesario, inicializar todas las posiciones del mismo. Inicializar todas las
posiciones de un arreglo unidimensional significa asignar un valor a cada posicin con la
finalidad de evitar que se produzca un error, si se intenta acceder a una posicin del arreglo
unidimensional que todava no contiene un dato.

Generalmente, los arreglos numricos (tipo NUMERO) se inicializan con cero (0), los arreglos
lgicos (tipo LOGICO) o booleanos se inicializan con false, los arreglos de caracteres con 0 y
los arreglos de objetos con null.

Ingreso de datos:

Despus de crear un arreglo unidimensional, inicialice o no el arreglo unidimensional, se
debern ingresar datos.

Es necesario que se ingresen datos a todas las posiciones del arreglo unidimensional. Si no
se ingresan datos a todas las posiciones del arreglo unidimensional deber asegurarse de
inicializarlo o en su defecto de mantener un adecuado control de las posiciones que tienen
datos almacenados y aquellas que no. Recuerde que tratar de acceder a una posicin que no
tiene un dato o que no ha sido inicializada, produce un error que ocasiona que se interrumpa
la ejecucin del programa.


Pg. 98

ARREGLOS BIDIMENSIONALES - MATRICES

Definicin:

Los arreglos bidimensionales conocidos tambin como matrices o tablas, son estructuras
de datos que permiten almacenar ms de un dato del mismo tipo a la vez. Es decir, una
matriz contiene un conjunto de datos, todos del mismo tipo, a los cuales se puede acceder a
travs de dos ndices.

Representacin grfica:

A continuacin se muestra la representacin grfica de un arreglo bidimensional llamado
nombre:

Es importante indicar que para declarar, crear, inicializar e ingresar datos en un arreglo
bidimensional o matriz se siguen las mismas reglas definidas para los arreglos
unidimensionales o vectores. La diferencia radica en el nmero de ndices que se utilizarn.

nombre
Columnas

Filas

0 1 2 j-1

0
X 0,0 X 0,1 X 0,2

X 0,j -1

1
X 1,0

2
X 2,0

i-1
X i-1,0 X i-1,j -1
(i, j)
Donde:

nombre = Nombre de la matriz.
X0,0...Xi-1, j -1 = Datos almacenados en la matriz.
i * j = Tamao de la matriz.


Pg. 99

ARREGLOS EN PARALELO

Introduccin:

Cuando se plantean soluciones a diversos problemas es necesario utilizar variables, vectores
y matrices en forma simultnea para almacenar los datos. Es decir, en una solucin se puede
utilizar algunas variables, un vector, dos vectores o muchos vectores. Tambin, se puede
utilizar variables, un vector y una matriz, o dos vectores y una matriz. En trminos generales
se puede afirmar que en una solucin se utilizan variables, vectores y matrices en forma
simultnea y en el nmero que se necesiten. Esto va a depender de la complejidad y tipo de
problema que se necesite resolver.

Cuando en una solucin se utiliza ms de un arreglo y el orden en que se disponen los datos
entre los arreglos tiene un significado, se les denomina vectores paralelos.

Ejemplos:

En la siguiente Grfica de Estructura de Datos se utiliza una variable y dos vectores en forma
simultnea (en paralelo). En la variable (numTrab) se almacena el nmero de trabajadores y
con este valor se crean los dos vectores (los arreglos en paralelo deben tener el mismo
tamao). En uno de los vectores (nombre[ ]) se almacenan los nombres de todos los
trabajadores y en el otro vector (sueldo[ ]) se almacenan sus respectivos sueldos. Se puede
observar que un dato almacenado en una posicin de un vector est relacionado con el dato
almacenado en la misma posicin del otro vector.

Dados los vectores:
nombre sueldo

0
Danae 1000
1
2
3
. .
: :
numTrab - 1
numTrab
(String) (double) ( int )

Donde numTrab permite almacenar el nmero de trabajadores.

La pregunta lgica que se pueden formular sera la siguiente: por qu en vez de crear dos
vectores en paralelo no creamos una matriz con dos columnas?, y la respuesta sera que en
una matriz solo se pueden almacenar datos del mismo tipo, mientras que usando dos
vectores en paralelo se pueden almacenar datos de diferente tipo. En el planteamiento de la
solucin anterior en uno de los vectores se almacenan datos de tipo TEXTO mientras que en
el otro vector se almacenan datos de tipo NUMERO.
Datos del mismo
trabajador.

Pg. 100

En la siguiente Grfica de Estructura de Datos se utiliza una variable y tres vectores en forma
simultnea (en paralelo). En la variable (numSoc) se almacena el nmero de socios de un
club y con este valor se crean los tres vectores. En uno de los vectores (nombre[ ]) se
almacenan los nombres de los socios, en otro de los vectores (sexo[ ]) se almacena el sexo
de cada uno de los socios y en el tercer vector (edad[ ]) sus respectivas edades. Como
ejemplo, se puede observar, que todos los datos del socio Rodrigo estn almacenados en la
posicin cero de los vectores en paralelo.

Dados los vectores:
nombre sexo edad

0
Rodrigo M 12
1
2
3
. . .
: : :
numSoc - 1
numSoc
(String) (char) ( int )

Donde numSoc permite almacenar el nmero de socios.

Finalmente, en la siguiente Grfica de Estructura de Datos se utiliza una variable, un vector y
una matriz con dos columnas en forma simultnea (en paralelo).

Dados los vectores:
nombre precio

PC (0) PV (1)

0
1
2
3
. . .
: : :
numArt - 1
numArt

Donde: numArt permite almacenar el nmero de Artculos.
PC = Precio de compra.
PV = Precio de venta.

Datos del mismo
socio.

Pg. 101

ARREGLOS DE GRAN TAMAO

Un arreglo de gran tamao es aquel que se crea con una capacidad mayor a la cantidad de
datos que va a almacenar. Los arreglos de gran tamao se utilizan cuando no se puede
determinar desde un inicio cul debe ser el tamao con el que se debe crear un arreglo.
Observe la siguiente Grfica de Estructuras de Datos:

Dado el vector:

codigo
0
1
2
3
.
:
9999
numAlu = 0
(long) ( int )

Donde numAlu indica el nmero de cdigos de alumnos almacenados.

En la grfica mostrada se especifica que el vector codigo[ ] se crear con un tamao de
1000. Tamao suficiente para poder almacenar todos los cdigos de los alumnos de un saln
de clase (se supone que en un saln de clase no habr tal cantidad de alumnos). Para
manejar los datos almacenados en un arreglo de gran tamao se necesita una variable que
indica el tamao lgico del arreglo. En este caso, la variable numTrab nos indicar el total de
cdigos de alumnos que se han almacenado en el vector en un determinado momento. Al
inicio, el valor de la variable numAlu deber ser cero (esto significa que cuando se inicia la
ejecucin de la aplicacin no se tiene almacenado ningn cdigo de alumno). Esto tambin
puede ser aplicado en arreglos en paralelo. Observe e interprete la siguiente Grfica de
Estructuras de Datos:

Dados los vectores:
nombre sueldo

0 Danae 1000
1
2
3
. .
: :
99999
numTrab = 0

Donde numTrab indica el nmero de trabajadores cuyos datos se han almacenado.


Pg. 102

Problema 014

Etapa 01 - Descripcin del problema.
Enunciado:
Desarrolla la codificacin en JAVA de una solucin que permita ingresar y almacenar el
nombre y las notas de los alumnos, calcular y mostrar el promedio de todos los alumnos.

La solucin deber ser desarrollada dentro del mtodo main.

Etapa 03 - Diseo de la lgica.

Defina el nombre del proyecto, desarrolle la definicin de paquetes, el diagrama de paquetes, la
definicin de las clases y el diagrama de secuencia.

5. Grfica de Estructura de Datos.

Dados los vectores:

codigo nombre notas
0
1
2
3
: : :
: : :
9999
numAlu = 0

(double) (String) (double) (int)

Donde numAlu permite almacenar el nmero de alumnos cuyos datos se han almacenado.

Disee el algoritmo de la solucin en Pseudocdigo.


Pg. 103

Etapa 04 Desarrollo de la codificacin.

Clase PrgPromedio

package dominioDeLaAplicacion;
import biblioteca.LE;
public class PrgPromedio {

public static void main(String[] args) {

int numAlum=LE.leerInt("Ingrese la cantidad de alumnos :");
double codigo[]=new double[numAlum];
double notas[]=new double[numAlum];
String nombre[]=new String[numAlum];

for(int r=0;r<numAlum;r++){
codigo[r]=LE.leerDouble("Ingrese Cdigo del "+(r+1)+" :");
nombre[r]=LE.leerString("Ingrese nombre del "+(r+1)+" :");
notas[r]=LE.leerDouble("Ingrese la nota del "+(r+1)+" :");
}

double prom=0;
for(int i=0;i<numAlum;i++){
prom+=notas[i];
}

LE.mostrarInformacion("El promedio de todos los alumnos es :
"+Math.round(((double)prom/numAlum)*100)/100.0);
}

}


Pg. 104

Problema 015

Enunciado:
Desarrolle la codificacin en JAVA de una solucin que permita ingresar y almacenar el
cdigo, nombre y sueldo de todos los empleados de la universidad, calcular el sueldo
promedio.





Dados los vectores:

codigo nombre sueldo
0
1
2
3
: : :
: : :
9999
numEmp = 0


Donde numEmp permite almacenar el nmero de alumnos cuyos datos se han almacenado.



Pg. 105


Clase PrgUniversidad

public class PrgUniversidad {


int numEmp=LE.leerInt("Ingrese la cantidad de Empleados :");

double codigo[]=new double[numEmp];
double sueldo[]=new double[numEmp];
String nombre[]=new String[numEmp];

for(int r=0;r<numEmp;r++){
codigo[r]=LE.leerDouble("Ingrese Cdigo del "+(r+1)+" :");
nombre[r]=LE.leerString("Ingrese nombre del "+(r+1)+" :");
sueldo[r]=LE.leerDouble("Ingrese el sueldo del "+(r+1)+" :");
}

double prom=0;
for(int i=0;i<numEmp;i++){
prom+=sueldo[i];
}

LE.mostrarInformacion("El promedio de sueldos de todos los empleados es :
"+Math.round(((double)prom/numEmp)*100)/100.0);
}

}


Pg. 106

Problema 016

Enunciado:
cdigo, nombre y las tres notas de todos los alumnos, calcular y mostrar el promedio de cada
alumno.





Dados los arreglos:

codigo nombre notas

N1 N2 N3

0
1
2
3
: : : :
:

: : :
9999
numAlu = 0

(Double) (lint) (double) (int)

Donde: N1 = Es la primera nota.
N2 = Es la segunda nota.
N3 = Es la tercera nota.



Pg. 107


Clase PrgPromedio2

public class PrgPromedio2 {


double notas[][]=new double[numAlum][3];

codigo[r]=LE.leerDouble("Ingrese Codigo del "+(r+1)+" alumno :");
nombre[r]=LE.leerString("Ingrese nombre del "+(r+1)+" alumno:");

for(int j=0;j<3;j++){
notas[r][j]=LE.leerDouble("Ingrese la "+(j+1)+" nota del "+(r+1)+
" alumno : ");
}

}

String promedios="El promedio de todos los alumnos es : \n";
double prom=0;

for(int j=0;j<3;j++){
prom+=notas[i][j];
}
promedios+=(i+1)+") "+nombre[i]+" -->
"+Math.round((prom/3)*100)/100.0+"\n";
}
LE.mostrarInformacion(promedios);
}

}

Se utiliza una estructura
de repeticin para el
ingreso de las notas
dado que es una matrz
que recibir 3 notas.

Pg. 108

Problema 017

Enunciado:
cdigo, nombre y todas las notas de los alumnos de un saln de clase, calcular y mostrar el
promedio de cada alumno y el promedio general del saln.





Dados los arreglos:

codigo nombre notas

0 1 2 numNotas - 1

0 :
1 :
2 :
3 :
: : : : :
:
:
:

: : : :
9999
numAlu = 0

(Double) (lint) ( (double) (int)

Donde:

Donde numNotas permite almacenar el nmero de notas de cada alumno.



Pg. 109


Clase PrgPromedioGeneral

public class PrgPromedioGeneral {


int numNotas=LE.leerInt("Ingrese el nmero de notas :");
double notas[][]=new double[numAlum][numNotas];

codigo[r]=LE.leerDouble("Ingrese Codigo del "+(r+1)+" alumno :");
nombre[r]=LE.leerString("Ingrese nombre del "+(r+1)+" alumno:");

for(int j=0;j<numNotas;j++){
notas[r][j]=LE.leerDouble("Ingrese la "+(j+1)+" nota del "+(r+1)+" alumno :
");
}

}

String promedios="El promedio de todos los alumnos es : \n";
double prom=0;
for(int j=0;j<numNotas;j++){
prom+=notas[i][j];
}
promedios+=(i+1)+") "+nombre[i]+" -->
"+Math.round((prom/3)*100)/100.0+"\n";
}
LE.mostrarInformacion(promedios);
}

}

Se utiliza una estructura de
repeticin para el ingreso de
las notas que ser
inicializado de acuerdo al
nmero de notas numNotas
que se ingresarn.

Pg. 110

PROCESAMIENTO DE DATOS UTILIZANDO ARREGLOS

MANEJO DE DATOS EN ARREGLOS (SIN MODIFICAR TAMAO DE ARREGLO)

Introduccin:

El proceso de manejo de datos en arreglos, implica desarrollar operaciones bsicas que son
fundamentales para toda etapa de solucin de un problema. Es por ello que seguidamente
explicaremos los principales procesos que implican el ingreso de datos, la insercin,
eliminacin, modificacin y su visualizacin.

INGRESO DE DATOS; utilizando Estructura de Repeticin FOR

Introduccin:

El ingreso de datos es esencial en todo proceso que implique el registro y manejo de los
datos, ya que mediante dicho proceso podemos realizar el ingreso de todos los datos para su
almacenamiento, ya sea en una estructura de datos interna como en una base de datos.

Definicin:

El ingreso de datos consiste en insertar un determinado elemento en una estructura de
datos especfica para que posteriormente dicho elemento pueda ser utilizado de acuerdo a los
requerimientos del usuario. El ingreso de datos es el primer paso para estructurar soluciones
que posteriormente permitan manejar dichos datos y mostrar informacin adecuada y
oportuna para la toma de decisiones.

Ejemplos:

Se desea almacenar el nmero telefnico de una determinada
persona. Para ello, se deber definir la estructura de datos
especfica para su almacenamiento y los mecanismos para su
ingreso y posterior almacenamiento.

Se tiene una lista de alumnos y sus calificaciones, para lo cual se
desea almacenarlos en una estructura de datos para que
posteriormente se puedan realizar clculos como obtener sus

Pg. 111

promedios. Para ello se deber definir la estructura de datos
especfica y posteriormente se debern registrar y almacenar los
datos a travs del proceso de ingreso de datos.

Un ejemplo prctico de ingreso de datos en una estructura de tipo arreglo, se realiza a travs
de la siguiente secuencia:

Primero se determina la cantidad de datos que se van a
registrar, esto es importante para crear el tamao del arreglo.

Despus podemos utilizar una estructura de repeticin para
realizar el ingreso de datos. Por ejemplo, podemos utilizar la
estructura de repeticin For e ingresar datos desde i = 0
mientras que i < numAlu. Entonces, cuando i = 0 se ingresar
un dato a la primera posicin del vector

notas

Entonces, sea el vector:
9 8 7 6 5 4 3 2 1 0
numAlu = 10.

notas

9 8 7 6 5 4 3 2 1 0
numAlu = 10.

12
12 15 14 17 19 08 13 16 17 13
notas

Cuando termina de realizar el primer ingreso, el i se incrementar en
uno y realizar nuevamente el ingreso de dato, y asi suscesivamente
hasta llegar a la ltima posicin del vector registrando todos los datos.
9 8 7 6 5 4 3 2 1 0
numAlu = 10.


Pg. 112

En el siguiente ejemplo veremos el ingreso de datos de la siguiente estructura:

Dados los vectores:

codigos nombres notas

0 10 JUAN 19

1 20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
9
numAlu = 10

(long) (String) (double) (int)

Donde numAlu permite almacenar el nmero de alumnos.

Tenemos que recordar que el arreglo tuvo que ser creado con un tamao del numAlu, que
segn la estructura es de 10 registros.

public void IngresarDatos () {

// Declaramos la estructura de repeticin para el ingreso de los 10 datos.
for ( int i = 0 ; i < numAlu ; i++ ){

// Ingreso del cdigo.
codigos[i]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );

// Ingreso del Nombre
nombres[i]=LE.leerString ( Ingrese el nombre del alumno: + (i+1) );

// Ingreso de las notas.
notas[i]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
}

}// Fin del mtodo IngresarDatos


Pg. 113

Tambin podemos implementar los mtodos que sirven para validar los datos de ingreso,
como se puede ver en la siguiente cuadro.

Existen tambin otras formas para realizar el ingreso de datos. Sin embargo la lgica que
se tiene que desarrollar resulta la misma, es por ello que el usuario puede escoger el tipo
de mtodo que utilizar tomando en cuenta sus principales requerimientos.



// Ingreso del cdigo con su respectiva validacin.
do{
if (codigos[i]<0 ){
LE.mostrarError ( Lo sentimos, el cdigo ingresado es incorrecto );
}
} while (codigos[i]<0 );
// Ingreso del Nombre con validacin.

do{
if (nombres[i].length( ) < 0 ){
LE.mostrarError ( Lo sentimos, el nombre ingresado es incorrecto );
}
} while (nombres[i].length( ) < 0 );

// Ingreso de las notas con validacin respectiva

do{
notas[i]=LE.leerLong ( Ingrese la nota del alumno: + (i+1) );
if (notas[i] < 0 || notas[i] > 20 ){
LE.mostrarError ( Lo sentimos, el nombre ingresado es incorrecto );
}
} while (notas[i] < 0 || notas[i] > 20 );


Pg. 114

VISUALIZACIN DE DATOS: Utilizando la Clase LE

Introduccin:

La visualizacin de datos consiste en mostrar los datos de tal forma que tengan un significado
adecuado para el usuario. Es decir, los datos mostrados adecuadamente se convierten en
informacin que puede ser utilizada por el usuario para la toma de decisiones y el control de
la organizacin de ser el caso. La visualizacin de datos tambin sirve para verificar que los
datos que se estn almacenando sean los correctos.

Definicin:

El proceso de visualizar datos o proceso de mostrar datos consiste en mostrar el resultado
de un conjunto de datos de tal forma que pueda tener un significado para el usuario y pueda
ser utilizado para la toma de decisiones, el control, u otras operaciones.

En el presente captulo se implementarn mtodos de visualizacin utilizando previamente
una variable de tipo String que almacenar los datos ingresados previamente.
Posteriormente, utilizaremos la clase LE para mostrar los datos contenidos en la variable
String utilizada.

Ejemplos:
Se desea visualizar las notas almacenadas en una estructura de
datos tipo vector. Para ello, declaramos como atributo una
variable que permita almacenar las notas almacenadas.

12 15 14 17 19 08 13 16 17 13
notas

Nuevamente utilizaremos una estructura de repeticin FOR para que
recorra todo el vector y permita almacenar los datos en una variable de
tipo String la cual ser mostrada posteriormente.
9 8 7 6 5 4 3 2 1 0
numAlu = 10.

lista = lista + notas[i]
i=0
i=1
i=2
Como se ve en el grfico, la variable lista declarada como atributo va
almacenando los datos de cada posicin del vector hasta llegar a la
ltima posicin. Finalmente, para mostrar dicha lista se utiliza la
siguiente sentencia:

LE.mostrarInformacion ( Los datos almacenados son: + lista );

Pg. 115

En el siguiente ejemplo podremos observar el desarrollo de lo mencionado:

Dados los vectores:


0 10 JUAN 19

1 20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
9
numAlu = 10



public void visualizarDatos ( ) {

//Declaramos la variable que almacenar los datos de los arreglos
String lista = ;

lista = Codigo \t Nombres \t Notas \t \n;

// Declaramos la estructura de repeticin para almacenar los datos

// La lista almacena los datos de cada arreglo.
lista = + codigos[j] +\t+nombres[i]+\t+notas[i]+\n;
}

//Finalmente visualizamos la lista
LE.mostrarInformacion (lista);

}// Fin del mtodo VisualizarDatos


Pg. 116


BSQUEDA DE DATOS

Introduccin:

La recuperacin de los datos y su posterior transformacin en informacin constituyen uno de
los procesos ms importantes y comunes que debemos realizar cuando se procesan o
manipulan datos.

Es comn que trabajemos con grandes cantidades de datos almacenados en las Estructuras
de Datos y que generalmente sea necesario determinar si un valor est almacenado. A este
proceso se denomina bsqueda y se realiza para recuperar una pequea cantidad de los
datos almacenados.

Definicin:

La bsqueda de datos consiste en ubicar un determinado elemento, su posicin o ambos,
entre un conjunto de elementos almacenados en una estructura de datos especfica. Se dice
que la bsqueda es exitosa cuando el elemento buscado es encontrado, caso contrario, la
bsqueda es no exitosa o fallida.

En este punto trataremos la bsqueda de datos en arreglos unidimensionales (vectores). Es
importante que comprenda adecuadamente este concepto para que pueda aplicarlo sobre los
arreglos bidimensionales (matrices) y en otros tipos de estructuras de datos.

Ejemplos:

En una gua telefnica se desea buscar el nmero telefnico de
una determinada persona. Entonces se buscar a la persona por
su apellido y nombre y si esta persona est registrada en la gua
podremos obtener el nmero telefnico.

En una lista de alumnos y sus calificaciones se desea buscar la
nota final de un determinado alumno. Entonces se buscar al
alumno por su apellido y nombre y si este alumno est en la lista
podremos obtener sus calificaciones.


Pg. 117

Tipos:

El proceso de bsqueda de datos se puede realizar utilizando principalmente los siguientes
mtodos:

Bsqueda secuencial o lineal.
Bsqueda binaria.

Existen tambin otros mtodos de bsqueda, entre los cuales podemos mencionar el mtodo de bsqueda por
transformacin de claves (Hashing).

Bsqueda por transformacin de claves (Hashing).

Es tambin conocido con el nombre de HASH o HASHING.
Este es uno de los mtodos de bsqueda ms eficiente y rpida, pero a la vez es el
ms complicado de desarrollar. Este mtodo no ser tratado en el presente texto, pero
se recomienda al lector su investigacin.


Pg. 118

Bsqueda Secuencial o Lineal

Este es el mtodo ms sencillo de bsqueda de datos y se basa en recorrer el arreglo en
forma secuencial desde el principio hasta el final.

Sea el vector notas que contiene las notas de 10 alumnos (numAlu = 10). Si se desea buscar
una nota determinada utilizando bsqueda de datos secuencial, se deber empezar buscando
la nota desde el principio del vector, es decir, desde la posicin 0. Si la nota buscada no est
en esta posicin se deber buscar en la siguiente posicin y as sucesivamente hasta
encontrar la nota buscada o hasta terminar de recorrer el vector notas en la posicin 9.

En la bsqueda secuencial o lineal, se compara cada elemento del arreglo con un
determinado valor, hasta encontrarlo o hasta llegar al final del arreglo.

Para la bsqueda secuencial no se necesita que los elementos del vector estn en un orden
especfico. La elaboracin de este algoritmo se realiza utilizando estructuras lgicas y es
bastante sencilla; sin embargo, si el vector a analizar es demasiado grande entonces la
bsqueda se vuelve bastante lenta. Este algoritmo de bsqueda de datos se utiliza
generalmente cuando se trabajan con vectores pequeos y sobre todo para fines
acadmicos.

Notas

Sea el vector:
9 8 7 6 5 4 3 2 1 0
numAlu = 10.
3 5 7 9 10 11 13 15 17 19

Pg. 119

Como ejemplo desarrollaremos el algoritmo expresado en pseudocdigo de una
solucin que permita almacenar la nota de los alumnos de un saln de clase y
buscar si una determinada nota est o no est almacenada.

Algoritmo PrgBuscarValorSec

ENTRADA: numAlu, notas[ ], valor
SALIDA: mensaje

INICIO

TEXTO mensaje
NUMERO notas[ ], numAlu, valor, i
LOGICO estado = FALSO
LEER numAlu
CREAR notas[numAlu]

COMENTARIO Ingresar datos al vector notas
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
LEER notas[i]
FINDESDE

COMENTARIO Ingreso del valor a buscar
LEER valor

COMENTARIO Bsqueda secuencial o lineal. Bsqueda de un valor en el
vector notas


SI ( notas[i] = valor )
ENTONCES
estado = VERDADERO
TERMINAR
FINSI
FINDESDE

SI ( estado )
ENTONCES
mensaje = Valor encontrado
SINO
mensaje = Valor no encontrado
FINSI
ESCRIBIR mensaje

FIN

Observe que es necesario ingresar y almacenar el dato que se va a buscar en una
variable (valor). Dicho dato se busca en el arreglo notas. Si es encontrado, la variable
estado cambia a VERDADERO y finaliza la ejecucin de la estructura de repeticin
DESDE. Al final se analiza el contenido de la variable estado que puede ser
VERDADERO (si el valor buscado fue encontrado) o FALSO (si el valor buscado no
fue encontrado).
Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.

Pg. 120

A continuacin se muestra el desarrollo de la codificacin en lenguaje de
programacin Java del algoritmo anterior.

PrgBuscarValorSec main ( )

package dominioDeLaAplicacion ;
import biblioteca.* ;

public class PrgBuscarValorSec {

public static void main ( String [ ] args ) {

int notas[ ], numAlu, valor, i ;
boolean estado = false ;
String mensaje ;

System.out.print ( "Ingrese el nmero de alumnos: " ) ;
numAlu = Lectura.leerInt ( ) ;
notas = new int[numAlu] ;

for ( i = 0; i < numAlu; i++) {
System.out.print ( "Ingrese la nota del alumno " + (i + 1) + ": " ) ;
notas[i] = Lectura.leerInt ( ) ;
}

System.out.println ( "Ingrese la nota a buscar: " ) ;
valor = Lectura.leerInt ( ) ;

for ( i = 0; i < numAlu; i++) {
if (notas[i] == valor) {
estado = true ;
break ;
}
}

if ( estado )
mensaje = "Valor encontrado" ;
else {
mensaje = "Valor no encontrado" ;
}

System.out.println ( mensaje ) ;

}

}


Pg. 121

Una variacin del ejemplo anterior nos permite buscar una nota y determinar la
posicin donde est almacenada dicha nota, si est es encontrada.

Algoritmo PrgBuscarPosicionSec

SALIDA: mensaje

INICIO

TEXTO mensaje
NUMERO notas[ ], numAlu, pos = -1, valor, i
LEER numAlu
CREAR notas[numAlu]

LEER notas[i]
FINDESDE

LEER valor

COMENTARIO Bsqueda Secuencial o Lineal. Bsqueda de la posicin de
un valor en el vector notas


ENTONCES
pos = i
TERMINAR
FINSI

FINDESDE

SI ( pos >= 0 )
ENTONCES
mensaje = Valor encontrado en la posicin + pos
SINO
FINSI
ESCRIBIR mensaje

FIN

La diferencia fundamental en este algoritmo es que si el valor de la variable pos es -1
significa que el valor buscado no fue encontrado. En otros casos, significa que fue
encontrado conteniendo la posicin del vector donde el dato fue encontrado.
(Observe, que si el valor se repite varias veces en el vector, slo se devolver la
posicin del primer valor encontrado).

Conjunto de
instrucciones que

Pg. 122

Observe que al final del algoritmo se muestra el contenido de la variable pos. Dicho
valor puede ser cero o mayor que cero, si el valor buscado fue encontrado
(conteniendo la posicin en la cual fue encontrado) o puede ser -1 si el valor buscado
no fue encontrado.


PrgBuscarPosicionSec main ( )


public class PrgBuscarPosicionSec {


int notas[ ], numAlu = 0, valor, pos = -1, i ;
String mensaje ;

System.out.print ( "Ingrese el nmero de alumnos: ") ;

for ( i = 0; i < numAlu; i++ ) {
System.out.print ( "Ingrese la nota del alumno " + (i + 1) + ": ") ;
}

System.out.println ( "Ingrese la nota a buscar: ") ;

for ( i = 0; i < numAlu; i++ ) {
if (notas[i] == valor) {
pos = i ;
break ;
}
}

if ( pos >= 0 )
mensaje = "Valor encontrado en la posicin " + pos ;
else {
mensaje = "Valor no encontrado " ;
}

System.out.println (mensaje) ;

}
}


Pg. 123

Otra variacin de este ejemplo nos permite buscar una nota y determinar el nmero
de veces que dicha nota es encontrada.

Algoritmo PrgBuscarCantidadSec

SALIDA: mensaje

INICIO

TEXTO mensaje
NUMERO notas[ ], numAlu, cantidad = 0, valor, i
LEER numAlu
CREAR notas[numAlu]

LEER notas[i]
FINDESDE

LEER valor

COMENTARIO Bsqueda secuencial o lineal. Bsqueda del nmero de
veces que se encuentra un valor en el vector notas


ENTONCES
cantidad = cantidad + 1
FINSI

FINDESDE

SI ( cantidad > 0 )
ENTONCES
mensaje = Valor encontrado + cantidad + veces.
SINO
FINSI
ESCRIBIR mensaje

FIN

La diferencia fundamental en este algoritmo es que si el valor de la variable cantidad
es cero significa que el valor buscado no fue encontrado. En otros casos, significa
que fue encontrado conteniendo el nmero de veces que dicho dato fue encontrado
en el vector.

Observe que al final del algoritmo se muestra el contenido de la variable cantidad.
Dicho valor puede ser mayor que cero si el valor buscado fue encontrado
(conteniendo el nmero de veces que fue encontrado) o puede ser cero si el valor
buscado no fue encontrado.
Conjunto de
instrucciones que

Pg. 124


PrgBuscarCantidadSec main ( )


public class PrgBuscarCantidadSec {


int notas[ ], numAlu = 0, valor, cantidad = 0, i ;
String mensaje ;


for ( i = 0; i < numAlu; i++ ) {
}


for ( i = 0; i < numAlu; i++ ) {
if ( notas[i] == valor ) {
cantidad ++ ;
}
}

if ( cantidad > 0 )
mensaje = "Valor encontrado " + cantidad + " veces" ;
else {
}


}

}


Pg. 125

Los algoritmos desarrollados anteriormente pueden ser modificados de tal forma
que puedan recibir el valor que se desea buscar y puedan devolver un valor
conteniendo el resultado de la bsqueda. Esto nos permite la reutilizacin de los
algoritmos en diferentes aplicaciones.

Analice detenidamente los siguientes algoritmos. Para su ejecucin se asume que el
arreglo notas existe, es accesible y contiene datos. Recuerde que el tamao del
arreglo se obtiene utilizando la regla LONGITUD.

El siguiente algoritmo permite recibir un valor, buscar dicho valor y devolver el
resultado de la bsqueda. Es decir, si el valor buscado fue encontrado o no.

Algoritmo Bsqueda Lineal Mtodo buscarValorSec

PARAMETRO: valor
RETORNO: estado

INICIO
NUMERO i
LOGICO estado = FALSO
DESDE i = 0 HASTA notas.LONGITUD - 1
ENTONCES
estado = VERDADERO
TERMINAR
FINSI
FINDESDE
RETORNAR estado
FIN

Observe que en este caso, el algoritmo de bsqueda secuencial o lineal llamado
Mtodo buscarValorSec recibe el dato que se va a buscar y lo almacena en la
variable valor. Dicho valor es buscado en el arreglo notas, si lo encuentra la variable
estado cambia a VERDADERO, es decir encontrado. Al final se retorna la variable
estado que contiene VERDADERO o FALSO si el valor buscado fue encontrado o
no.


Pg. 126


Algoritmo Bsqueda Lineal Mtodo buscarValorSec ( )

public boolean buscarValorSec ( int valor ) {
int i ;
boolean estado = false ;

for ( i = 0; i < notas.lenght; i++ ) {
estado = true ;
break ;
}
}
return estado ;
}

El siguiente algoritmo permite recibir un valor, buscar dicho valor y devolver la
posicin del mismo si ste es encontrado.

Algoritmo Bsqueda Lineal Mtodo buscarPosicionSec

PARAMETRO: valor
RETORNO: pos

INICIO
NUMERO i, pos = -1
ENTONCES
pos = i
TERMINAR
FINSI
FINDESDE
RETORNAR pos
FIN

Algoritmo de bsqueda secuencial o lineal llamado Mtodo buscarPosicionSec. La
diferencia fundamental en este algoritmo es que, si el valor de la variable pos es -1
significa que el valor buscado no fue encontrado. En otros casos, significa que fue
encontrado conteniendo la posicin del vector donde el dato fue encontrado.

Pg. 127


Bsqueda Lineal Mtodo buscarPosicionSec ( )

public int buscarPosicionSec ( int valor ) {
int i, pos = -1 ;

pos = i ;
break ;
}
}
return pos ;
}

El siguiente algoritmo permite recibir un valor, buscar dicho valor y devolver el
nmero de veces que se repite en el vector.

Algoritmo Bsqueda Lineal Mtodo buscarCantidadSec

PARAMETRO: valor
RETORNO: cantidad

INICIO
NUMERO i, cantidad = 0
ENTONCES
cantidad = cantidad + 1
FINSI
FINDESDE
RETORNAR cantidad
FIN

Algoritmo de bsqueda secuencial o lineal llamado Mtodo buscarCantidadSec. La
diferencia fundamental en este algoritmo es que si el valor de la variable cantidad es
0 significa que el valor buscado no fue encontrado. En otros casos, significa que fue
encontrado, conteniendo el nmero de veces que dicho dato fue encontrado en el
vector.

Pg. 128


Bsqueda Lineal Mtodo buscarCantidadSec ( )

public int buscarCantidadSec ( int valor ) {
int i, cantidad = 0 ;

cantidad ++ ;
}
}
return cantidad ;
}


Pg. 129

Bsqueda Binaria

La Bsqueda Binaria se basa en la frase Divide y Vencers para buscar un determinado
valor en un vector. Este vector deber estar ordenado alfabticamente o numricamente
dependiendo del tipo de dato que contiene.

La Bsqueda Binaria comienza comparando el elemento central del arreglo de datos (vector)
con el valor buscado. Esto permite tener dos sublistas, una lista inferior (o lista izquierda) y
otra lista superior (o lista derecha). Si el elemento central coincide con el valor buscado
entonces la bsqueda termina. En caso contrario, se determina si el valor buscado puede
pertenecer a la lista inferior (lista izquierda) o a la lista superior (lista derecha) y se repite el
proceso utilizando el elemento central de la sublista seleccionada. La bsqueda contina
hasta que el valor buscado sea encontrado o hasta que la sublista consista en un solo
elemento que no sea igual al valor buscado.

La siguiente tabla compara la eficiencia de la bsqueda lineal y binaria para diferentes valores
de n (tamao del arreglo). La ventaja del mtodo de bsqueda binaria aumenta a medida
que el tamao del arreglo es mayor. Esto representa una impresionante mejora en el
rendimiento respecto al mtodo de bsqueda lineal.

Nmero mximo de comparaciones
Tamao del arreglo Bsqueda Lineal Bsqueda Binaria
10 10 4
100 100 7
1000 1000 10
10000 10000 14
1000000 1000000 20

El nmero mximo de comparaciones requeridas para una bsqueda binaria de cualquier
arreglo es el exponente de la primera potencia de 2 mayor que el nmero de elementos del
arreglo.


Pg. 130

Suponga que tenemos el siguiente arreglo de notas con numAlu = 10 (donde numAlu es el
nmero de elementos del arreglo notas):

Podemos afirmar que el nmero mximo de comparaciones
para este ejemplo ser de 2
x
>= 9, donde x = 4.

Supongamos que le solicitan buscar un valor (nota=15) utilizando el mtodo de bsqueda
binaria. Este mtodo se inicia determinando los lmites del arreglo y el punto central de la
siguiente forma:

bajo = 0.
alto = numAlu - 1 = 9.
central = ( bajo + alto ) / 2 = 4.

Entonces se determina que el nmero central es el 10 y que este nmero es menor que la
nota buscada (nota=15) por lo que la nota puede estar en la sublista superior (sublista
derecha).

Ahora se trabaja con la sublista superior (sublista derecha) y se determina nuevamente sus
lmites y el nuevo punto central:

bajo = central + 1 = 5.
alto = numAlu - 1 = 9.
central = ( bajo + alto ) / 2 = 7.

Y se determina que la nota central es ahora 15 y que es igual al valor buscado (nota=15) por
lo que se finaliza el mtodo y se da como resultado que la bsqueda ha sido exitosa y que el
nmero buscado fue encontrado en la posicin 7 del arreglo notas. En caso de no ser igual se
contina con el mtodo hasta que se encuentre el valor o se tenga una sublista con un solo
elemento y el valor de este elemento sea diferente al valor buscado.

Sea el vector:
9 8 7 6 5 4 3 2 1 0
notas
numAlu = 10.
3 5 7 9 10 11 13 15 17 19

Pg. 131

Como ejemplo desarrollaremos el algoritmo expresado en pseudocdigo de una
solucin que permita almacenar la nota de los alumnos de un saln de clase, buscar
una nota y determinar la posicin donde esta almacenada dicha nota, si sta es
encontrada.

Algoritmo PrgBuscarPosicionBin

SALIDA: mensaje

INICIO
TEXTO mensaje
NUMERO notas[ ], numAlu, pos = -1
NUMERO bajo = 0, alto, central, valor = 0
LEER numAlu
CREAR notas

alto = numAlu - 1
central = (bajo+alto) DIVIDIR 2

LEER notas[i]
FINDESDE

LEER valor

COMENTARIO Bsqueda binaria. Bsqueda de la posicin de un valor en el
vector notas
MIENTRAS ( ( bajo =< alto ) AND ( A[central] <> valor ) )
SI ( valor < notas[central] )
ENTONCES
alto = central -1
SINO
bajo = central + 1
FINSI
central = ( bajo + alto ) DIVIDIR 2
FINMIENTRAS

SI ( valor = notas[central] )
ENTONCES
pos = central
FINSI

SI ( pos >= 0 )
ENTONCES
mensaje = Valor encontrado en la posicin + pos
SINO
FINSI
ESCRIBIR mensaje

FIN

Conjunto de
instrucciones que

Pg. 132


PrgBuscarPosicionBin main ( )


public class PrgBuscarPosicionBin {


int notas[ ], numAlu, pos = -1 ;
int bajo = 0, alto, central, valor = 0 ;
String mensaje ;

alto = numAlu - 1 ;
central = (bajo + alto) / 2 ;

for ( int i = 0; i < numAlu; i++ ) {
}


while ( ( bajo <= alto && notas[central] != valor ) ) {
if ( valor < notas[central] ) {
alto = central - 1 ;
} else {
bajo = central + 1 ;
}
central = ( bajo + alto ) / 2 ;
}

if ( valor == notas [central] ) {
pos = central ;
}

if ( pos >= 0 ) {
mensaje = "Valor encontrado en la posicin " + pos ;
} else {
}
System.out.print ( mensaje ) ;
}

}


Pg. 133

El algoritmo desarrollado anteriormente puede ser modificado de tal forma que
pueda recibir el valor que se desea buscar y pueda devolver un valor conteniendo el
resultado de la bsqueda. Esto nos permite la reutilizacin de los algoritmos en
diferentes aplicaciones.

Analice detenidamente el siguiente algoritmo. Para su ejecucin se asume que el
arreglo notas existe, es accesible y contiene datos. Recuerde que el tamao del
arreglo se obtiene utilizando la regla LONGITUD.

El siguiente algoritmo permite recibir un valor, buscar dicho valor y devolver la
posicin del mismo si este es encontrado.

Algoritmo Bsqueda Binaria Mtodo BuscarPosicionBin

ENTRADA: valor
SALIDA: mensaje

INICIO

TEXTO mensaje
NUMERO bajo = 0, alto = notas.LONGITUD - 1, central, pos = -1
central = (bajo + alto) DIVIDIR 2

MIENTRAS ( ( bajo =< alto ) AND ( A[central] <> valor ) )
SI ( valor < notas[central] )
ENTONCES
alto = central -1
SINO
bajo = central + 1
FINSI
central = ( bajo + alto ) DIVIDIR 2
FINMIENTRAS

SI ( valor = notas[central] )
ENTONCES
pos = central
FINSI

RETORNAR pos

FIN


Pg. 134


Algoritmo Bsqueda Binaria Mtodo buscarPosicionBin ( )


public class PrgBuscarPosicionBin {


int bajo = 0, alto = conta - 1, central, pos = -1 ;
String mensaje = "";

central = (bajo + alto) / 2 ;

while ( ( bajo <= alto && notas[central] != valor ) ) {
if (valor < notas[central] ) {
alto = central - 1 ;
} else {
bajo = central + 1 ;
}
central = ( bajo + alto ) / 2 ;
}

if ( valor == notas[central] ) {
pos = central ;
}
return pos ;
}

}

Como ejercicio, intente desarrollar un algoritmo utilizando Bsqueda Binaria, que
permita buscar una nota y determine el nmero de veces que dicha nota es
encontrada.


Pg. 135

Durante el tema de bsqueda se ha desarrollado un ejemplo sencillo y prctico utilizando un
vector numrico. Cuando se disean algoritmos las consideraciones para el uso de vectores
de tipo numrico son las mismas que para los vectores de tipo cadena. Al momento de
codificar un algoritmo en un lenguaje de programacin determinado se debe tener en cuenta
sus caractersticas y particularidades. En Java, por ejemplo, cuando se trabaja con valores
numricos se utilizan los operadores lgicos y aritmticos, y cuando se trabaja con valores de
tipo cadena se utilizan mtodos de la clase String.

A continuacin, se muestra la codificacin en lenguaje de programacin Java, de una solucin
que permite almacenar los nombres de los alumnos de un saln de clase (en el arreglo
nombres) y determinar la posicin donde un nombre est almacenado si existe. Se utiliza una
bsqueda secuencial.

Observe el uso del mtodo equalsIgnoreCase ( ) de la clase String de Java.
PrgBuscarPosicionSec main ( )


public class PrgBuscarPosicionSec {


int numAlu = 0, pos = -1, i ;
String nombres[ ], valor, mensaje ;

System.out.print ( Ingrese el nmero de alumnos: ) ;
nombres = new String[numAlu] ;

for ( i = 0; i < numAlu; i++ ) {
System.out.print ( Ingrese el nombre del alumno + (i + 1) + : ) ;
nombres[i] = Lectura.leerString ( ) ;
}

System.out.println ( Ingrese el nombre a buscar: ) ;
valor = Lectura.leerString ( ) ;

for ( i = 0; i < numAlu; i++ ) {
if ( nombres[i].equalsIgnoreCase ( valor ) ) {
pos = i ;
break ;
}
}

if ( pos >= 0 )
mensaje = Valor encontrado en la posicin + pos ;
else {
mensaje = Valor no encontrado ;
}
}
}


Pg. 136

ORDENAMIENTO DE DATOS

Introduccin:

La ordenacin de los datos y su posterior transformacin en informacin constituyen uno de
los procesos bsicos y necesarios que debemos realizar cuando se procesan o manipulan
datos. Podemos afirmar que los datos se ordenan de diferente manera y utilizando diferentes
mtodos con la finalidad de poder acceder a los datos lo ms rpido posible.

Es comn que trabajemos con grandes cantidades de datos almacenados en las Estructuras
de Datos y que sea necesario ordenar previamente los datos almacenados antes de ejecutar
otros procesos.

Definicin:

La ordenacin o clasificacin de datos es la operacin de organizar un conjunto de datos en
algn orden dado, tal como creciente o decreciente en datos numricos, o bien en orden
alfabtico directo o inverso. Estructuras de datos tpicas que suelen requerir ordenacin son:
lista de nmeros, archivos de clientes de banco, nombres de una agenda telefnica, etc. En
sntesis, la ordenacin significa poner los datos en orden (orden numrico para los nmeros y
alfabtico para los caracteres) ascendente o descendente.

La ordenacin de los datos es una operacin tan frecuente en programas de computadora
que una gran cantidad de algoritmos se han diseado para clasificar listas de elementos con
eficacia y rapidez. La eleccin de un determinado algoritmo depende del tamao de la
estructura de datos a clasificar, el tipo de datos y la cantidad de memoria disponible.

Categoras:

Los mtodos de ordenacin se dividen en dos categoras:

Ordenacin interna o directa:

La ordenacin interna consiste en ordenar los elementos
almacenados en las estructuras de datos que trabajan en la
memoria interna de la computadora. Es decir, en la memoria
RAM (memoria de gran velocidad y acceso aleatorio). Como
ejemplo, podemos mencionar a los arreglos y las listas.


Pg. 137

Ordenacin externa o indirecta.

La ordenacin externa consiste en ordenar los elementos
almacenados en las estructuras de datos ubicadas en un
almacenamiento externo de la computadora. Es decir, en discos
duros, cintas, etc. (los dispositivos externos son ms lentos para
las operaciones de entrada/salida, pero, por el contrario, pueden
contener mayor cantidad de informacin). Como ejemplo,
podemos mencionar a los archivos y las bases de datos.

La ordenacin externa no ser tratada en el presente texto.

Los algoritmos de ordenacin interna se explicarn a travs del uso de vectores (arreglos
unidimensionales) y se pueden extender para poder aplicarlos al uso de matrices (arreglos
bidimensionales), considerando la ordenacin respecto a una fila o columna (o ambas de ser
el caso).

Los algoritmos de ordenacin interna ms utilizados y que sern tratados a continuacin son:

Mtodo de ordenamiento por Seleccin.
Mtodo de ordenamiento por Insercin.
Mtodo de ordenamiento por Intercambio o burbuja.
Mtodo de ordenamiento rpido QuickSort.
.


Pg. 138

Mtodo de Ordenamiento por Seleccin

Este mtodo de ordenacin es simple de entender y codificar en un lenguaje de
programacin. Se utiliza con arreglos pequeos y medianos, y funciona de la siguiente
manera:

Primero se busca el elemento ms pequeo del arreglo y se
intercambia con el elemento que est en la primera posicin;
despus, se busca el siguiente elemento ms pequeo del arreglo y
se intercambia con el elemento que est en la segunda posicin,
continuando de esta forma hasta que el elemento ms grande se
encuentre al final del arreglo; es decir, hasta que todo el arreglo est
ordenado.

Podemos afirmar que este algoritmo funciona seleccionando
repetidamente el elemento ms pequeo de los que queda por
ordenar en el arreglo, y que la mayora de elementos del arreglo se
mueve como mximo una sola vez.

Este mtodo se basa en los siguientes principios:

Se selecciona el elemento del arreglo que tenga el nmero
menor.
El elemento seleccionado se intercambia con el primer elemento.
Se repite despus estas operaciones con los elementos no
ordenados del arreglo, hasta que todos los elementos estn
ordenados.

Ejemplo;

El vector notas contiene 5 elementos. Dichos elementos son 20, 18, 13, 17, 19 y estn
almacenados en las posiciones 0, 1, 2, 3 y 4 respectivamente.
Sea el vector:
20 18 13 17 19
4 3 2 1 0
notas
numAlu = 5.

Pg. 139

Se selecciona el elemento del vector notas que tenga el nmero
menor:

El elemento seleccionado se intercambia con el primer elemento:

Ahora, se selecciona el elemento del vector que tenga el nmero
menor entre los elementos restantes:

El elemento seleccionado se intercambia con el segundo elemento
del vector:


El elemento seleccionado se intercambia con el tercer elemento del
vector:

20 18 13 17 19
4 3 2 1 0
13 18 20 17 19
4 3 2 1 0
13 18 20 17 19
4 3 2 1 0
13 17 20 18 19
4 3 2 1 0
13 17 20 18 19
4 3 2 1 0
13 17 18 20 19
4 3 2 1 0

Pg. 140


El elemento seleccionado se intercambia con el cuarto elemento del
vector:

Observe que el vector ya est ordenado (de menor a mayor) y que el
ltimo nmero (ubicado en la posicin 4) es el nmero mayor.

13 17 18 20 19
4 3 2 1 0
13 17 18 19 20
4 3 2 1 0

Pg. 141

A continuacin se muestra el algoritmo del mtodo de ordenacin por seleccin:

Algoritmo PrgOrdenacionSeleccion

ENTRADA: numAlu, notas[ ]
SALIDA: notas[ ]

INICIO

NUMERO notas[ ], numAlu, i

LEER numAlu
CREAR notas[numAlu]

DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
LEER notas[i]
FINDESDE

COMENTARIO Ordenacin por seleccin

NUMERO k, j, nota
nota = notas[i]
k = i

DESDE j = i + 1 HASTA j = numAlu - 1 INCREMENTA 1
SI ( notas[j] < nota )
ENTONCES
k = j
nota = notas[k]
FINSI
FINDESDE

notas[k] = notas[i]
notas[i] = nota

FINDESDE

COMENTARIO Mostrar datos ordenados
ESCRIBIR notas[i]
FINDESDE

FIN

Conjunto de
instrucciones que

Pg. 142


PrgOrdenacionSeleccion main ( )


public class PrgOrdenacionSeleccion {


int notas[ ], numAlu, i ;


for ( i = 0; i < numAlu; i++ ) {
}

int k, j, nota ;
for ( i = 0; i < numAlu; i++ ) {
nota = notas[i] ;
k = i ;

for ( j = i + 1; j < numAlu; j++ ) {
if ( notas[j] < nota ) {
k = j ;
nota = notas[k] ;
}
}

notas[k] = notas[i] ;
notas[i] = nota ;
}

for ( i = 0; i < numAlu; i++ ) {
System.out.println ( "La nota " + (i+1) + " es: " + notas[i] ) ;
}
}

}


Pg. 143

Mtodo de ordenamiento por Insercin

Este mtodo de ordenacin es casi tan sencillo como el mtodo de ordenacin por seleccin,
y probablemente ms flexible. Se utiliza con arreglos pequeos y medianos, y funciona de la
siguiente manera:

Primero se toma el segundo elemento del arreglo y se inserta en el
lugar que le corresponde entre los dos primeros elementos; despus,
se toma el tercer elemento del arreglo y se inserta en el lugar que le
corresponde entre los tres primeros elementos, continuando de esta
forma hasta que se tome el ltimo elemento y se inserte en el lugar
que le corresponda entre todos los elementos del arreglo.

Podemos afirmar que este algoritmo funciona tomando cada
elemento del arreglo empezando desde el segundo elemento e
insertndolo en el lugar que le corresponda entre los elementos ya
insertados.

Este mtodo se basa en los siguientes principios:

Se toma el segundo elemento del arreglo.
Se inserta el elemento tomado en el lugar que le corresponde
entre los dos primeros elementos del arreglo.
Se repite despus estas operaciones con los elementos no
ordenados del arreglo hasta que todos los elementos estn
ordenados.

Ejemplo;

El vector notas contiene 5 elementos. Dichos elementos son 20, 18, 13, 17, 19 y estn
almacenados en las posiciones 0, 1, 2, 3 y 4 respectivamente.
Sea el vector:
20 18 13 17 19
4 3 2 1 0
notas
numAlu = 5.

Pg. 144

Se toma el segundo elemento del vector notas:

El elemento tomado se inserta en el lugar que le corresponde entre
los dos primeros elementos, quedando ordenada esta parte del
vector:

Ahora, se toma el tercer elemento del vector:

los tres primeros elementos, quedando ordenada esta parte del
vector:

Ahora, se toma el cuarto elemento del vector:

18 20
4 3 2 1 0
20 18
4 3 2 1 0
x = 18
18 20 13
4 3 2 1 0
x = 13
13 18 20
4 3 2 1 0
13 18 20 17
4 3 2 1 0
x = 17

Pg. 145

los cuatro primeros elementos, quedando ordenada esta parte del
vector:

Ahora, se toma el ltimo elemento del vector:

El ltimo elemento tomado se inserta en el lugar que le corresponde
entre los todos los elementos, quedando ordenado todo el vector:

Finalmente, podemos afirmar que este mtodo se basa en insertar
cada elemento del arreglo en el lugar adecuado.

13 17 18 20
4 3 2 1 0
13 17 18 20 19
4 3 2 1 0
x = 19
13 17 18 19 20
4 3 2 1 0

Pg. 146

A continuacin se muestra el algoritmo del mtodo de ordenacin por insercin:

Algoritmo PrgOrdenacionInsercion

SALIDA: notas[ ]

INICIO


LEER numAlu
CREAR notas[numAlu]

LEER notas[i]
FINDESDE

COMENTARIO Ordenacin por insercin

NUMERO j, nota, sw

sw = 0
nota = notas[i]
j = i

MIENTRAS ( ( j > 0 ) AND ( sw = 0 ) )

SI ( nota < notas[ j -1 ] )
ENTONCES
notas[j] = notas[ j -1 ]
j = j -1
SINO
sw = 1
FINSI

notas[j] = nota

FINMIENTRAS
FINDESDE

ESCRIBIR notas[i]
FINDESDE

FIN

Conjunto de
instrucciones que

Pg. 147

Este algoritmo puede ser mejorado eliminando la variable sw, tal y como se muestra
a continuacin:


SALIDA: notas[ ]

INICIO


LEER numAlu
CREAR notas[numAlu]

LEER notas[i]
FINDESDE


NUMERO j, nota

nota = notas[i]
j = i

MIENTRAS ( j > 0 )

SI ( nota < notas[ j -1 ] )
ENTONCES
notas[j] = notas[ j -1 ]
j = j -1
SINO
j = 0
FINSI

notas[j] = nota

FINMIENTRAS
FINDESDE

ESCRIBIR notas[i]
FINDESDE

FIN

Conjunto de
instrucciones que

Pg. 148

Finalmente, podemos mejorar an ms el algoritmo, tal y como se muestra a
continuacin:


SALIDA: notas[ ]

INICIO


LEER numAlu
CREAR notas[numAlu]

LEER notas[i]
FINDESDE


NUMERO j, tempNota

tempNota = notas[i]
j = i-1;

MIENTRAS ( j >= 0 && tempNotas < notas[ j] )
notas[j+1] = notas[ j]
notas[j]=tempNotas;
j = j -1

FINMIENTRAS

notas[j+1] = tempNotas

FINDESDE

ESCRIBIR notas[i]
FINDESDE

FIN

Conjunto de
instrucciones que

Pg. 149


PrgOrdenacionInsercion main ( )


public class PrgOrdenacionInsercion {


int notas[], numAlu, i ;

numAlu = LE.leerInt( "Ingrese el nmero de alumnos: " ) ;

for ( i = 0; i < numAlu; i++ ) {

notas[i] = LE.leerInt( "Ingrese la nota del alumno " + (i + 1) + ": " ) ;
}

int j, tempNotas ;

for ( i = 1; i < numAlu; i++ ) {

tempNotas = notas[i] ;

j=i-1;

while (j>=0 && tempNotas<notas[j] ) {

notas[j+1]=notas[j];
notas[j]=tempNotas;
j--;
}
notas[j+1] = tempNotas ;
}

for ( i = 0; i < numAlu; i++ ) {
}
}

}


Pg. 150

Mtodo de Ordenamiento por Intercambio

Este mtodo de ordenacin se fundamenta en el principio de comparar e intercambiar pares
de elementos contiguos hasta ordenar todos los elementos. Al igual que en los mtodos
anteriores, hacemos varios pases sobre el arreglo y en cada recorrido desplazamos el
elemento ms pequeo del conjunto restante hacia el extremo final del arreglo.

Este mtodo se conoce tambin como ordenacin por burbuja. El algoritmo de este mtodo
es relativamente sencillo y fcil de desarrollar (se utilizan dos estructuras de repeticin
DESDE, una estructura de decisin simple SI y tres estructuras de asignacin para realizar el
intercambio). Generalmente, se utiliza para ordenar arreglos pequeos.

A continuacin se muestra el algoritmo del mtodo de ordenacin por intercambio:


Pg. 151

Algoritmo PrgOrdenacionIntercambio

SALIDA: notas[ ]

INICIO


LEER numAlu
CREAR notas[numAlu]

LEER notas[i]
FINDESDE

NUMERO j, nota


DESDE j = i + 1 HASTA j = numAlu - 1 INCREMENTA 1

SI ( notas[i] > notas[j] )
ENTONCES
nota = notas[i]
notas[i] = notas[j]
notas[j] = nota
FINSI

FINDESDE

FINDESDE

ESCRIBIR notas[i]
FINDESDE

FIN

Este mtodo ser utilizado en el presente texto para el desarrollo de las soluciones.
Realice sus propias observaciones.

Conjunto de
instrucciones que

Pg. 152


PrgOrdenacionIntercambio main ( )


public class PrgOrdenacionIntercambio {


int notas[ ], numAlu, i ;


for ( i = 0; i < numAlu; i++ ) {
}

int j, nota ;
for ( i = 0; i < numAlu - 1; i++ ) {

for ( j = i+1; j < numAlu; j++ ) {

if ( notas[i] > notas[j] ) {

nota = notas[i] ;
notas[j] = notas[ j-1 ] ;
notas[i] = nota ;
}
}

}

for ( i = 0; i < numAlu; i++ ) {
}
}

}

Esta clase permite ordenar el arreglo notas de menor a mayor. En caso se necesite
ordenarlo de mayor a menor slo deber modificar la condicin lgica tal y como se
muestra a continuacin:

if ( notas[i] <notas[j] ) {

Pg. 153

programacin Java, des una solucin que permite almacenar los nombres de los
alumnos de un saln de clase (en el arreglo nombres) y los ordena en forma
alfabtica (ascendentemente). Se utiliza el ordenamiento por intercambio.

PrgOrdenacionIntercambio main ( )


public class PrgOrdenacionIntercambio {


int numAlu, i ;
String nombres[], nombre ;


for ( i = 0; i < numAlu; i++ ) {
System.out.print ( "Ingrese el nombre del alumno " + (i + 1) + ": " ) ;
nombres[i] = Lectura.leerString ( ) ;
}

int j ;
for ( i = 0; i < numAlu - 1; i++ ) {
for ( j = i+1; j < numAlu; j++ ) {

if ( nombres[i].compareToIgnoreCase ( nombres[j]) > 0 ) {

nombre = nombres[i] ;
nombres[j] = nombres[ j-1 ] ;
nombres[i] = nombre ;
}
}
}

for ( i = 0; i < numAlu; i++ ) {
System.out.println ( "El nombre " + (i+1) + " es: " + nombres[i] ) ;
}
}
}

Observe el uso del mtodo compareToIgnoreCase ( ) de la clase String de Java.
Esta clase permite ordenar el arreglo nombres alfabticamente en forma ascendente.
En caso se necesite ordenarlo descendentemente slo deber modificar la condicin
lgica tal y como se muestra a continuacin:

if ( nombres[i].compareToIgnoreCase( notas[j] ) <0 ) {

Pg. 154

Mtodo de ordenamiento rpido Quicksort

El mtodo de ordenacin rpida (QuickSort) permite ordenar un arreglo o una lista de
elementos. Este mtodo se basa en el hecho que es ms fcil ordenar dos listas pequeas
que una lista grande (estrategia Divide y Vencers Divide and Conquer).

Se denomina mtodo de ordenacin rpida porque, en general, puede ordenar los datos de
un arreglo mucho ms rpido que cualquiera de los mtodos de ordenacin mencionados.

Este mtodo se debe a Hoare, y se basa en los siguientes principios:

Se toma un elemento arbitrario del vector, al que vamos a denominar pivote (p).

Se divide el vector de tal forma que todos los elementos a la izquierda del pivote
sean menores que l, y los elemento de la derecha mayores.

Ordenamos por separado, las dos zonas delimitadas por el pivote.

En el caso mejor, el pivote termina en el centro del array, dividindola en dos
subarrays de igual tamao. En este caso, el orden de complejidad del algoritmo
es O(nlog(n)).

En el caso peor, el pivote termina en un extremo del array. El orden de
complejidad del algoritmo es entonces de 0(n). El peor caso depender de la
implementacin del algoritmo, aunque habitualmente ocurre en arrays que se
encuentran ordenados, o casi ordenados.

En el caso medio, el orden de complejidad es O(nlog(n)). No es extrao, pues,
que la mayora de optimizaciones que se aplican al algoritmo se centren en la
eleccin del pivote.

Ejemplo;

El vector notas contiene 7 elementos. Dichos elementos son 6, 4, 8, 7, 3, 2, 5 y estn
almacenados en las posiciones 0, 1, 2, 3, 4, 5, 6 respectivamente. En el ejemplo
vamos a ubicar al pivote y lo identificaremos con la letra p y los ndices con las letras i y
j respectivamente.
Sea el vector:
notas
numAlu = 7
6 4 8 7 3 2 5
4 3 2 1 0 5 6

Pg. 155

Comenzaremos con el vector completo donde el elemento divisor
ser el 6:

Comparamos con el 6 por la izquierda y el 5 por la derecha con el
pivote.

6 es menor que 7 y 5 NO es mayor que 7. Entonces avanzamos el
ndice i una posicin, mientras que el ndice j queda en su misma
posicin, y continuamos con la comparacin.

4 es menor que 7 y 5 NO es mayor que 7. Avanzamos el ndice i,
mientras que el ndice j queda en su misma posicin, y continuamos
con la comparacin.

6 4 8 7 3 2 5
4 3 2 1 0 5 6
6 4 8 7 3 2 5
4 3 2 1 0 5 6
6 4 8 7 3 2 5
4 3 2 1 0 5 6
p
i j
p
i j
6 4 8 7 3 2 5
4 3 2 1 0 5 6
p
i j
p

Pg. 156

8 NO es menor que 7 y 5 NO es mayor que 7.

Como i=2 y j=6, i es menor que j, as que intercambiamos los valores
de notas[i] y de notas[j].

Como i sigue siendo menor que j, se vuelve a aplicar el mismo
algoritmo hasta que se crucen los ndices i y j, siendo este momento
cuando se vuelve a ejecutar el mtodo quicksort (tcnica de
programacin llamada recursividad) con la parte del vector que es
menor que el pivote y, por otro lado, con la parte que es mayor. (Slo
se muestra a continuacin una parte, ya que la ejecucin del mtodo
es igual para ambas partes):

2 es menor que 4: avanzamos por la izquierda. 3 NO es mayor que 4:
no avanzamos por la derecha. Como i no es menor que el pivote, se
para, y como i es menor que j, se intercambian notas[i] y notas[j],
resultando ya ordenador este subarray:

2 3 4
p
i j
6 4 5 7 3 2 8
4 3 2 1 0 5 6
2 1 0
2 4 3
2 1 0
p
i j
p
i j
6 4 8 7 3 2 5
4 3 2 1 0 5 6

Pg. 157

El mismo procedimiento se aplicar al otro subvector. Al finalizar y
unir todos los subarrays queda el array inicial ordenado en forma
ascendente.

programacin Java del mtodo de ordenamiento rpido QuickSort utilizando la clase
reutilizable LE.

Mtodo OrdenarEnQuickSort
..
import biblioteca.*;

public class PrgOrdenamientoQuickSort {

int notas[];
int numAlu;

public PrgOrdenamientoQuickSort ( ) {

numAlu = LE.leerInt("Ingrese la cantidad de alumnos: ");
notas = new int[numAlu];

}


PrgOrdenamientoQuickSort obj = new PrgOrdenamientoQuickSort ( );
obj.IngresarNumeros ( );
obj.Mostrar ( );
obj.OrdenarEnQuickSort(0, ((obj.numAlu)-1));
LE.mostrarInformacion ("La Lista Ordenada es");
obj.Mostrar ( );

}

public void IngresarNumeros ( ) {

for (int i = 0; i < numAlu; i++) {
notas[i] = LE.leerInt("Ingrese la nota del alumno nro: " + (i + 1));
}
}

2 3 4 5 6 7 8
4 3 2 1 0 5 6

Pg. 158

..

public void Mostrar ( ) {

String lista = "";

lista += "Los nmeros son: " + notas[i] + " \n";
}
LE.mostrarInformacion ( lista ) ;
}

public void OrdenarEnQuickSort(int primero, int ultimo) {

int pivote, tempNotas;
int i = primero, j = ultimo;
pivote = notas[(primero + ultimo) / 2];
do {
while (notas[i] < pivote) {
i++;
}
while (notas[j] > pivote) {
j--;
}
if (i <= j) {
tempNotas = notas[i];
notas[i] = notas[j];
notas[j] = tempNotas;

i++;
j--;
}

} while (i <= j);

if (primero < j) {
OrdenarEnQuickSort(primero, j);
}

if (ultimo > i) {
OrdenarEnQuickSort(i, ultimo);
}
}

}
Llamada recursiva al mtodo
OrdenarEnQuickSort( );

Pg. 159

RECURSIVIDAD

Definicin:

El trmino recursividad es la forma en la cual se especifica un proceso basado en su propia
definicin.

La recursin permite definir un objeto (problemas, estructuras de datos) en trminos de s
mismo. Casos tpicos de estructuras de datos definidas de manera recursiva son los rboles y
las listas ligadas. Algunos ejemplos de problemas que se definen recursivamente son el
factorial de un nmero, la serie de Fibonacci, etc.

Ejemplos:

Desarrollar un mtodo que retorne el factorial de un nmero utilizando recursividad:

La recursividad a menudo se utiliza cuando se evala algn tipo de problema arbitrariamente
complejo, ya que no se restringe la solucin a ningna estructura en particular. La funcin
puede simplemente efectuar la recursividad hasta que se haya alcanzado el final del
problema.

Es por ello que debemos entender que un subprograma que se llama a s mismo se dice que
es recursivo.

Aunque los trminos "recursin" y "recursividad" son ampliamente empleados en el campo de
la informtica, el trmino correcto en castellano es recurrencia.

public long factorial ( long n ) {
// Declaramos la lgica del algortmo.
if (n ==0) {
return 1;
}else {
return n * factorial ( n 1 );
}
}
Llamada recursiva al
mtodo factorial

Pg. 160

Problema 018

Enunciado:
Utilizando mtodos y un men de opciones desarrolla la codificacin en JAVA de una
solucin que permita :

1.- Ingresar el nombre y las notas de los alumnos,
2.- Calcular y mostrar el promedio de todos los alumnos.
3.- Buscar y ver los datos de un determinado alumno de acuerdo a su cdigo
4.- Ordenar los datos de acuerdo a notas de menor a mayor.




Dados los vectores:

codigo nombre notas
0
1
2
3
: : :
: : :
9999
numAlu = 0





Pg. 161


Clase PrgAlumnos

import biblioteca.LE ;

public class PrgAlumnos {
String nombre[ ] ;
long codigo[ ] ;
double nota[ ] ;
int numAlu ;

public PrgAlumnos ( ) {
numAlu = 0 ;
nombre = new String [9999] ;
codigo = new long [9999] ;
nota = new double [9999] ;
}

public static void main ( String[ ] args ) {
PrgAlumnos obj = new PrgAlumnos ( ) ;
obj.menu ( ) ;
}

public void menu ( ) {
String menu = " Ingrese la opcin que desea ejecutar \n "
+" 1) Ingresar Datos \n "
+" 2) Calcular Promedio \n "
+" 3) Buscar \n "
+" 4) Ordenar \n "
+" 5) Mostrar \n "
+" 6) Finalizar \n "
+" ---------------------------------------- " ;
int opc = 0 ;
boolean sw = false ;

do {
opc = LE.leerInt(menu) ;

switch ( opc ) {
case 1:
ingresar ( ) ;
sw = true ;
break ;

case 2:
if ( sw )
calcular ( ) ;
else
LE.mostrarError ( " Error...Ingrese los datos " ) ;
break ;


Pg. 162

Clase PrgAlumnos
case 3:
if ( sw )
buscar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;

case 4:
if ( sw )
ordenar ();
else
break ;

case 5:
if ( sw )
mostrar ();
else
break ;

case 6:
break ;
default:
LE.mostrarError ( " Opcin no vlida Reintente! " ) ;
}
} while ( opc != 6 ) ;
}

public void ingresar () {
int rpta = 0 ;
do {
codigo[numAlu] = LE.leerLong ( " Cdigo del alumno " + ( numAlu + 1)
+ " : " ) ;
nombre[numAlu] = LE.leerString ( " Nombre del alumno " + ( numAlu +
1) + " : " ) ;
do {
nota[numAlu] = LE.leerDouble ( " Nota del alumno " + ( numAlu + 1 )
+ " : " ) ;
if ( nota[numAlu] < 0 || nota[numAlu] > 20 ) {
LE.mostrarError ( " Error...Notas ingresada Errnea " ) ;
}
} while ( nota[numAlu] < 0 || nota[numAlu] > 20 ) ;
numAlu++ ;

rpta = LE.mostrarPreguntaOpcion2 ( " Desea continuar ? " ) ;
} while ( rpta == 0 ) ;
}

public void calcular ( ) {
double prom = 0, suma = 0 ;
for ( int i=0; i<numAlu; i++ ) {
suma += nota[i] ;
}
prom = suma / numAlu ;
prom = Math.round ( prom*100 ) / 100.0 ;


Pg. 163

Clase PrgAlumnos

LE.mostrarResultado ( " El promedio del saln es: " + prom ) ;
}

public void buscar ( ) {
long aux = 0 ;
aux = LE.leerLong( " Ingrese el codigo del alumno que desea modificar: " )
;
for( int i=0; i<numAlu; i++ ) {
if (codigo[i] == aux){
LE.mostrarInformacion("Datos del Alumno: "+"codigo:"+ codigo[i]+"
nombre: "+ nombre[i]+" nota: "+ nota[i]);
break;
}
}
LE.mostrarInformacion( " Error...Codigo no Encontrado " );
}

public void ordenar ( ){
for(int i=0;i<numAlu-1;i++)
for(int j=i+1;j<numAlu;j++)
if(nota[i] > nota[j]){
String aux1 = nombre[i];
long aux2 = codigo[i];
double aux3 = nota[i];
nombre[i] = nombre[j];
codigo[i] = codigo[j];
nota[i] = nota[j];
nombre[j]=aux1;
codigo[j]=aux2;
nota[j]=aux3;
}
}

public void mostrar ( ) {
String total = " " ;
total += "\n" + codigo[i] + "/" + nombre[i] + "/" + nota[i] ;
}
LE.mostrarResultado ( " Los datos de los alumnos son: " + " " + total ) ;
}

}


Pg. 164

Problema 019

Enunciado:
Utilizando mtodos y un men de opciones desarrolla la codificacin en JAVA de una
solucin que permita :

1.- Ingresar el cdigo, nombre y el sueldo de los empleados de una universidad.
2.- Calcular y mostrar el sueldo promedio.
3.- Buscar y ver los datos de un determinado producto de acuerdo a su cdigo
4.- Ordenar los datos de los empleados alfabeticamente.




Dados los vectores:

codigo nombre sueldo
0
1
2
3
: : :
: : :
9999
numEmp = 0


Donde numEmp permite almacenar el nmero de alumnos cuyos datos se han almacenado.



Pg. 165




public class PrgUniversidad {

String nombre[ ] ;
long codigo[ ] ;
double sueldo[ ] ;
int numEmp ;

public PrgUniversidad ( ) {
numEmp = 0 ;
sueldo = new double [9999] ;
}

PrgUniversidad obj = new PrgUniversidad ( ) ;
obj.menu ( ) ;
}

+" 3) Buscar \n "
+" 4) Ordenar \n "
+" 5) Mostrar \n "
+" ---------------------------------------- " ;
int opc = 0 ;

do {

switch ( opc ) {
case 1:
ingresar ( ) ;
sw = true ;
break ;

case 2:
if ( sw )
calcular ( ) ;
else

Pg. 166


break ;

case 3:
if ( sw )
buscar ();
else
break ;

case 4:
if ( sw )
ordenar ();
else
break ;

case 5:
if ( sw )
mostrar ();
else
break ;

case 6:
break ;
default:
}
} while ( opc != 6 ) ;
}

int rpta = 0 ;
do {
codigo[numEmp] = LE.leerLong ( " Cdigo del empleado " + ( numEmp
+ 1) + " :
" ) ;
nombre[numEmp] = LE.leerString ( " Nombre del empleado " + (
numEmp + 1) + "
: " ) ;
sueldo[numEmp] = LE.leerDouble ( " Sueldo del empleado " + (
numEmp + 1 ) + " :
" ) ;
numEmp++ ;

} while ( rpta == 0 ) ;
}

for ( int i=0; i<numEmp; i++ ) {
suma += sueldo[i] ;
}


Pg. 167


prom = suma / numEmp ;
}

public void buscar ( ) {
long aux = 0 ;
aux = LE.leerLong( " Ingrese el codigo del alumno que desea modificar: "
) ;
for( int i=0; i<numEmp; i++ ) {
LE.mostrarInformacion("Datos del Alumno: "+"codigo:"+ codigo[i]+"
nombre: "+ nombre[i]+" sueldo: "+ sueldo[i]);
break;
}
}
}

public void ordenar ( ){
for(int i=0;i<numEmp-1;i++)
for(int j=i+1;j<numEmp;j++)
if( nombre[i].compareToIgnoreCase(nombre[j]) > 0 ){
String aux1 = nombre[i];
long aux2 = codigo[i];
double aux3 = sueldo[i];

nombre[i] = nombre[j];

sueldo[i] = sueldo[j];
nombre[j]=aux1;
codigo[j]=aux2;
sueldo[j]=aux3;
}
}

for ( int i=0; i<numEmp; i++ ) {
total += "\n" + codigo[i] + "/" + nombre[i] + "/" + sueldo[i] ;
}
}

}


Pg. 168

MODIFICACIN DE DATOS

Introduccin:

La modificacin de los datos constituye otros de los procesos comunes que debemos tener en
cuenta cuando realizamos mantenimiento a los datos almacenados en las Estructuras de
Datos.

Muchas veces sucede que al momento de ingresar los datos, la persona encargada de esta
labor, se equivoca e ingresa datos inexactos o errados. Por otro lado, el valor de los datos
almacenados puede perder vigencia y cambiar. Estas situaciones hacen evidente la
necesidad de modificar los datos cuando estos han sido ingresados en forma inexacta o
errnea, o cuando han perdido vigencia y sus valores han cambiado. A este proceso se
denomina modificacin de datos y se realiza para mantener actualizados los datos. Este
proceso hace uso de la bsqueda con la finalidad de determinar si los datos que se desean
modificar estn almacenados.

Definicin:

La modificacin de datos consiste en cambiar el valor de un dato o de un conjunto de datos
almacenados en una Estructura de Datos.

En el caso de los arreglos, la modificacin de datos es poco usual, pero necesaria para
cambiar el valor de los datos cuando han sido ingresados en forma errnea.

Ejemplos:

En una gua telefnica electrnica se desea cambiar el nmero
telefnico de una determinada persona. Entonces se buscar a
la persona por su apellido y nombre y si esta persona est
registrada en la gua, ingresamos su nuevo nmero y lo
cambiamos por el existente.

En una lista de alumnos y sus calificaciones se desea modificar
la nota del examen final de los alumnos que realizaron reclamos
y estos procedieron.


Pg. 169

Mtodo de Modificacin de Datos

El algoritmo para modificar datos en arreglos es simple de comprender y codificar en un
lenguaje de programacin determinado.

La modificacin de datos se basa en los siguientes principios:

Se busca el elemento del arreglo cuyos datos se desea modificar.

Se obtiene el nuevo dato o los nuevos datos por los cuales se van a
reemplazar los datos a modificar.

Se reemplaza el nuevo dato o los nuevos datos por los datos a modificar.

Aunque no es totalmente necesario, cuando se realiza una modificacin de datos tiene
sentido que la bsqueda del elemento del arreglo cuyos datos se desea modificar se realice
sobre un arreglo que almacene datos nicos (como por ejemplo el cdigo del alumno, cdigo
del empleado, nmero de producto, etc.) y si el elemento es encontrado sus valores se
puedan modificar.

Para ilustrar la forma en que se pueden modificar los datos, desarrollaremos una explicacin
en base a una solucin que permita almacenar el cdigo, el nombre y la nota final de los
alumnos de un saln de clase. Para esto utilizaremos la Grfica de Estructura de Datos que
se muestra a continuacin:

Dados los vectores:

0
1
2
3
: : :
: : :
9999
numAlu = 0




Pg. 170

Ahora, supongamos que se han ingresado los datos de 5 alumnos de un saln de clase, lo
cual se podra representar de la siguiente manera:

Dados los vectores:

codigos nombres Notas

0 10 JUAN 19

1 20 CARMIEN 13

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
9999
numAlu = 5



Ingresados los datos nos percatamos que el nombre del segundo alumno y su nota no son
correctos, por lo que se necesita modificarlo (por error se ingres el nombre CARMIEN en
lugar de CARMEN y la nota debi ser de 17).

Como se ha establecido, para la modificacin de datos se necesita en primer lugar ubicar la
posicin donde se tienen almacenados los datos que se desean modificar. Para esto
utilizamos alguno de los algoritmos de bsqueda de datos tratados anteriormente en este
mismo captulo. En segundo lugar, se necesita ingresar los datos correctos y reemplazarlos
por los datos ingresados en forma errnea.

En base a esto, se ingresa el cdigo del alumno del cual se desea realizar la modificacin de
sus datos. Para nuestro caso ingresamos el cdigo 20. Buscamos el cdigo ingresado en el
vector codigos[]. El cdigo buscado es encontrado en la segunda posicin del vector
codigos[]. Encontrado el cdigo se solicita el nombre y la nota correcta del alumno, los cuales
son almacenados en la segunda posicin del vector nombres[] y notas[] respectivamente.


Pg. 171

Cdigo buscado = 20

codigos nombres Notas

0 10

JUAN 19

1
20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
9999
numAlu = 5



Datos reemplazados:
Nuevo nombre = Carmen
Nueva nota = 17


Pg. 172

El siguiente algoritmo en Pseudocdigo expresa lo descrito anteriormente.

Algoritmo PrgModificarDatos

ENTRADA: numAlu, codigos[ ], nombres[ ], notas[ ], codigo
SALIDA: mensaje

INICIO

TEXTO nombres[ ], mensaje
NUMERO codigos[ ], notas[ ], numAlu, pos = -1, codigo, i
LEER numAlu
CREAR codigos[numAlu], nombres[numAlu], notas[numAlu]

COMENTARIO Ingresar datos a los vectores
LEER codigos[i]
LEER nombres[i]
LEER notas[i]
FINDESDE

COMENTARIO Ingreso del cdigo a buscar
LEER codigo

vector codigos[ ]

SI ( codigos[i] = codigo )
ENTONCES
pos = i
TERMINAR
FINSI
FINDESDE

SI ( pos > = 0 )
ENTONCES
LEER nombres[pos]
LEER notas[pos]
mensaje = Los datos del alumno fueron modificados satisfactoriamente
SINO
mensaje = El cdigo del alumno ingresado no existe Verifique!!!
FINSI

ESCRIBIR mensaje

FIN

Conjunto de
instrucciones que
Conjunto de
instrucciones que

Pg. 173

A continuacin se muestra el desarrollo de la codificacin en lenguaje de programacin Java
del algoritmo anterior.

PrgModificarDatos main ( )


public class PrgModificarDatos {


int numAlu, pos = -1, i ;
long codigos[ ], codigo ;
String nombres[ ], mensaje ;
double notas[ ] ;

numAlu = LE.leerInt ( "Ingrese el nmero de alumnos: " ) ;

codigos = new long [numAlu] ;
notas = new double[numAlu] ;

for ( i = 0; i < numAlu; i++ ) {
codigos[i] = LE.leerLong ( "Ingrese el cdigo del alumno " + (i + 1) ) ;
nombres[i] = LE.leerString ( "Ingrese el nombre del alumno " + (i + 1) ) ;
notas[i] = LE.leerDouble ( "Ingrese la nota final del alumno " + (i + 1) ) ;
}

codigo = LE.leerLong ( "Cdigo del alumno cuyos datos desea modificar ? " ) ;

for ( i = 0; i < numAlu ; i++ ) {
if ( codigos[i] == codigo ) {
pos = i ;
break ;
}
}

if ( pos >= 0 ) {
nombres[i] = LE.leerString ( "Ingrese el nombre correcto " ) ;
notas[i] = LE.leerDouble ( "Ingrese la nota final correcta " ) ;
mensaje = "Los datos del alumno fueron modificados satisfactoriamente " ;
} else {
mensaje = "El cdigo del alumno ingresado no existe Verifique!!! " ;
}
LE.mostrarInformacion ( mensaje ) ;

}

}

En este ejemplo, se modifica el nombre y la nota de un alumno. Tambin puede hacer un men
de opciones de tal forma que el usuario pueda decidir qu datos exactamente modificar.

Pg. 174

ELIMINACIN DE DATOS

Introduccin:

La eliminacin de los datos constituye otros de los procesos comunes que debemos tener en
cuenta cuando realizamos mantenimiento a los datos almacenados en las Estructuras de
Datos.

Es comn que trabajemos con grandes cantidades de datos almacenados en estructuras de
datos y que sea necesario eliminar peridicamente ciertos datos, los cuales ya no son
necesarios. A este proceso se denomina ELIMINACIN DE DATOS y se realiza para
mantener actualizados los datos. A este proceso se denomina eliminacin de datos y se
realiza para mantener actualizados los datos. Este proceso hace uso de la bsqueda con la
finalidad de determinar si los datos que se desea eliminar estn almacenados.

Definicin:

La eliminacin de datos consiste en eliminar el valor de un dato o de un conjunto de datos
almacenados en una Estructura de Datos.

En el caso de los arreglos, la eliminacin de datos es poco usual, pero necesaria para
mantener actualizados los datos almacenados en el mismo.

Ejemplos:

En una gua telefnica electrnica se desea eliminar los datos de
las personas que han cancelado su servicio telefnico.

En una lista de alumnos y sus calificaciones se desea eliminar a
los alumnos que se han retirado del curso.

Tipos:

La eliminacin de datos se puede realizar utilizando principalmente los siguientes mtodos:

Eliminacin Lgica.
Eliminacin Fsica.


Pg. 175

Mtodo de Eliminacin Lgica de Datos

Este es el mtodo ms sencillo de eliminacin de datos y consiste en colocar una marca de
eliminacin en la posicin donde estn almacenados los datos que se desean eliminar. Para
esto, es necesario tener una estructura de datos adicional que permita almacenar las marcas
de eliminacin.

Para ilustrar la forma en que se pueden eliminar los datos en forma lgica, desarrollaremos
una explicacin en base a una solucin que permita almacenar el cdigo, el nombre y la nota
final de los alumnos de un saln de clase. Para esto utilizaremos la Grfica de Estructura de
Datos que se muestra a continuacin:

Dados los vectores:

codigos nombres notas estado
0
1
2
3
: : : :
: : : :
9999
numAlu = 0

(long) (String) (double) (int) (boolean)


Ahora, supongamos que se han ingresado los datos de 5 alumnos de un saln de clase, lo
cual se podra representar de la siguiente manera:

Dados los vectores:

codigos Nombres notas estado

0 10 JUAN 19

true

1 20 CARMEN 17

true

2 30 DANAE 15

true

3 40 RODRIGO 16

true

4 50 JOS 09

true

: : : :
: : : :
9999
numAlu = 5




Pg. 176

Observe, que cuando se almacenan los datos de un alumno, es necesario almacenar en el
vector estado[] el valor true que significa que los datos estn activos. Es decir, no estn
eliminados.

Para la eliminacin lgica de datos se necesita en primer lugar ubicar la posicin donde se
tiene almacenados los datos que se desean eliminar. Para ello, utilizaremos alguno de los
algoritmos de bsqueda de datos tratados anteriormente en este mismo captulo. En segundo
lugar, se necesita que se confirme la eliminacin y cambiar el valor almacenado en el vector
estado[] por false, lo que indica que los datos estn inactivos. Es decir, han sido eliminados.

Como ejemplo, ingresamos el cdigo 20. Buscamos el cdigo ingresado en el vector
codigos[]. El cdigo buscado es encontrado en la segunda posicin del vector codigos[].
Encontrado el cdigo se solicita la confirmacin de la eliminacin de los datos y si esta es
afirmativa se procede a cambiar el valor almacenado en la segunda posicin del vector
estado[] por el valor false (marca de eliminacin).

Cdigo buscado = 20

Dados los vectores:


0 10 JUAN 19

true

1 20 CARMEN 17

false

2 30 DANAE 15

true

3 40 RODRIGO 16

true

4 50 JOS 09

true

: : : :
: : : :
9999
numAlu = 5



Datos eliminados.
(marca de eliminacin)

La eliminacin lgica de datos permite que se conserven los datos almacenados en las
estructuras de datos, y es til cuando se necesita guardar informacin histrica como
referencia o para estadsticas. La eliminacin lgica de datos permite que pueda existir un

Pg. 177

proceso de recuperacin de datos, el cual consiste en cambiar la marca de eliminacin cuyo
valor es false por el valor true, que indicara que los datos nuevamente estn activos.

Cuando se utiliza la eliminacin lgica de datos los algoritmos relacionados con el manejo de
datos (bsqueda, ordenamiento, modificacin, etc.) deben modificarse de tal forma que slo
procesen los datos que no estn eliminados. Es decir, aquellos que no tengan el valor false
en el vector estado[ ].

Observe la siguiente grfica:

Dados los vectores:


0 10 JUAN 19

true

1 20 CARMEN 17

false

2 30 DANAE 15

false

3 40 RODRIGO 16

true

4 50 JOS 09

false

: : : :
: : : :
9999
numAlu = 5



En la grfica se especifica que se tienen almacenados los datos de 5
alumnos de un saln de clase de los cuales 3 han sido eliminados.

Si se deseara mostrar los datos de los alumnos del saln de clase,
se debera mostrar solo los datos de los alumnos Juan y Rodrigo
cuyos valores relacionados en el vector estado[ ] son true.


Pg. 178

Mtodo de Eliminacin Fsica de Datos

Este es el mtodo de eliminacin de datos utilizado en el presente libro y consiste en eliminar
los datos en forma permanente de las estructuras de datos. Para la eliminacin lgica no se
necesita un vector adicional y una vez eliminados los datos no podrn ser recuperados.

Para ilustrar la forma en que se pueden eliminar los datos en forma fsica, desarrollaremos
una explicacin en base a una solucin que permita almacenar el cdigo, el nombre y la nota
final de los alumnos de un saln de clase. Para esto utilizaremos la Grfica de Estructura de
Datos que se muestra a continuacin:

Dados los vectores:

0
1
2
3
: : :
: : :
9999
numAlu = 0



Para la eliminacin fsica de datos se necesita en primer lugar ubicar la posicin donde se
tiene almacenado los datos que se desean eliminar. Para ello, utilizaremos alguno de los
algoritmos de bsqueda de datos tratados anteriormente en este mismo captulo. En segundo
lugar, se necesita que se confirme la eliminacin. Esto, se realiza mostrando los datos
encontrados y preguntando si se est seguro de desear eliminar dichos datos. En caso que la
respuesta sea afirmativa se procede a eliminar los datos en forma permanente.

Como ejemplo, ingresamos el cdigo 20. Buscamos el cdigo ingresado en el vector
codigos[]. El cdigo buscado es encontrado en la segunda posicin del vector codigos[], se
solicita la confirmacin de la eliminacin de los datos y si esta es afirmativa se procede a
eliminar los datos en forma permanente.


Pg. 179

Cdigo buscado = 20

Dados los vectores:


0

JUAN 19

1 20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
9999
numAlu = 5



Confirmacin de la eliminacin de
datos en forma permanente

Al confirmar la eliminacin, todos los datos almacenados a partir de la siguiente posicin
donde estn los datos a eliminar, se copian y se almacenan uno a uno en la posicin
anterior:

Dados los vectores:


0 10 JUAN 19

1
20

CARMEN

17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
9999
numAlu = 5



10

Pg. 180

Es decir, ya que los datos a eliminar estn almacenados en la posicin 1, se deber copiar
los datos almacenados en la posicin 2 a la posicin 1. Luego, los datos almacenados en la
posicin 3 se debern copiar a la posicin 2 y as sucesivamente hasta llegar a los datos
almacenados en la ltima posicin vlida. Finalmente, la variable que almacena la cantidad
de datos almacenados en las estructuras (en nuestro caso numAlu), se deber reducir en una
unidad, ya que se ha eliminado los datos de un alumno. Como resultado los datos
almacenados seran los que se muestran en la siguiente grfica:

Dados los vectores:


0 10 JUAN 19

1 30 DANAE 15

2 40 RODRIGO 16

3 50 JOS 09

4 50 JOS 09

: : :
: : :
9999
numAlu = 4



Es importante indicar, que al analizar la grfica anterior se puede llegar a pensar que los
datos almacenados en las dos ltimas posiciones se repiten. Esto no es tan cierto ya que la
variable numAlu contiene el valor 4, lo que indica que slo se trabajar con los 4 primeros
registros. Todos los dems datos almacenados despus de la tercera posicin se
considerarn como datos no vlidos.


Pg. 181

El siguiente algoritmo en Pseudocdigo expresa lo descrito anteriormente.

Algoritmo PrgEliminarDatos

ENTRADA: numAlu, codigos[ ], nombres[ ], notas[ ], codigo
SALIDA: mensaje

INICIO

TEXTO nombres[ ], mensaje
NUMERO codigos[ ], notas[ ], numAlu, pos = -1, codigo, i
LEER numAlu
CREAR codigos[numAlu], nombres[numAlu], notas[numAlu]

COMENTARIO Ingresar datos a los vectores
LEER codigos[i]
LEER nombres[i]
LEER notas[i]
FINDESDE

COMENTARIO Ingreso del cdigo a buscar
LEER codigo

vector codigos[ ]

SI ( codigos[i] = codigo )
ENTONCES
pos = i
TERMINAR
FINSI
FINDESDE

SI ( pos > = 0 )
ENTONCES

DESDE i = pos HASTA i = numAlu - 2 INCREMENTA 1
codigos[i] = codigos[i+1]
nombres[i] = nombres[i+1]
notas[i] = notas[i+1]
FINDESDE
numAlu = numAlu - 1

mensaje = Los datos del alumno fueron eliminados satisfactoriamente
SINO
mensaje = El cdigo del alumno ingresado no existe Verifique!!!
FINSI
ESCRIBIR mensaje

FIN

Conjunto de
instrucciones que


Pg. 182

A continuacin se muestra el desarrollo de la codificacin en lenguaje de programacin Java
del algoritmo anterior.

PrgEliminarDatos main ( )


public class PrgEliminarDatos {


int numAlu, pos = -1, i ;
long codigos[ ], codigo ;
String nombres[ ], mensaje ;
double notas[ ] ;

numAlu = LE.leerInt ( "Ingrese el nmero de alumnos: " ) ;

codigos = new long [numAlu] ;
notas = new double[numAlu] ;

for ( i = 0; i < numAlu; i++ ) {
codigos[i] = LE.leerLong ( "Ingrese el cdigo del alumno " + (i + 1) ) ;
nombres[i] = LE.leerString ( "Ingrese el nombre del alumno " + (i + 1) ) ;
notas[i] = LE.leerDouble ( "Ingrese la nota final del alumno " + (i + 1) ) ;
}

codigo = LE.leerLong ( "Cdigo del alumno cuyos datos desea modificar ? " ) ;

for ( i = 0; i < numAlu ; i++ ) {
if ( codigos[i] == codigo ) {
pos = i ;
break ;
}
}

if ( pos >= 0 ) {
for ( i = 0; i < numAlu - 1; i++ ) {
codigos[i] = codigos[i+1] ;
nombres[i] = nombres[i+1] ;
notas[i] = notas[i+1] ;
}
numAlu = numAlu - 1 ;
mensaje = "Los datos del alumno fueron eliminados satisfactoriamente " ;
} else {
mensaje = "El cdigo del alumno ingresado no existe Verifique!!! " ;
}
LE.mostrarInformacion ( mensaje ) ;

}
}


Pg. 183

La modificacin y eliminacin de datos son procesos que necesitan utilizar otros procesos
como el ingreso de datos, la bsqueda de datos y la visualizacin de datos. Al inicio del
algoritmo desarrollado anteriormente se utiliza el ingreso de datos y la bsqueda de datos y
es posible utilizar tambin la visualizacin de datos despus de la modificacin o eliminacin
de datos para poder observar cul fue el efecto despus de ejecutar dichos procesos.

Para poder utilizar adecuadamente los diferentes procesos para el manejo de datos se
recomienda desarrollar soluciones utilizando men de opciones y mtodos para cada uno de
dichos procesos.


Pg. 184

Problema 020

Enunciado:

Desarrollar una solucin en JAVA que permita registrar los nombres, cdigos y la nota final
de los alumnos del curso de Algoritmo y Estructura de Datos I. Utilice un men de opciones,
utilice mtodos y la Grfica de Estructura de Datos mostrada.

1.- Ingresar datos.
2.- Calcular promedio.
3.- Modificar datos.
4.- Eliminacin lgica de datos.
5.- Mostrar datos
6.- Ordenar los datos de los empleados alfabeticamente.




Dados los
vectores:

nombre codigo nota estado
0
1
2
3
: : :
: : :
9999
numAlu = 0

(String) (long) (double) (boolean) (int)




Pg. 185


Clase PrgAlumnos



String nombre[ ] ;
long codigo[ ] ;
double nota[ ] ;
boolean estado[ ] ;
int numAlu ;

numAlu = 0 ;
nota = new double [9999] ;
estado = new double [9999]
}


PrgAlumnos obj = new PrgAlumnos ( ) ;
obj.menu ( ) ;
}

+" 3) Modificar Datos \n "
+" 4) Eliminacin Lgica de Datos\n "
+" 5) Mostrar Datos \n "
+" ---------------------------------------- " ;
int opc = 0 ;

do {

switch ( opc ) {
case 1:
ingresar ( ) ;
sw = true ;
break ;

case 2:
if ( sw )
calcular ( ) ;
else
break ;

Pg. 186

Clase PrgAlumnos

case 3:
if ( sw )
modificar ();
else
break ;

case 4:
if ( sw )
eliminar ();
else
break ;

case 5:
if ( sw )
mostrar ( ) ;
else
break ;

case 6:
break ;
default:
}
} while ( opc != 6 ) ;
}

int rpta = 0 ;
do {
codigo[numAlu] = LE.leerLong ( " Cdigo del alumno " + ( numAlu + 1)
+ " : " )
;
nombre[numAlu] = LE.leerString ( " Nombre del alumno " + ( numAlu +
1) + " : " ) ;
do {
nota[numAlu] = LE.leerDouble ( " Nota del alumno " + ( numAlu + 1 )
+ " : " ) ;
if ( nota[numAlu] < 0 || nota[numAlu] > 20 ) {
}
} while ( nota[numAlu] < 0 || nota[numAlu] > 20 ) ;
numAlu++ ;

estado[numAlu] =true;
} while ( rpta == 0 ) ;
}

suma += nota[i] ;


Pg. 187

Clase PrgAlumnos

}
prom = suma / numAlu ;

}

public void modificar ( ) {
long aux = 0 ;
aux = LE.leerLong( " Ingrese el codigo del alumno que desea modificar: " ) ;
codigo[i] = LE.leerLong ( " Cdigo del alumno " + ( i + 1) + " :
" ) ;
nombre[i] = LE.leerString ( " Nombre del alumno " + ( i + 1) + "
: " ) ;
do {
nota[i] = LE.leerDouble ( " Nota del alumno " + ( i + 1 ) + " :
" ) ;
if ( nota[i] < 0 || nota[i] > 20 ) {
}
} while ( nota[i] < 0 || nota[i] > 20 ) ;
break;
}
}
}

public void eliminar ( ){
long aux = 0 ;
aux = LE.leerLong( " Ingrese el codigo del alumno que desea eliminar: " ) ;
estado = false;
}
break;
}
}

if (estado[i] ==true){
total += "\n" + codigo[i] + "/" + nombre[i] + "/" + nota[i] ;
}
}
}
}


Pg. 188

Problema 021

Enunciado:

Desarrollar una solucin en JAVA que permita registrar los nombres, cantidades y precios de
los artculos de una bodega. Mostrar los datos y calcular la ganancia total en caso de vender
todos los artculos. Utilice un men de opciones, utilice mtodos y la Grfica de Estructura de
Datos mostrada.

1.- Ingresar datos.
2.- Mostrar datos.
3.- Calcular Ganancia.
4.- Modificar datos.
5.- Eliminacin Fsica de datos.

Se desea registrar los nombres, cantidades y precios de los artculos de una bodega. Mostrar
los datos y calcular la ganancia total en caso de vender todos los artculos. Utilice mtodos y
la Grfica de Estructura de Datos mostrada.




Dados los vectores:

nombre cantidad precio
0
1
2
3
: : :
: : :
9999
numArt = 0

(String) (long) (double) (int)

Donde numArt permite almacenar el nmero de artculos de una bodega.



Pg. 189


Clase PrgArticulos


public class PrgArticulos {

String nombre [ ] ;
long cantidad [ ] ;
double precio [ ] ;
int numArt ;

public PrgArticulos ( ) {
cantidad = new long [9999] ;
precio = new double [9999] ;
numArt = 0 ;
}

PrgArticulos obj = new PrgArticulos ( ) ;
obj.menu ( ) ;
}

String menu = " Ingrese una de las siguientes opciones: \n "
+ " 1) Ingresar Datos(Recomendada para iniciar) \n "
+ " 2) Mostrar Datos \n"
+ " 3) Calcular Ganancia \n "
+ " 4) Modificar Datos \n "
+ " 5) Eliminacin Fsica de Datos \n "
+ " 6) Finalizar \n "
+ " -------------------------------------------" ;
int opc;

do {
opc = LE.leerInt ( menu ) ;

switch ( opc ) {
case 1:
ingresar ( ) ;
sw = true ;
break ;

case 2:
if ( sw )
mostrar ( ) ;
else
break ;
case 3:

Pg. 190

Clase PrgArticulos
if ( sw )
calcularGanancia ( ) ;
else
break ;

case 4:
if ( sw )
modificar ( ) ;
else
break ;
case 5:
if ( sw )
eliminar ( ) ;
else
break ;
case 6:
finalizar ( ) ;
break ;
default:
}
} while ( opc != 6 ) ;
}

public void ingresar ( ) {
int rpta ;
do {
nombre[numArt] = LE.leerString ( " Nombre del producto " + ( numArt +
1 ) + " : " ) ;
cantidad[numArt] = LE.leerLong ( " Cantidad de productos " + ( numArt
+ 1 ) + " : " ) ;
precio[numArt] = LE.leerDouble ( " Precio del producto " + ( numArt + 1)
+ " : " ) ;
numArt++ ;
} while ( rpta == 0 ) ;
}


for ( int i = 0; i < numArt; i++ ) {
total += "\n" + nombre[i] + "/" + cantidad[i] + "/" + precio[i] ;
}

LE.mostrarResultado ( "Datos de articulos: " + total ) ;
}

public void calcularGanancia ( ) {
double prod, suma = 0 ;
for ( int i = 0; i < numArt; i++) {


Pg. 191

Clase PrgArticulos
prod = cantidad[i] * precio[i] ;
suma += prod ;
}

LE.mostrarResultado ( " La ganancia total al vender todos los productos
es: " + suma ) ;
}

String aux = "" ;
aux = LE.leerString( " Ingrese el nombre del articulo que desea modificar: "
);
for( int i=0; i<numArt; i++ ) {
if ( nombre[i].equalsIgnoreCase(aux) ){
nombre[i] = LE.leerString ( " Nombre del producto " + ( i + 1 )
+ " : " ) ;
cantidad[i] = LE.leerLong ( " Cantidad de productos " + ( i + 1 )
+ " : " ) ;
precio[i] = LE.leerDouble ( " Precio del producto " + ( i + 1) + "
: " ) ;
break;
}
}
}

public void eliminar ( ) {
String aux = "" ;
aux = LE.leerString( " Ingrese el nombre del articulo que desea modificar:
" );
for( int i=0; i<numArt; i++ ) {
if ( nombre[i].equalsIgnoreCase(aux) ){
nombre[i] = nombre[i+1];
cantidad[i] = cantidad[i+1];
precio[i] = precio[i+1];
numArt --;
}
break;
}
}

public void finalizar ( ) {
LE.mostrarInformacion ( " El programa ha finalizado " ) ;
}

}

Ahora, se recomienda intentar solucionar los problemas propuestos del 01
al 10, que estn planteados al final del presente captulo.


Pg. 192


MANEJO DE DATOS EN ARREGLOS (MODIFICAR TAMAO DE ARREGLO)

Introduccin:

Una deficiencia de la utilizacin de arreglos para almacenar datos es el tamao que se define
al momento de crear el arreglo. La cantidad de datos que se van a ingresar se limita a la
capacidad o tamao del arreglo. Es por ello que ahora explicaremos un mtodo que nos
permitir declarar un arreglo y posteriormente redimensionar su tamao de acuerdo a la
cantidad de datos que vayamos a ingresar en un determinado momento. Y si la cantidad de
datos que almacenan sobrepasan la capacidad del arreglo, esta ser redimensionada para
superar esta limitacin y tener una mejor solucin de un problema.

INGRESO DE DATOS UTILIZANDO DO

Introduccin:

El algoritmo para redimensionar el tamao de un arreglo se encuentra dentro del mtodo
ingresar. Ya que en el momento de realizar el ingreso, procederemos a realizar el algoritmo
que haga una llamada a un mtodo que denominaremos modificarTamaoArreglo() que
realizar el redimensionamiento del arreglo o arreglos.

Recordemos el ejemplo que utilizamos para explicar el mtodo de ingresar datos.

Dados los vectores:


0 10 JUAN 19

1 20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
10
numAlu = 10




Pg. 193

El mtodo que desarrollamos fue el siguiente:

Como ahora no sabemos la cantidad exacta de datos que se van a ingresar, eliminamos la
estructura de repeticin del FOR, y lo cambiamos por la estructura de repeticin DO,
dndole la siguiente sintaxis:

.





notas[i]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
}



// Creamos la variable que permitir seguir ingresando datos realizando
// dependiendo de la respuesta del usuario.

int rpta;

do{
// Declaramos la condicin para realizar el redimensionamiento del arreglo

if (numAlu =nombres.length ){
// Se ejecuta el mtodo para aumentar el tamao del arreglo.
aumentarTamaoArreglo( );
}

codigos[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );

nombres[numAlu]=LE.leerString ( Ingrese el nombre del alumno: + (i+1) );

notas[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
}
numAlu++;

rpta =LE.mostrarPreguntaOpcion2 (Desea aadir ms registros ?
SI = 0 NO=1] );
} while (rpta ==0);



Pg. 194

Como vemos en el cuadro anterior, el mtodo ha cambiado considerablemente. Primero se
declara una variable rpta que permite determinar si se continua ingresando los datos o no.
El proceso se hace repetitivo previa pregunta de si se desea aadir otro registro.

El programa finalizar cuando un usuario ingrese en todo caso el nmero 0. Que es el valor
que se ha configurado en la estructura de repeticin DO. Otra forma de configurar el
mtodo con la estructura de repeticin DO sera la siguiente:

E

En la solucin tambin vemos que se ejecuta el mtodo aumentarTamaoArreglo()
verificando primero que la cantidad de alumnos que se han ingresado hasta el momento,
sean iguales a la cantidad mxima de registros permitidos del arreglo. En caso que sea
verdadero se ejecuta el mtodo de aumentarTamaoArreglo() para poder continuar
almacenando datos.

En las siguiente pgina veremos detenidamente el mtodo aumentar tamao del arreglo.

public void ingresarDatos () {

// Creamos la variable que permitir seguir ingresando datos realizando
// dependiendo de la respuesta del usuario.

int rpta;

do{
// Declaramos la condicin para realizar el redimensionamiento del arreglo

if (numAlu =nombres.length ){
// Se ejecuta el mtodo para aumentar el tamao del arreglo.
aumentarTamaoArreglo( );
}

codigos[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );

nombres[numAlu]=LE.leerString ( Ingrese el nombre del alumno: + (i+1) );

notas[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
}
numAlu++;

rpta =LE.mostrarPreguntaOpcion2 (Desea aadir ms registros ?
SI = 0 NO=1] );
} while (rpta ==0);



Pg. 195

AUMENTO DEL TAMAO DEL ARREGLO.

Introduccin:

Como ya se ha mencionado, el mtodo aumentar tamao del arreglo permitir
cambiar el tamao del arreglo para que se puedan registrar muchos ms datos.

El algoritmo se basa en los siguientes pasos:

1. Crear arreglos temporales, del mismo tipo del arreglo que se va a
redimensionar.
2. Los arreglos temporales deben ser creados con un tamao mayor que al de
los arreglos que van a ser redimensionados.
3. Definir una estructura de repeticin que recorra todas las filas de los
arreglos que sern redimensionados.
4. Pasar los datos de los arreglos que sern redimensionados, a los arreglos
temporales que han sido creados.
5. Pasar los datos de los arreglos temporales, a los arreglos reales igualando
las variables. Y finalmente este nuevo arreglo quedar redimensionado con
ms filas producto del proceso.

El desarrollo del mtodo aumentarTamaoArreglo( ) se muestra a continuacin.

.

A continuacin proponemos desarrollar el mtodo reducir tamao del
arreglo que permitir reducir el tamao de los arreglos de acuerdo a la
cantidad de registros almacenados.

public void aumentarTamaoArreglo () {
// Creamos los arreglos temporales del mismo tipo que los arreglos reales.
long codigotempora= new Long[codigos.length + 10] ;
String nombretempora [ ]= new String [codigos.length + 10l;
double notastempora [ ] = new double[codigos.length + 10l;
// Crear estructura de repeticin y pasar los archivos del arreglo real al temporal.
for ( int i = 0; i < numChar; i++ ) {
codigotemporal[i] =codigos [i]] ;
nombretemporal[i] = nombres [i];
notastemporal [i]= notas [i];
}
// Filamente hacemos que el arreglo original sea igual al arreglo temporal
// heredando asi su nuevo tamao y manteniendo los datos.
codigos = codigotemporal ;
nombres = nombretemporal ;
notas = notastemporal ;
}// Fin del mtodo aumentarTamaoArreglo

Pg. 196

INSERCIN DE DATOS

Introduccin:

La insercin de datos se refiere a ingresar un dato en el lugar correcto. Dicho lugar, se refiere
a la posicin donde le corresponde al dato ser insertado.

A diferencia del mtodo ingresar datos, este mtodo refiere una condicin determinada que
se va a evaluar antes de realizar el ingreso de datos. Esta condicin se establece para
mejorar el orden determinado de ingresos, ordenando automticamente los arreglos
dependiendo del dato a ingresar en la posicin correcta.

Los pasos que se tienen que realizar para utilizar correctamente el mtodo son:

1. Ubicar la posicin donde debera insertar los datos a ingresar.
2. Trasladar todos los datos desde la posicin determinada hacia una posicin abajo.
3. Finalmente insertar los datos.

Del ejemplo que hemos utilizado vamos a proceder a realizar la insercin correspondiente.

Dados los vectores:


0 10 JUAN 19

1 20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
10
numAlu = 10



Si por ejemplo tenemos que insertar un nuevo registro donde los datos son:

25 LUIS 14


Pg. 197

Entonces podemos seguir los pasos definido los cuales se muestran a continuacin:

1. Ubicar la posicin donde debera insertarse los datos ingresados.

Por ejemplo, si el cdigo a ingresar es 25, entonces deberamos insertar los datos entre los
cdigos 20 y 30, es decir en la posicin 2 teniendo en consideracin que los datos a partir de
esa posicin deben ser trasladados una posicin hacia abajo para no perder datos.

2. Trasladar todos los datos desde la posicin determinada una posicin abajo.

Dados los vectores:


0 10 JUAN 19

1 20 CARMEN 17

2 30 DANAE 15

3 40 RODRIGO 16

4 50 JOS 09

: : :
: : :
10
numAlu = 10



Dados los vectores:


0 10 JUAN 19

1 20 CARMEN 17

2

3
.
30
DANAE 15

4 40 RODRIGO 16

.

50

.
JOS

.
09

10
:
:

:
:
:
:

numAlu = 10


codigos: 25
nombres: Luis
notas: 14


Pg. 198

3. Insertar los Datos

Para que nuestro mtodo funcione correctamente tenemos que desarrollar un mtodo
llamado posicionCodigo() que permita recibir como parmetro el cdigo. De esta forma,
podremos ubicar la posicin en donde se deber realizar la insercin de datos.

Dados los vectores:


0 10 JUAN 19

1 20 CARMEN 17

2 25 LUIS 14

3
.
30
DANAE 15

4 40 RODRIGO 16

.

50

.
JOS

.
09

5

10
:
:

:
:
:
:

numAlu = 10


Datos ingresados
correctamente.

public void posicionCodigo (long cod ) {

for ( int i = 0 ; i<=numAlu ; i++- ){
if (cod<codigos)[i]){
return i;
}
}
return numAlu;
}

Pg. 199

Finalmente procedemos a desarrollar el mtodo para insertar datos.

C

.

public void insertarDatos () {

// Declaramos las variables temporales..
into pc, pos;
long cod;
String nom;
double nota;

do {

// Declaramos la condicin de aumentar tamao de arreglo .
if( codigos.length == numAlu);{
aumentarTamaoArreglo();
}

// Asignamos los valores a las variables temporales.
cod=LE.leerLong( Ingrese el cdigo del alumno: );
nom=LE.leerString( Ingrese los nombres del alumno: );
nota=LE.leerDouble( ingrese la nota del alumno: );

// Buscamos la adecuada para realizar la insercin de datos.

pos= posicionCodigo(cod);

// Declaramos la estructura de repeticin para pasar los valores una
posicin abajo.
for ( int i = numAlu -1 ; i >= pos ; i-- ){
codigos[i+1]=codigos[i]
nombres[i+1]= nombres [i]
notas[i+1]= notas [i]
}

// Insertamos los datos temporales a los arreglos en la posicin adecuada.
codigo[pos]=cod;
nombres[pos]=nom;
notas[pos]=nota;

numAlu++;

rpta=LE.mostrarPreguntaOpcion2( Desea aadir otro registro? );

}while( rpta ==0 );
}


Pg. 200

VISUALIZACIN DE DATOS

Introduccin:

Una alternativa para la visualizacin de datos est referida al uso de clases o componentes
propios de las Interfaz Grfica de Usuario GUI. Aunque este tema ser tratado en captulos
posteriores resulta importante poder tener una opcin a la visualizacin de datos
convencionales.

Analice las siguientes lneas de cdigo Java:

Mtodo visualizar
..
public void visualizar ( ) {

String informacion = " CODIGO"+ "\t" + " NOMBRES " + "\t" + " APELLIDOS"
+ "\t" + qq"NOTAS" + "\n" ;

informacion + = " -----------------------------------------------------------------------------
------- ---------------\n" ;
JTextArea muestraInformacion = new JTextArea( 10, 30 ) ;
JScrollPane desplazaInformacion = new JScrollPane( muestraInformacion ) ;

informacion +=datos[i][2] + "\t" + datos[i][0] + "\t" + datos[i][1] + "\t" +
notas[i] + "\n" ;
}

muestraInformacion.append ( informacion ) ;
JOptionPane.showMessageDialog( null, desplazaInformacion, "LISTA DEL
SALN",
JOptionPane.INFORMATION_MESSAGE ) ;
}

Observe cmo se crean objetos de las clases componentes y cmo estos se van configurando de
modo que se pueda mostrar la informacin de una mejor forma. Esto incluye una barra de
desplazamiento en caso la informacin a mostrar sea de un tamao considerable. Para entender
mejor este punto le sugerimos revisar los siguientes captulos aunque este mtodo se utiliza en
algunos de los siguientes problemas.

A continuacin, se presentan 12 problemas con sus respectivas soluciones,
que permitirn que usted pueda comprender mejor cada uno de los temas
tratados en el presente captulo. Se recomienda el estudio de cada uno de
ellos en el orden que son presentados, ya que conforme se avanza con el
estudio de cada una de las soluciones se van implementando mejoras
significativas en la codificacin de las soluciones.

Pg. 201

Problema 022

Enunciado:
Se desea registrar los cdigos, nombres y el promedio final de los alumnos del curso de
Algoritmo y Estructura de Datos I, y determinar cul es el porcentaje de alumnos aprobados y
desaprobados. Adicionalmente determinar quin es el alumno que ha obtenido la mayor nota.
Utilice la Grfica de Estructuras de Datos mostrada.

Dados los vectores:

nombre codigo promedio
0
1
2
3
: : :
: : :
9999
numAlu = 0




Clase PrgAlumnos
..



String nombre[ ];
long codigo[ ];
double promedio[ ];
int numAlu;

public static void main (String[ ] args) {
PrgAlumnos x = new PrgAlumnos ( );
x.menu ( );
}

nombre = new String[9999];
codigo = new long[9999];

Pg. 202

Clase PrgAlumnos
promedio = new double[9999];
numAlu = 0;
}

String menu = "Curso de Algoritmo y Estructura de Datos I\n"
+ "---------------------------------------------------------\n"
+ "1) Ingreso de datos de los alumnos\n"
+ "2) Mostrar datos de los alumnos\n"
+ "3) Porcentaje de alumnos aprobados\n"
+ "4) Porcentaje de alumnos desaprobados\n"
+ "5) Alumnos con el mayor promedio\n"
+ "6) Finalizar\n"
+ "---------------------------------------------------------\n"
+ "Ingrese una opcin: \n";

int opc;
do {
opc = LE.leerInt(menu);
switch (opc) {
case 1 :
ingresar ( );
break;
case 2 :
mostrar ( );
break;
case 3:
porcentajeAprobados ( );
break;
case 4:
porcentajeDesaprobados ( );
break;
case 5:
alumnosConMayorNota ( );
break;
case 6:
finalizar ( );
break;
default:
LE.mostrarError ("Error...Opcin desconocida");
}
} while (opc != 6);
}

int rpta;
do {
nombre[numAlu] = LE.leerString ("Ingrese el nombre del alumno " + (numAlu +
"" 1));
codigo[numAlu] = LE.leerLong ("Ingrese el cdigo del alumno " + (numAlu + 1));
do {
promedio[numAlu] = LE.leerDouble ("Ingrese el promedio del alumno " +
"" (numAlu + 1));

Pg. 203

Clase PrgAlumnos
if (promedio[numAlu] < 0 || promedio[numAlu] > 20) {
LE.mostrarError ("Promedio invlido, reingrese el promedio");
}
} while ( promedio[numAlu] < 0 || promedio[numAlu] > 20 );

numAlu++;
rpta = LE.mostrarPreguntaOpcion2 ( "Desea continuar?" );
}
while (rpta == 0);
}

String da String datos = "Los datos de los alumnos son los siguientes:\n" +
"" "nombre/codigo/promedio\n\n";

datos += (i+1) + " "
+ nombre[i]
+ "/"
+ codigo[i]
+ "/"
+ promedio[i]
+ "\n";
}
LE.mostrarInformacion (datos + "\n");
}

public void porcentajeAprobados ( ) {
double porApro = 0;
int cont=0;

if (promedio[i] >= 10.5) {
cont++;
}
}
porApro = (cont * 100) / numAlu;
porApro = Math.round(porApro * 100) / 100.0;
LE.mostrarResultado("Alumnos aprobados: " + porApro + "%");

}

public void porcentajeDesaprobados ( ) {

double porDesapro = 0;
int cont=0;
if (promedio[i] <= 10.5) {
cont++;
}
}

Pg. 204

Clase PrgAlumnos

porDesapro = (cont * 100) / numAlu;
porDesapro = Math.round(porDesapro * 100) / 100.0;
LE.mostrarResultado("Alumnos desaprobados: " + porDesapro + "%");
}

public void alumnosConMayorNota ( ) {
double mayor=0;
for(int i=0;i<numAlu;i++){
if(promedio[i]>=mayor){
mayor=promedio[i];
}
}
String texto="El promedio mas alto es " + mayor ;
texto += "\nAlumnos que han obtenido dicho promedio:\n\n" +
"" "codigo/nombre\n...\n" ;
for(int i=0;i<numAlu;i++) {
if(promedio[i]==mayor) {
texto += codigo[i]+ "/" + nombre[i] + "\n" ;
}
}
LE.mostrarInformacion (texto + "...\n") ;
}

LE.mostrarInformacion ("Usted ha finalizado el programa") ;
}

}

Comentarios con relacin a la solucin planteada

Al ejecutar la solucin planteada para el problema puede observar lo siguiente:

1 Se tiene una capacidad mxima de almacenamiento de datos de 10000. Esto
significa que no se podran almacenar los datos de 10001 alumnos. Aunque resulta
improbable que en un saln de clase pueda haber esa cantidad de alumnos.

2 No se ha incluido una validacin, de tal forma que no se permita el ingreso de un
cdigo de alumno repetido.

3 Es posible ingresar a cualquier opcin del men antes de ingresar los datos de los
alumnos. Si se ingresa a la opcin 3 o a la opcin 4 el programa finaliza. Analice esta
situacin. En el men planteado en la solucin del siguiente problema se resuelve
esta situacin.


Pg. 205

4 El mtodo alumnosConMayorNota ( ) permite calcular el promedio ms alto de notas
y luego determina y muestra los nombres de los alumnos que han obtenido el mayor
promedio. Con la finalidad de contribuir al reuso del cdigo fuente, se debera crear
un mtodo que permita calcular el promedio ms alto de notas y el mtodo
alumnosConMayorNota ( ) debera utilizar dicho mtodo. Analice la codificacin de
esta situacin.

Mtodo alumnosConMayorNota
..

public void alumnosConMayorNota ( ) {
double mayor = mayorNota ( );
String texto = "El promedio ms alto en el curso es " + mayor
+ "\nAlumnos que han obtenido dicho promedio:\n\n" +
"" "codigo/nombre\n...\n";
if(promedios[i]==mayor){
texto += codigos[i]+ "/" + nombres[i] + "\n";
}
}
LE.mostrarInformacion (texto + "...\n");
}

public double mayorNota ( ) {
double mayor = mayorNota ( );
if(promedios[i]>=mayor){
mayor=promedios[i];
}
}
return mayor;
}


Pg. 206

Problema 023

Enunciado:
La Librera Boligrafito S.A., ubicada cerca de la FIA, vende diversos artculos de oficina.
Desarrolle una aplicacin para determinar la ganancia por cada artculo si se vendiera todo lo
que se tiene en el almacn. Mostrar los artculos ordenados por la cantidad de artculos.

Dados los arreglos:

nombres cantidad precios

PV (0) PC (1)

0
1
2
3
: : :
: : :
9999
numArt = 0

(String) (lint) (double) (double) (int)

Donde: numArt permite almacenar el nmero de artculos.


Clase PrgLibreria
..


public class PrgLibreria {

String nombres[ ];
int cantidad[ ], numArt;
double precios[ ][ ];

PrgLibreria x = new PrgLibreria ( );
x.menu ( );
}

public PrgLibreria ( ) {
numArt = 0;
nombres = new String[9999];
cantidad = new int[9999];

Pg. 207

Clase PrgLibreria
..
precios = new double[9999][2];
}

public void men ( ) {
String menu = "Librera Boligrafito S.A.\n"
+ "-----------------------------------------------------\n"
+ "1) Ingreso de datos de los artculos\n"
+ "2) Mostrar datos de los artculos\n"
+ "3) Calculo de la utilidad al vender todo\n"
+ "4) Ordenar por cantidad de artculos\n"
+ "5) Finalizar\n"
+ "-----------------------------------------------------\n"
+ "Ingrese una opcin: \n";

int opc;
boolean sw=false;
do {
switch(opc){
case 1:
ingresar ( );
sw=true;
break;
case 2:
if(sw){
mostrar ( );
}else{
LE.mostrarError ( "Ingrese primero la opcin 1" );
}
break;
case 3:
if(sw){
utilidadObtenida ( );
}else{
LE.mostrarError ( "Ingrese primero la opcin 1" );
}
break;
case 4:
if(sw){
ordenar ( );
mostrar ( );
}else{
LE.mostrarError ("Ingrese primero la opcin 1" );
}
break;
case 5:
finalizar ( );
break;
default:
LE.mostrarError ( "Opcin invlida" );
}
} while (opc != 5);
}


Pg. 208

Clase PrgLibreria
..

int rpta;
do {
nombres[numArt] = LE.leerString ("Ingrese el nombre del artculo " + (numArt +
"" 1));
cantidad[numArt] = LE.leerInt ("Ingrese la cantidad del artculo " + (numArt + 1));
precios[numArt][0] = LE.leerDouble ("Ingrese el precio de venta del artculo " +
xxxxxx(numArt + 1));
precios[numArt][1] = LE.leerDouble ("Ingrese el precio de compra del artculo " +
ddddd(numArt + 1));
numArt++;
rpta = LE.mostrarPreguntaOpcion2 ("Desea continuar?");
} while (rpta == 0);
}

public void utilidadObtenida ( ) {
String datosVenta = "";
double utilidad=0;
for (int i = 0; i < numArt; i++) {
utilidad = (precios[i][0] - precios[i][1]) * cantidad[i];
utilidad=Math.round(utilidad*100)/100.0;
datosVenta += "\n"
+ "La utilidad al vender todo el stock del producto "
+ nombres[i]
+ " es de : "
+ utilidad;
}
LE.mostrarResultado("El resultado de la venta general es: " + datosVenta);
}

public void ordenar ( ) {
int temp1;
String temp;
double temp2,temp3;
for (int i = 0; i < numArt - 1; i++) {
for (int j = i + 1; j < numArt; j++) {
if (cantidad[i] >= cantidad[j]) {
temp1 = cantidad[i];
cantidad[i] = cantidad[j];
cantidad[j] = temp1;

temp = nombres[i];
nombres[i] = nombres[j];
nombres[j] = temp;

temp2 = precios[i][0];
precios[i][0] = precios[j][0];
precios[j][0] = temp2;

temp3 = precios[i][1];
precios[i][1] = precios[j][1];
precios[j][1] = temp3;

Pg. 209

Clase PrgLibreria
..
}
}
}
}

String datos = "Los datos de los artculos son los siguientes:\n" ;
datos += "nombre/cantidad/precioVenta/precioCompra\n\n";

for (int i = 0; i < numArt; i++) {
datos += (i+1) + " "
+ nombres[i]
+ "/"
+ cantidad[i]
+ "/"
+ precios[i][0]
+ "/"
+ precios[i][1]
+ "\n";
}
LE.mostrarInformacion (datos + "\n");
}

LE.mostrarInformacion ("Usted ha finalizado el programa");
}
}



significa que no se podran almacenar los datos de 10001 artculos. Aunque resulta
improbable que se necesiten almacenar tal cantidad de datos y si fuera el caso, se
utilizara otra estrategia de solucin.

cdigo de artculo repetido.

3 El mtodo utilidadObtenida ( ) permite calcular y mostrar la utilidad obtenida por cada
artculo si se vendiera todo el stock (cantidad de artculos). Observe que no se
muestra la utilidad total y que existe la posibilidad que la utilidad de un artculo pueda
ser negativa. Esto se debe a que no se ha validado que el precio de compra no sea
mayor al precio de venta. Mejore esta solucin teniendo en cuenta este punto.

Pg. 210

Problema 024

Enunciado:
Cinco estudiantes del curso se fueron de paseo a Paracas. Ah se alojaron en la posada Don
Alfonso que se encuentra cerca de Pisco. El administrador de la posada al enterarse que los
estudiantes eran alumnos de la FIA les solicit que le desarrollen un programa de
computadora que le ayudara a controlar si las habitaciones estaban ocupadas o no, y cunto
era su ganancia por el alquiler de las habitaciones. A cambio del programa el administrador
les realizara un excelente descuento. La delegada del curso sugiri desarrollar una aplicacin
que manejar los datos de la posada, utilizando la Grfica de Estructuras de Datos mostrada.

Dada la matriz:

datosHotel

NH (0) VA (1) EH (2) NA (3)

0
1
2
3
: : :
: : :
9999
numHab = 0

(int) (int)

Donde: numHab permite almacenar el nmero de habitaciones de la
posada.

NH = Nmero de la habitacin.
VA = Valor del alquiler.
EH = Estado de la habitacin (1=ocupado, 2=desocupado).
NA = Nmero de veces alquilado.


Clase PrgPosada
..


public class PrgPosada {

int datosPosada[ ][ ], numHab ;

public PrgPosada ( ) {
datosPosada = new int[9999][4] ;
numHab = 0 ;

Pg. 211

Clase PrgPosada
..
}

PrgPosada x= new PrgPosada ( ) ;
x.menu ( ) ;
}

public void menu ( ){
String texto = "Posada \"Don Alfonso\"\n"
+ "...\n"
+ "[1] Ingreso de datos de las habitaciones\n"
+ "[2] Mostrar datos de las habitaciones\n"
+ "...\n"
+ "[3] Indicar el estado de una habitacin\n"
+ "[4] Alquilar habitaciones\n"
+ "[5] Desocupar habitaciones\n"
+ "[6] Calcular la ganancia\n"
+ "...\n"
+ "[7] Ordenar segn nmero de habitacin\n"
+ "[8] Modificar segn nmero de habitacin\n"
+ "[9] Eliminar segn nmero de habitacin\n"
+ "...\n"
+ "[0] Finalizar\n"
+ "...\n"
+ "Ingrese su opcin:";

int opc=0, numCuarto, pos=-1;
int sw =1;

do {
opc = LE.leerInt(texto);;
switch(opc){
case 1:
ingresarDatos ( );
sw=2;
break;
case 2:
if(sw ==1){
LE.mostrarError ("Ingrese los datos");
break;
}
visualizarDatos ( );
break;
case 3:
if(sw ==1){
break;
}
do{

numCuarto = LE.leerInt ("Ingrese el nmero de habitacin que desea
"" buscar");
pos = buscar (numCuarto);

Pg. 212

Clase PrgPosada
..

if(pos==-1){
LE.mostrarInformacion ("El nmero de habitacin no existe, vuelta a
xxxxxxxxxxxx xingresar!!!");
}
}while(pos==-1);

indicarEstado(pos);
break;

case 4:
if(sw ==1){
break;
}
numCuarto = LE.leerInt("Ingrese el nmero de habitacin que desea
"" alquilar");
alquilar(pos);
break;
case 5:
if(sw ==1){
break;
}
numCuarto = LE.leerInt ("Ingrese el nmero de habitacin que desea
"" desocupar");
desocupar(pos);
break;
case 6:
if(sw ==1){
break;
}
calcularGanancia ( );
break;
case 7 :
if(sw ==1){
break;
}
ordenar ( );
break;
case 8 :
if(sw ==1){
break;
}
numCuarto = LE.leerInt ("Ingrese el nmero de la habitacin");
modificar(pos);
break;
case 9 :
if(sw ==1){

Pg. 213

Clase PrgPosada
..
break;
}
numCuarto =LE.leerInt ("Ingrese el nmero de la habitacin");
eliminar(pos);
break;
case 0:
finalizar ( );
break;
default:
LE.mostrarError ("Ingrese una opcin vlida");
}
} while(opc!=0);
}

public void ingresarDatos ( ){
int rpta;
do {
datosPosada[numHab][0]=LE.leerInt ( "Ingrese el nmero de la habitacin" );
datosPosada[numHab][1]=LE.leerInt ( "Ingrese el valor de alquiler" );
datosPosada[numHab][2]=2;
datosPosada[numHab][3]=0;
numHab++;
rpta = LE.mostrarPreguntaOpcion2( "Desea continuar?" );
}

public void visualizarDatos ( ){
String texto="", estado="";
for (int i=0; i< numHab; i++){
if(datosPosada[i][2]==1){
estado = "ocupada";
}else{
estado = "desocupada";
}

texto+="La habitacin "+datosPosada[i][0]+" cuesta "+datosPosada[i][1]+"
"" soles\n"
+ "Se encuentra "+estado+" y ha sido alquilada "+datosPosada[i][3] + "
"" veces\n";
}
LE.mostrarInformacion (texto);
}

public void indicarEstado ( int p ){
if(datosPosada[p][2]==1){
LE.mostrarAdvertencia ( "La habitacin est ocupada" );
}else {
LE.mostrarAdvertencia ( "La habitacin est desocupada" );
}
}

Pg. 214

Clase PrgPosada
..

public void alquilar ( int p ){
if ( LE.mostrarPreguntaOpcion2( "La habitacin "+ datosPosada[p][0] + " cuesta "
"" + datosPosada[p][1]+" soles." +"\nDesea
"" alquilarla?" )==0 ) {
datosPosada[p][2]=1;
datosPosada[p][3]++;
LE.mostrarAdvertencia ( "Alquiler exitoso, gracias" );
}
} else {
LE.mostrarError ( "La habitacin est en uso" );
}
}

public void desocupar ( int p ){
datosPosada[p][2]=2;
LE.mostrarAdvertencia ( "La habitacin ha sido desocupada" );
}else{
LE.mostrarError ( "La habitacin estaba desocupada" );
}
}

public void calcularGanancia ( ){
String texto ="Ganancia por concepto de alquiler de habitaciones\n...\n";
double total = 0;
for(int i=0;i <numHab ;i++){
texto += "La habitacin "+datosPosada[i][0] +" ha tenido una ganancia de "
+ datosPosada[i][1]*datosPosada[i][3]+" soles\n";
total = total + datosPosada[i][1]*datosPosada[i][3];
}
texto = texto + "...\nLa Ganancia total es: " + total;
}

int temp, temp1, temp2, temp3;
for (int i = 0; i < numHab - 1; i++) {
for (int j = i + 1; j < numHab; j++) {
if (datosPosada[i][0] >= datosPosada[j][0]) {

temp = datosPosada[i][0];
datosPosada[i][0] = datosPosada[j][0];
datosPosada[j][0] = temp;
temp1 = datosPosada[i][1];
datosPosada[j][1] = temp1;

Pg. 215

Clase PrgPosada
..
}
}
}
}

public void modificar ( int pos ) {
if (pos != -1) {
int rpta =LE.mostrarPreguntaOpcion2("Desea modificar el precio?");
if (rpta == 0) {
datosPosada[pos][1] = LE.leerInt("Ingrese el nuevo costo de alquiler");
}
} else {
LE.mostrarError ("Habitacin no encontrada");
}
}

public int buscar ( int dato ) {
int pos=-1;
for (int i = 0; i < numHab; i++) {
if (datosPosada[i][0] == dato) {
pos = i;
break;
}
}
return pos;
}

public void eliminar ( int pos ) {
if (pos != -1) {
int rpta =LE.mostrarPreguntaOpcion2("Desea eliminar los datos?");
if (rpta == 0) {
for (int i = pos; i < numHab - 1; i++) {
datosPosada[i][0] = datosPosada[i + 1][0];
}
numHab--;
}
} else {
LE.mostrarError ( "Habitacin no encontrada" );
}
}

LE.mostrarInformacion ("Usted ha finalizado el programa");
}
}

Pg. 216



significa que no se podran almacenar los datos de 10001 habitaciones. Aunque
resulta improbable que en una posada existen tal cantidad de habitaciones. Esta
situacin se resuelve en la solucin del siguiente problema.

nmero de habitacin repetido. Esta situacin afecta cuando se implementan los
mtodos de manejo de datos, ya que estos siempre manipulan el primer nmero de
habitacin encontrado.

3 En esta solucin se incluye en el men 9 opciones para el manejo de datos. La
opcin 1 y 2 permiten ingresar y mostrar los datos en forma bsica. La opcin 3, 4, 5
y 6 estn relacionadas con el manejo de las habitaciones, es decir; el alquiler y la
devolucin de habitaciones, que son la razn de ser del negocio. La opcin 7 permite
ordenar los datos de tal forma que stos puedan ser mostrados en forma adecuada.
Finalmente, en las opciones 8 y 9 se implementan los mtodos para el
mantenimiento de datos. Es decir; los mtodos de eliminacin y modificacin de los
datos ingresando.

En resumen, para manejar datos adecuadamente debe proporcionar opciones
que permitan:

1.- Ingresar datos Operaciones tipo INSERT.

2.- Consultar datos.. Operaciones tipo SELECT.

3.- Ordenar datos. Operaciones tipo SORT.

4.- Modificar datos Operaciones tipo UPDATE.

5.- Eliminar datos. Operaciones tipo DELETE.

6.- Otros clculos propios de cada situacin Operaciones tipo CLCULO.


Pg. 217

Problema 025

Enunciado:
El alumno Torres tiene ms de 1000 cintas de video con pelculas de accin, drama,
suspenso y comedia. Torres decide alquilar sus cintas de video a un bajo costo. Para ello,
copi las mejores cintas de video que posea y desarroll un programa de computadora para
mantener un adecuado control del alquiler de las cintas de video y sus respectivas copias.
Para el desarrollo del programa de computadora determin que era necesario utilizar la
Grfica de Estructuras de Datos mostrada. Desarrolle una solucin utilizando un men de
opciones.

Dadas las matrices:

peliculas alquileres
nom (0) cod (1) cos (0) sto (1) alq (2) tot (3)
0 0
1 1
2 2
3 3
: : : : : :
: : : : : :
numPel = 0
9 9 (int)

(String) (double)

Donde: numPel permite almacenar el nmero de videos / pelculas que tiene el alumno.

nom= Nombre de la pelcula.

cod = Cdigo de la pelcula.

cos = Costo del alquiler de la pelcula.

sto = Nmero de cintas de video por pelcula.

alq = Nmero de cintas que en un determinado momento estn alquiladas.
tot = Nmero total de veces que se ha alquilado un video.


Clase PrgVideos
..


public class PrgVideos {

String peliculas[ ][ ] ;

Pg. 218

Clase PrgVideos
..
int alquileres[ ][ ] ;
int numPel ;

public PrgVideos ( ) {
peliculas = new String[10][2];
alquileres = new int[10][4];
numPel = 0;
}

PrgVideos x = new PrgVideos ( );
x.menu ( );
}

int opc, sw = 1;
String menu = "---Ingrese una de las opciones---\n"
+ "-----------------------------------\n"
+ "[1] Ingresar datos\n" + "[2] Mostrar datos\n"
+ "[3] alquileres de videos\n" + "[4] Devolucin de videos\n"
+ "[5] Calcular utilidad total\n" + "[6] Pelcula ms pedida\n"
+ "[0] Finalizar\n" + "------------------------------------";
do {
switch (opc) {
case 1:
ingresar ( );
sw = 2;
break;
case 2:
if (sw == 1) {
LE.mostrarError ( "Error... Ingrese primero los datos" ) ;
}else{
mostrar ( );
}
break;
case 3:
if (sw == 1) {
}else{
alquiler ( );
}
break;
case 4:
if (sw == 1) {
}else{
devolucion ( );
}
break;
case 5:
if (sw == 1) {
LE.mostrarError ("Error... Ingrese primero los datos");

Pg. 219

Clase PrgVideos
..
}else{
utilidadTotal ( );
}
break;
case 6:
if (sw == 1) {
LE.mostrarError ("Error... Ingrese primero los datos");
}else{
masPedida ( );
}
break;
case 0:
finalizar ( );
break;
}
} while (opc != 0);
}

String texto;
int rpta;
do {
if (numPel == peliculas.length) {
aumentar ( );
}
peliculas[numPel][0] = LE.leerString ("Ingrese nombre de la pelcula "
+ (numPel + 1));
peliculas[numPel][1] = LE.leerString ("Ingrese el cdigo de la pelcula "
+ peliculas[numPel][0]);
texto = "Cdigo de la pelcula: " + peliculas[numPel][0] + "\n";
texto += "Nombre de la pelcula: " + peliculas[numPel][1] + "\n";
alquileres[numPel][0] = LE.leerInt (texto + "Ingrese el costo de alquileres" ) ;
alquileres[numPel][1] = LE.leerInt (texto + "Ingrese la cantidad de copias" ) ;
alquileres[numPel][2] = 0;
alquileres[numPel][3] = 0;
numPel++;
rpta = LE.mostrarPreguntaOpcion2 ("Desea ingresar datos de otro video?" ) ;
}

public void aumentar ( ) {
String pel[][] = new String[peliculas.length + 5][2];
int alq[][] = new int[peliculas.length + 5][4];
for (int i = 0; i < numPel; i++) {
pel[i][0] = peliculas[i][0];
pel[i][1] = peliculas[i][1];
alq[i][0] = alquileres[i][0];
}
peliculas = pel;
alquileres = alq;
}

Pg. 220

Clase PrgVideos
..

String datos = "Datos de Pelculas\n";
datos += "Nombre / Cdigo / Precio / Stock / Alquiladas\n\n";
datos += peliculas[i][0] + " \t " + peliculas[i][1] + " \t " + alquileres[i][0] + " \t "
+ alquileres[i][1] + " \t " + alquileres[i][2]+"\n";
}
LE.mostrarInformacion (datos);
}

public void alquiler ( ) {
int solicitadas, disponibles, opc;
String texto;
String codigo = LE.leerString ("Ingrese el cdigo de la pelcula que desea alquilar");
int pos = buscarCodigo(codigo);

if (pos != -1) {
if(alquileres[pos][1] - alquileres[pos][2] == 0){
LE.mostrarInformacion ("En este momento todas las copias estan
alquiladas");
}else{
solicitadas = LE.leerInt("Cuntas copias desea alquilar?");
disponibles = alquileres[pos][1] - alquileres[pos][2];
if(solicitadas > disponibles){
LE.mostrarError ("No se cuenta con la cantidad solicitada");
} else {
texto = "Pelcula: " + peliculas[pos][0] + ".\n";
texto += "Cdigo: " + peliculas[pos][1] + ".\n";
texto += "Total de copias solicitadas: " + solicitadas + ".\n";
texto += "El monto total a pagar por las copias es de ";
texto += (solicitadas * alquileres[pos][0]) + " soles.\n\n";
texto += "Desea realizar el alquiler?";
opc = LE.mostrarPreguntaOpcion2(texto);
if (opc==0) {
alquileres[pos][2] += solicitadas;
alquileres[pos][3] += solicitadas;
texto = "Se ha alquilado " + solicitadas + " video(s) a un costo de ";
texto += (solicitadas * alquileres[pos][0]) + " soles.\n";;
}
}
}
} else {
LE.mostrarError ("Cdigo de la pelcula no existe!!!");
}
}

public int buscarCodigo ( String cod ) {
if (peliculas[i][1].equalsIgnoreCase(cod)) {
return i;

Pg. 221

Clase PrgVideos
..
}
}
return -1;
}

public void devolucion ( ) {
int devueltas, total;
String texto;
String codigo = LE.leerString ("Ingrese cdigo de la pelcula que desea devolver");
int pos = buscarCodigo(codigo);

if (pos != -1) {
devueltas=LE.leerInt("Cuntos copias de la pelcula va a devolver?");
total = alquileres[pos][2] - devueltas;
if(total < 0){
LE.mostrarError ("No se puede devolver la cantidad de copias indicada.");
} else {
alquileres[pos][2] -= devueltas;
texto = "Se ha registrado la devolucin de " + devueltas + " copias\n";
texto += "de la pelcula " + peliculas[pos][0] + " con cdigo " + codigo;
}
} else {
LE.mostrarError ("Cdigo de la pelcula no existe!!!");
}
}

public void utilidadTotal ( ){
String dato="La utilidad total es de "+"\n";
int utilidad=0;
for(int i=0;i<numPel;i++){
utilidad+=(alquileres[i][0]*alquileres[i][3]);
}
LE.mostrarResultado ( dato + utilidad +" sol(es)." );
}

public void masPedida ( ){
LE.mostrarInformacion ( "Intente implementar esta opcin!!!" );
}

public void finalizar ( ){
LE.mostrarInformacion ( "Usted ha finalizado el programa" );
}
}


Pg. 222



1. El mtodo alquiler ( ) ha sido trabajado de tal forma que se informa al usuario todo lo
relacionado con el progreso de alquiler de una pelcula. En soluciones adecuadas
se debe informar permanentemente al usuario de todos los acontecimientos.

2. El mtodo aumentar ( ) permite que las matrices aumenten su tamao 5 filas ms
cada vez que stas se llenan. La validacin del espacio disponible en las matrices
se realiza en el mtodo ingresar ( ).

3. No se ha incluido una validacin de tal forma que no se permita el ingreso del
cdigo de pelcula repetido. Esta situacin afecta cuando se implementan los
mtodos de manejo de datos, ya que estos siempre manipulan el primer cdigo de
video encontrado. Esta situacin se resuelve en la solucin del siguiente problema.


Pg. 223

Problema 026

Enunciado:
Durante el partido de ftbol entre la seleccin de Per contra Argentina, los alumnos Pian y
Adrianzen discutan cmo podan programar la tabla de posicin con los resultados de los
partidos del mundial de ftbol. Luego de un gran debate propusieron la siguiente Grfica de
Estructuras de Datos para almacenar y controlar los datos de los resultados de los partidos.
Desarrolle una solucin utilizando un men de opciones y mtodos para el manejo de los
datos.

Dados los arreglos:

equipos datos
Nom PJ (0) PG (0) PE (0) GF (1) GC (2) PA (3)
0 0
1 1
2 2
3 3
: : : : : : :
: : : : : : :
numEqu = 0
9999 9999 (int)

( String ) ( int )

Donde: numEqu permite almacenar el nmero de equipos que participan en el mundial.

nom= Nombre del equipo participante en el mundial de ftbol.

PJ = Partidos Jugados.

PG = Nmero de Partidos Ganados.

PE = Nmero de Partidos Empatados.

GF = Goles a Favor.

GC = Goles en Contra.
PA = Puntaje Actual. Puntaje en un determinado momento.


Clase Futbol
..


public class PrgFutbol {

int tabla[ ][ ], fechas ;
String equipos[ ] ;

Pg. 224

Clase Futbol
..

public PrgFutbol ( ) {
equipos = new String[0];
tabla = new int[0][6];
fechas=1;
}

public static void main(java.lang.String[ ] args) {
PrgFutbol mundial = new PrgFutbol ( );
mundial.menu ( ) ;
}

int menu;

do {
System.out.println("\n\nMENU PRINCIPAL");
System.out.println("---------------");
System.out.println("1.- Ingresar equipo");
System.out.println("2.- Modificar Equipo");
System.out.println("3.- Eliminar Equipo");
System.out.println("4.- Ingresar resultados de la fecha");
System.out.println("5.- Mostrar tabla");
System.out.println("6.- Salir\n");
do {
System.out.print (" Eleccin (1-6) = ");
menu = Lectura.leerInt ( );
if (menu > 6 || menu < 1) {
System.out.print ( "Eleccin incorrecta, reintente!" ) ;
}
} while (menu > 6 || menu < 1);

switch (menu) {
case 1:
ingresar ( );
break;
case 2:
if (equipos.length == 0) {
System.out.println ( "No existen datos..." );
} else {
modificar ( );
}
break;
case 3:
System.out.println ("No existen datos..." );
} else {
eliminar ( );
}
break;
case 4:

Pg. 225

Clase Futbol
..
System.out.println ( "No existen datos..." );
} else {
resultadosFecha ( );
}
break;
case 5:
System.out.println("No existen datos...");
} else {
mostrarTabla ( );
}
break;
case 6:
break;
}
} while (menu != 6);
}

String nombre, tmpEquipos[];
int tmpDatos[][];

System.out.println ("\nEnter (intro) para finalizar el ingreso de nombres");
do {
System.out.print ("Ingresa el nombre del equipos: ");
nombre = Lectura.leerString ( );
nombre = nombre.trim ( );
if (nombre.equals(""))
break;

tmpEquipos = new String [equipos.length + 1];
tmpDatos = new int [equipos.length + 1][6];

for (int i = 0; i < equipos.length; i++) {
tmpEquipos[i] = equipos[i];
tmpDatos[i] = tabla[i];
}

tmpEquipos[tmpEquipos.length - 1] = nombre;
equipos = tmpEquipos;
tabla = tmpDatos;

} while (!nombre.equals(""));
}

String nombre;
int numEquipo;

System.out.println ( "\n\nModificar nombre de Equipo" );
System.out.println ( "---------------" );
for (int i = 0; i < equipos.length; i++)
System.out.println((i + 1) + ".-" + equipos[i]);

Pg. 226

Clase Futbol
..

System.out.println( "0.- Salir sin modificar" );
do {
System.out.print ( " Elige un Equipo: " );
numEquipo = Lectura.leerInt ( );
} while (numEquipo < 0 || numEquipo > equipos.length);

if (numEquipo != 0) {
numEquipo--;
System.out.println ( "Antiguo nombre = " + equipos[numEquipo] );
do {
System.out.print ("Nuevo Nombre = ");
nombre = Lectura.leerString ( );
} while (nombre.equals(""));
equipos[numEquipo] = nombre;
}
}

String tmpEquipos[];
int tmpDatos[][], numEquipo, aux;
char opc;

System.out.println ("\n\nEliminar un Equipo");
System.out.println ("---------------");
System.out.println ((i + 1) + ".-" + equipos[i]);

System.out.println("0.- Salir sin Eliminar\n");
do {
System.out.print (" Elige un Equipo: ");
numEquipo = Lectura.leerInt ( );
} while (numEquipo < 0 || numEquipo > equipos.length);

if (numEquipo != 0) {
numEquipo--;
System.out.print ("Seguro que desea eliminar el equipo " + equipos[numEquipo]
"" + "(s/n) = ");
opc = Lectura.leerChar ( );
opc = Character.toLowerCase(opc);
if (opc == 's') {
tmpEquipos = new String[equipos.length - 1];
tmpDatos = new int[equipos.length - 1][6];
aux = 0;
if (i != numEquipo) {
tmpEquipos[aux] = equipos[i];
tmpDatos[aux++] = tabla[i];
}
}
equipos = tmpEquipos;
tabla = tmpDatos;

}

Pg. 227

Clase Futbol
..
}
}

public void resultadosFecha ( ) {
if ((equipos.length % 2) == 0) {
boolean reg[] = new boolean[equipos.length];
// a = Equipo local. b = Equipo visitante.
// ga = Goles Equipo local. gb = Goles Equipo visitante.
int a, b, ga, gb;
int aux;

System.out.println("\n\nResultados de la fecha " + fechas);
System.out.println("----------------------");
aux = 0;
do {
System.out.println("\nPartido " + ++aux);
if (!reg[i])
System.out.println((i + 1) + ".- " + equipos[i]);
do {
System.out.print ("Equipo local= ");
a = Lectura.leerInt ( );
} while (a > equipos.length || a < 1 || reg[a - 1]);
reg[a - 1] = true;

do {
System.out.print ("Equipo visitante= ");
b = Lectura.leerInt ( );
} while (b > equipos.length || b < 1 || reg[b - 1]);
reg[b - 1] = true;

System.out.print ("Goles que meti " + equipos[a - 1] + " = ");
ga = Lectura.leerInt ( );
System.out.print ("Goles que meti " + equipos[b - 1] + " = ");
gb = Lectura.leerInt ( );

if (ga > gb) {
tabla[a - 1][1] += 1;
tabla[a - 1][5] += 3;
}
if (gb > ga) {
tabla[b - 1][1] += 1;
tabla[b - 1][5] += 3;
}
if (gb == ga) {
tabla[a - 1][2] += 1;
tabla[b - 1][2] += 1;
tabla[a - 1][5] += 1;
tabla[b - 1][5] += 1;
}
tabla[a - 1][0]++;
tabla[a - 1][3] += ga;
tabla[a - 1][4] += gb;
tabla[b - 1][0]++;

Pg. 228

Clase Futbol
..
tabla[b - 1][3] += gb;
tabla[b - 1][4] += ga;
} while (aux < (equipos.length / 2));
fechas++;
} else {
System.out.println("Ingrese un nmero par de equipos");
}
}

public void mostrarTabla ( ) {
int aux;
boolean cambio = false;

String tmpEquipo;
int tmpDatos[][] = new int[1][6];

do {
System.out.print ("\n\n Indique ordenar (1=Nombre, 2=Puntos) = ");
aux = Lectura.leerInt ( );
} while (aux < 1 || aux > 2);

for (int i = 0; i < equipos.length - 1; i++) {
for (int j = equipos.length - 1; j > i; j--) {
switch (aux) {
case 1:
if (equipos[i].compareTo(equipos[j]) > 0)
cambio = true;
break;
case 2:
if (tabla[i][5] < tabla[j][5]) {
cambio = true;
}
break;
}
if (cambio) {
tmpEquipo = equipos[j];
equipos[j] = equipos[i];
equipos[i] = tmpEquipo;

tmpDatos[0] = tabla[j];
tabla[j] = tabla[i];
tabla[i] = tmpDatos[0];

cambio = false;
}
}
}

int tamao = nombreLongitudMayor ( );
String espacios = espaciosEnBlanco(30);
String nombreEquipo;
System.out.println("\n\nTABLA DE POSICIONES");
System.out.println("-----------------------");


Pg. 229

Clase Futbol
..
String texto = ("Equipo" + espacios).substring(0, tamao + 2);
System.out.println(texto + "\tPJ\tPG\tPE\tGF\tGC\tP");
nombreEquipo = (equipos[i] + espacios).substring(0, tamao + 2);
System.out.println(nombreEquipo + "\t" + tabla[i][0] + "\t"
+ tabla[i][1] + "\t" + tabla[i][2] + "\t"
+ tabla[i][3] + "\t" + tabla[i][4] + "\t"
+ tabla[i][5]);
}
}

private int nombreLongitudMayor ( ) {
int tamao=0;
if (equipos[i].length ( ) > tamao)
tamao = equipos[i].length ( );
}
return tamao;
}

private String espaciosEnBlanco (int total) {
String espacios="";
for (int i = 0; i < total; i++) {
espacios = espacios + " ";
}
return espacios;
}

}



1 No se utiliza el mtodo aumentar ( ) ya que las Estructuras de Datos se crean a
medida. Si se necesita almacenar ms datos no existira problemas, ya que los datos
almacenados tambin se almacenarn en arreglos temporales conjuntamente con los
nuevos datos. Finalmente, los arreglos temporales se considerarn como los arreglos
propios de la aplicacin.

2 El mtodo resultadosFecha ( ) permite que se ingresen los datos de una fecha
determina del campeonato. En cada fecha slo podr ingresar un resultado por cada
equipo que participa en el campeonato. Analice cmo se logra esto.

3 El mtodo mostrarTabla ( ) permite mostrar la tabla de posiciones del campeonato en
cualquier fecha del campeonato.

Pg. 230

Problema 027

Enunciado:
Desarrollar una solucin utilizando mtodos y arreglos en paralelo, que permita ingresar,
almacenar y manejar los datos de todos los alumnos de un saln de clase en base a la
Grfica de Estructuras de Datos mostrada. Se deber desarrollar un men con las siguientes
opciones:

[1] Ingreso de datos (valide los datos ingresados. No permitir el ingreso de un
cdigo que ya existe).

[2] Visualizacin de notas (visualizar los nombres, apellidos, cdgios y las notas de
todos los alumnos de un saln de clase. Considerar la posibilidad de tener
muchos datos que visualizar).

[3] Ordenar datos (ordenar los datos por nombre y apellido en forma ascendente).

[4] Modificar los datos utilizando el cdigo del alumno (no se podr modificar los
cdigos).

[5] Eliminar los datos utilizando el cdigo del alumno.

[6] Calcular y mostrar el promedio general del curso.

[7] Finalizar.

Dados los arreglos:

notas datos
nom (0) ape (1) cod (2)
0 0
1 1
2 2
3 3
: : : :
: : : :
numAlu = 0
9999 9999 (int)

(double) (String)

Donde: numAlu permite almacenar el nmero de alumnos.

nom = Nombre del alumno.

ape = Apellido del alumno.

cod = Cdigo del alumno.


Pg. 231


Clase PrgAlumnos
..

import javax.swing.* ;


double notas[ ] ;
String datos[ ][ ] ;
int numAlu ;

notas = new double[10] ;
datos = new String[10][3] ;
numAlu = 0 ;
}

PrgAlumnos x = new PrgAlumnos ( ) ;
x.menu ( ) ;
}

String menu = "===OPCIONES DEL MENU===\n" + "[1] Ingreso de datos.\n"
+ "[2] Visualizar datos.\n"
+ "[3] Ordenar datos segn nombres y apellidos.\n"
+ "[4] Modificar los datos segn cdigo.\n"
+ "[5] Eliminar los datos segn cdigo.\n"
+ "[6] Calcular y mostrar la nota ms alta y ms baja.\n"
+ "[7] Calcular y mostrar el promedio general en el curso.\n"
+ "[8] FINALIZAR.\n\n" + "___InGrEsE UnA De LaS OpCiOnEs___" ;
int opc, rpta, pos, sw = 0 ;
String cod = "" ;

do {

switch (opc) {

case 1:
ingresar ( ) ;
sw = 1 ;
break ;

case 2:
if (sw == 1) {
visualizar ( ) ;
} else {
LE.mostrarError ("Error...Ingrese la primera opcin") ;

Pg. 232

Clase PrgAlumnos
..
}
break ;

case 3:
if (sw == 1) {
ordenar ( ) ;
} else {
}
break ;

case 4:
if (sw == 1) {
cod = LE.leerString ("Ingrese el cdigo del alumno del que desea
modificar qqqqqqqq qdatos") ;
pos = buscar (cod) ;
if (pos != -1) {
rpta = LE.mostrarPreguntaOpcion2("Desea modificar los datos del
"" alumno " + datos[pos][0] + " " +
"" datos[pos][1] + " ?") ;
if (rpta == 0) {
modificar(pos) ;
}
} else {
LE.mostrarInformacion ("Cdigo no encontrado") ;
}
} else {
}
break ;

case 5:
if (sw == 1) {
cod = LE.leerString ("Ingrese el cdigo del alumno del que desea eliminar
qqqqqqqqq datos") ;
pos = buscar (cod) ;
if (pos != -1) {
rpta = LE.mostrarPreguntaOpcion2("Desea eliminar los datos del
"" alumno " + datos[pos][0] + " " +
"" datos[pos][1] + " ?") ;
if (rpta == 0) {
eliminar(pos) ;
}
} else {
LE.mostrarInformacion ("Cdigo no encontrado") ;
}
} else {
}
break ;

case 6:
if (sw == 1) {
calcularNotas ( ) ;
} else {

Pg. 233

Clase PrgAlumnos
..
}
break ;

case 7:
if (sw == 1) {
calcularPromedio ( ) ;
} else {
}
break ;

case 8:
finalizar ( ) ;
break ;
default :
LE.mostrarError ("Error...Opcin no conocida") ;
}
} while (opc != 8) ;
}

int rpta ;
String cod = "" ;
do {
if (notas.length == numAlu) {
aumentar ( ) ;
}
cod = LE.leerString ("Ingrese el cdigo del alumno: " + (numAlu + 1)) ;
int pos = buscar (cod) ;
if (pos == -1) {
datos[numAlu][2] = cod ;

do {
datos[numAlu][0] = LE.leerString ("Ingrese el nombre del alumno: "
+ (numAlu + 1)) ;
datos[numAlu][0] = datos[numAlu][0].trim ( ) ;
if (datos[numAlu][0].equals("")) {
LE.mostrarError ("Error...Ingrese un dato") ;
}
} while (datos[numAlu][0].equals("")) ;

do {
datos[numAlu][1] = LE.leerString ("Ingrese el apellido del alumno: "
+ (numAlu + 1)) ;
datos[numAlu][1] = datos[numAlu][1].trim ( ) ;
if (datos[numAlu][1].equals("")) {
LE.mostrarError ("Error...Ingrese un dato") ;
}
} while (datos[numAlu][1].equals("")) ;

do {
notas[numAlu] = LE.leerDouble ("Ingrese la nota del alumno: "
+ (numAlu + 1)) ;

Pg. 234

Clase PrgAlumnos
..
if (notas[numAlu] < 0 || notas[numAlu] > 20) {
LE.mostrarError ("Error...La nota debe de ser entre 0 y 20") ;
}
} while (notas[numAlu] < 0 || notas[numAlu] > 20) ;
numAlu++ ;
} else {
LE.mostrarInformacion ("Ya ingres el cdigo: " + cod) ;
}
rpta = LE.mostrarPreguntaOpcion2("Desea continuar con el proceso?") ;
} while (rpta == 0) ;
}

String informacion = " CODIGO"+ "\t" + " NOMBRES " + "\t" + " APELLIDOS" + "\t"
"" + "NOTAS" + "\n" ;
informacion += " ---------------------------------------------------------------------------------------
"" -------------\n" ;


informacion += datos[i][2] + "\t" + datos[i][0] + "\t" + datos[i][1] + "\t" + notas[i] +
"" "\n" ;
}
muestraInformacion.append( informacion ) ;
JOptionPane.showMessageDialog( null, desplazaInformacion, "LISTA DEL
"" SALN", JOptionPane.INFORMATION_MESSAGE ) ;
}

String temp1, temp2, temp3 ;
double temp4 ;

for (int i = 0; i < numAlu - 1; i++) {
for (int j = i + 1; j < numAlu; j++) {
if (datos[i][0].compareToIgnoreCase(datos[j][0]) > 0) {
temp1 = datos[i][0] ;
datos[i][0] = datos[j][0] ;
datos[j][0] = temp1 ;
temp2 = datos[j][1] ;
temp4 = notas[i] ;
notas[i] = notas[j] ;
notas[j] = temp4 ;
}
if (datos[i][0].equalsIgnoreCase(datos[j][0])) {

Pg. 235

Clase PrgAlumnos
..
temp4 = notas[i] ;
notas[i] = notas[j] ;
notas[j] = temp4 ;
}
}
}
}
}

public int buscar (String cod) {
int pos = -1 ;
if (datos[i][2].equalsIgnoreCase(cod)) {
pos = i ;
break ;
}
}
return pos ;
}

public void modificar (int pos) {
datos[pos][0] = LE.leerString ("Ingrese el nuevo nombre del Alumno") ;
datos[pos][1] = LE.leerString ("Ingrese el nuevo apellido del Alumno") ;
notas[pos] = LE.leerDouble ("Ingrese la nueva nota del Alumno") ;
}

public void eliminar(int pos) {
for (int i = pos; i < numAlu - 1; i++) {
datos[i][0] = datos[i + 1][0] ;
datos[i][1] = datos[i + 1][1] ;
datos[i][2] = datos[i + 1][2] ;
notas[i] = notas[i + 1] ;
}
numAlu-- ;
}

public void calcularNotas ( ) {
double mayor = notas[0] ;
double menor = notas[0] ;
mayor = Math.max(notas[i], mayor) ;
menor = Math.min(notas[i], menor) ;
}

Pg. 236

Clase PrgAlumnos
..
String mensaje = "La nota mayor es: " + mayor + "\n" + "La nota menor es: " +
"" menor ;
LE.mostrarInformacion (mensaje) ;
}

public void calcularPromedio ( ) {
double suma = 0, prom ;
suma += notas[i] ;
}
prom = (suma / numAlu) ;
prom = Math.round(prom * 100) / 100.0 ;
String mensaje = "El promedio general es: " + prom ;
LE.mostrarInformacion (mensaje) ;
}

LE.mostrarInformacion ("Usted ha finalizado el programa") ;
}

public void aumentar ( ) {
String dat[][] = new String[notas.length + 10][3] ;
double not[] = new double[notas.length + 10] ;
dat[i][0] = datos[i][0] ;
not[i] = notas[i] ;
}
datos = dat ;
notas = not ;
}

}


Pg. 237


Ahora deber mejorar la solucin en base a los temas tratados en los problemas
anteriores.

Ahora, observe el mtodo visualizar:

Mtodo visualizar
..


String informacion = " CODIGO"+ "\t" + " NOMBRES " + "\t" + " APELLIDOS" + "\t" +
qq"NOTAS" + "\n" ;
informacion + = " -------------------------------------------------------------------------------------
"" ---------------\n" ;

informacion +=datos[i][2] + "\t" + datos[i][0] + "\t" + datos[i][1] + "\t" + notas[i] + "\n" ;
}

muestraInformacion.append ( informacion ) ;
JOptionPane.showMessageDialog( null, desplazaInformacion, "LISTA DEL SALN",
iii JOptionPane.INFORMATION_MESSAGE ) ;

}

Observe cmo se utilizan los componentes de Java para mejorar la visualizacin de los
datos.


Pg. 238

Problema 028

Enunciado:
Un grupo de estudiantes visitaron diversos colegios del cono norte de Lima apoyando a los
docentes en el dictado de diversas charlas. En total visitaron aproximadamente 15 colegios y
observaron que todos los colegios posean computadoras donadas por instituciones privadas.
El alumno Gutirrez coment a sus compaeros que podan desarrollar una aplicacin que
permita controlar las vacantes a cada una de las charlas programadas. El alumno Castro
propuso un vector unidimensional para almacenar el tema de la charla a dictar y un vector
bidimensional para almacenar datos adicionales sobre cada uno de las charlas, tal y como se
muestra en la figura. Tener en cuenta que los invitados a la charla cuentan con el descuento
establecido.

Dados los arreglos:

charlas asistentes
vac (0) cos (0) des (0) ins (1) inv (2)
0 0
1 1
2 2
3 3
: : : : : :
: : : : : :
numChar = 0
9 9 (int)

(String) (double)

Donde: numCha permite almacenar el nmero de charlas.

vac = Nmero mximo de asistentes a una charla.

cos = Costo de particiacin.

des = Descuento por participacin.

Ins = Nmero de inscritos

inv = Nmero de invtados.

Desarrolle una solucin utilizando mtodos y un men de opciones. Desarrolle un men
de opciones de tal forma que slo se muestren las opciones que se pueden utilizar.


Pg. 239


Clase PrgCharlas
..

import biblioteca. * ;

public class PrgCharlas {

String charlas[ ] ;
double asistentes[ ][ ] ;
int numChar ;

public static void main (String[] args) {
PrgCharlas x = new PrgCharlas ( ) ;
x.menu ( ) ;
}

public PrgCharlas ( ) {
charlas = new String[10] ;
asistentes = new double[10][5] ;
numChar = 0 ;
}

int opc ;
String opciones1 = "************MENU PRINCIPAL ************\n"
+ "-------------------------------------\n"
+ "[1] Ingreso de Datos \n" + "[0] Finalizar operacin\n"
+ "-------------------------------------\n"
+ "Elija opcin deseada:\n" ;

String opciones2 = "************MENU PRINCIPAL ************\n"
+ "-------------------------------------\n"
+ "[1] Ingreso de datos \n" + "[2] Mostrar datos \n"
+ "[3] Inscribirse a una Charla \n"
+ "[4] Calcular ganancia total de charlas \n"
+ "[5] Ordenar datos \n" + "[6] Modificar datos \n"
+ "[7] Eliminar datos \n" + "[0] Finalizar operacin\n"
+ "-------------------------------------\n"

boolean acceso = false ;
String opciones = opciones1;

do {
opc = LE.leerInt(opciones) ;
switch (opc) {
case 1:
ingresarDatos ( ) ;
acceso = true;

Pg. 240

Clase PrgCharlas
..
opciones = opciones2;
break;

case 2:
if (acceso) {
mostrarDatos ( ) ;
} else {
LE.mostrarError ( "Opcin no vlida" ) ;
}
break;

case 3:
if (acceso) {
String charla = LE.leerString ("Ingrese el nombre de la charla en que desea
qqqqqqqqq inscribirse:") ;
int poschar = buscar (charla) ;
if ( poschar !=- 1) {
if ( ( asistentes[poschar][3] + asistentes[poschar][4] ) < qqqqqq
"" qqq qqasistentes[poschar][0] ) {
int rptachar=LE.mostrarPreguntaOpcion2("Desea registrarse a esta
"" charla?");
if ( rptachar == 0 ) {
inscribirseCharla(poschar) ;
} else {
LE.mostrarAdvertencia ( "La operacin fue cancelada ") ;
}
} else {
LE.mostrarError ("Lo sentimos, no hay vacantes para la charla
qqqqqqqqqqqqq seleccionada");
}
} else {
LE.mostrarError ("El nombre de la charla ingresada no es vlido");
}
} else {
LE.mostrarError ("La opcin ingresada es incorrecta");
}
break;

case 4:
if (acceso) {
gananciaTotal ( );
} else {
}
break;

case 5:
if (acceso) {
ordenarDatos ( );
} else {
}
break;

case 6:

Pg. 241

Clase PrgCharlas
..
if (acceso) {
String nom1 = LE.leerString ("Ingrese el nombre de la charla que desea
qqqqqqq qmodificar:") ;
int rpta2 ;
int pos1 = -1 ;
pos1 = buscar (nom1) ;
if (pos1 != -1) {
rpta2 = LE.mostrarPreguntaOpcion2("Desea modificar la charla de: "+
qqqqqqqqq qqcharlas[pos1]) ;
if (rpta2 == 0) {
modificarDatos(pos1) ;
} else {
LE.mostrarAdvertencia ("La operacin a sido cancelada");
}
} else {
}
} else {
}
break;

case 7:
if (acceso) {
String nom = LE.leerString ("Ingrese el nombre de la charla que desea
"" eliminar:" ;
int pos = -1;
pos = buscar (nom);
if (pos != -1) {
int rpta = LE.mostrarPreguntaOpcion2 ("Desea eliminar la charla de:" +
qqqqqqqqqqq charlas[pos] ) ;
if (rpta == 0) {
eliminarDatos(pos);
} else {
LE.mostrarAdvertencia ("La operacin fue cancelada") ;
}
}else{
}
if (numChar == 0) {
acceso = false;
opciones = opciones1;
}
} else {
LE.mostrarError ( "La opcin ingresada es incorrecta" ) ;
}
break;

case 0:
LE.mostrarAdvertencia ( "La operacin ha sido finalizada" ) ;
break;
default:
LE.mostrarError ( "La opcin ingresada es incorrecta" ) ;
}
} while (opc != 0) ;

Pg. 242

Clase PrgCharlas
..
}

public void ingresarDatos ( ) {
int rpta;
do {
if (numChar == charlas.length) {
aumentarTamaoArreglo ( ) ;
}

do {
do {
charlas[numChar] = LE.leerString ( "Ingrese el nombre de la charla Nro:" +
qqqqqqqqq (numChar + 1) ) ;
charlas[numChar] = charlas[numChar].trim ( ) ;
charlas[numChar] = charlas[numChar].toUpperCase ( ) ;
if ( !charlas[numChar].matches("[A-Z]+") ) {
LE.mostrarError ( "Error, el tipo de dato ingresado no es vlido; reintente"
"" ) ;
}
} while ( !charlas[numChar].matches("[A-Z]+" ) ) ;

if (buscar (charlas[numChar]) != -1 || charlas[numChar].length ( ) < 3) {
LE.mostrarError ( "El nombre de la charla ingresada no es vlida; reintente"
"" ) ;
}
} while ( buscar (charlas[numChar]) != -1 || charlas[numChar].length ( ) < 3 ) ;

do {
asistentes[numChar][0] = LE.leerDouble ( "Ingrese el nmero de asistentes a
"" la charla de: " + charlas[numChar] ) ;
if (asistentes[numChar][0] < 0 ) {
LE.mostrarError ( "La cantidad de asistentes a la charla ingresada no es
"" vlida; reintente" ) ;
}
} while (asistentes[numChar][0] < 0 ) ;

do {
asistentes[numChar][1] = LE.leerDouble ( "Ingrese el costo de la charla" ) ;
if ( asistentes[numChar][1] < 0 ) {
LE.mostrarError ("El costo de la charla ingresada no es vlido; reintente");
}
} while ( asistentes[numChar][1] < 0 ) ;

do {
asistentes[numChar][2] = LE.leerDouble ("Ingrese el descuento de la charla");
if (asistentes[numChar][2] > asistentes[numChar][1]) {
LE.mostrarError ("El descuento de la charla ingresada no es vlido;
"" reintente") ;
}
} while ( asistentes[numChar][2] > asistentes[numChar][1] ) ;

asistentes[numChar][3] = 0 ;
asistentes[numChar][4] = 0 ;
numChar++ ;

Pg. 243

Clase PrgCharlas
..
rpta = LE.mostrarPreguntaOpcion2 ( "Desea seguir agregando datos?" ) ;

} while ( rpta == 0 ) ;
}

public void mostrarDatos ( ) {
String listado = "Nombre de la Charla || Asistentes || Costo ||
"" Descuento || Nro de Inscritos || Nro de Invitados \n----------------
"" ----------------------------------------------------------------------------\n" ;

for (int i = 0; i < numChar; i++) {
listado = listado
+ completarConBlancosXDer ("" + charlas[i], 35)
+ completarConBlancosXDer ("" + asistentes[i][0], 23)
+ completarConBlancosXDer ("S/." + asistentes[i][1], 23)
+ completarConBlancosXDer ("S/." + asistentes[i][2], 25)
+ "\n" ;
}

listado += "\n---------------------------------------------------------------------------------------------
"" -----------------------------\n" ;
LE.mostrarInformacion ( listado ) ;
}

public void inscribirseCharla(int posChar) {
int opcChar;
String subMenu = "************MENU PRINCIPAL ************\n"
+ "-------------------------------------\n"
+" Inscribirse a charla de: \t"+ charlas[posChar]+ " \n"
+"Vacantes disponibles: \t"+ asistentes[posChar][0] + " \n"
+"Costo de usuario inscrito:\t " + asistentes[posChar][1]+ " \n"
+"Costo de usuario invitado:\t " + asistentes[posChar][2]+ " \n"
+ "-------------------------------------\n"
+"[1] Usuario inscrito \n"
+"[2] Usuario invitado\n"
+"[3] Volver al men principal\n"
+ "----------------------------\n"
+"Elija opcin deseada:" ;

do {
opcChar = LE.leerInt(subMenu) ;
switch (opcChar) {
case 1 :
userInscrito(posChar) ;
break ;

case 2 :
userInvitado(posChar) ;
break ;

case 3 :

Pg. 244

Clase PrgCharlas
..
LE.mostrarAdvertencia ( "Regresando al men principal" ) ;
break ;
default :
LE.mostrarError ( "La opcin ingresada es incorrecta, reintente" ) ;
}
} while ( opcChar != 3 ) ;
}

public void gananciaTotal ( ) {
double ganancia1=0 ;
double ganancia=0 ;
double neto=0 ;
for ( int i=0; i<numChar; i++ ) {
ganancia1 = ganancia1 + (asistentes[i][1] * (asistentes[i][3]) ) ;
ganancia = ganancia + (asistentes[i][1] * (asistentes[i][4]) ) ;
if ( ganancia!= 0 ) {
ganancia=ganancia - ( asistentes[i][2] * asistentes[1][4] ) ;
}
}
neto = ganancia1 + ganancia ;
LE.mostrarInformacion ( "La ganancia total por los usuarios inscritos es: " + neto) ;
}

public void ordenarDatos ( ) {
String charla ;
double temp ;
for ( int i = 0; i < numChar - 1; i++ ) {
for ( int j = i + 1; j < numChar; j++) {
if ( charlas[i].compareToIgnoreCase(charlas[j]) > 0 ) {
charla = charlas[i] ;
charlas[i] = charlas[j] ;
charlas[j] = charla ;

temp = asistentes[i][0] ;
asistentes[i][0] = asistentes[j][0] ;
asistentes[j][0] = temp ;






Pg. 245

Clase PrgCharlas
..
}
}
}
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
}

public void modificarDatos ( int pos ) {
if ( numChar == charlas.length ) {
}
do {
do {
charlas[pos] = LE.leerString ( "Ingrese el nuevo nombre de la charla nro: " ) ;
charlas[pos] = charlas[pos].trim ( ) ;
charlas[pos] = charlas[pos].toUpperCase ( ) ;
if ( !charlas[pos].matches("[A-Z]+") ) {
LE.mostrarError ("Error, el tipo de dato ingresado no es vlido; reintente");
}
} while ( !charlas[pos].matches ( "[A-Z]+") ) ;
if ( charlas[pos].length ( ) < 3 ) {
LE.mostrarError ( "El nombre de la charla ingresada no es vlido; reintente");
}
} while ( charlas[pos].length ( ) < 3 ) ;

// Ingresando y validando nmero de asistentes, costo y descuento.
do {
asistentes[pos][0] = LE.leerDouble ( "Ingrese el nuevo nmero de asistentes a la
qqqq qcharla de: " + charlas[pos] ) ;
if (asistentes[pos][0] < 0) {
LE.mostrarError ( "La cantidad de asistentes a la charla ingresada no es
"" vlida; reintente" ) ;
}
} while ( asistentes[pos][0] < 0 ) ;
do {
asistentes[pos][1] = LE.leerDouble ( "Ingrese el costo de la charla" ) ;
if ( asistentes[pos][1] < 0 ) {
LE.mostrarError ( "El costo de la charla ingresada no es vlido; reintente" ) ;
}
} while ( asistentes[pos][1] < 0 ) ;
do {
asistentes[pos][2] = LE.leerDouble ( "Ingrese el descuento de la charla" ) ;
if (asistentes[pos][2] > asistentes[pos][1]) {
LE.mostrarError ( "El descuento de la charla ingresada no es vlido; reintente"
"" ) ;
}
} while ( asistentes[pos][2] > asistentes[pos][1] ) ;

asistentes[pos][3] = 0 ;
asistentes[pos][4] = 0 ;
}

public void eliminarDatos ( int pos ) {

Pg. 246

Clase PrgCharlas
..
for ( int i = pos; i < numChar; i++ ) {
charlas[i] = charlas[i + 1] ;
for ( int j = 0; j < 5; j++ ) {
asistentes[i][j] = asistentes[i + 1][j] ;
}
}
numChar-- ;
}

public int buscar ( String c ) {
int pos = -1 ;
if ( c.equalsIgnoreCase(charlas[i]) ) {
pos = i ;
break ;
}
}
return pos ;
}

public void aumentarTamaoArreglo ( ) {
String charla[] = new String[charlas.length + 10] ;
double asis[][] = new double[charlas.length + 10][5] ;
charla[i] = charlas[i] ;
for ( int j = 0; j < 5; j++ ) {
asis[i][j] = asistentes[i][j] ;
}
}
charlas = charla ;
asistentes = asis ;
}

public void userInscrito ( int posChar ) {
if ( asistentes[posChar][3] + asistentes[posChar][4] < asistentes[posChar][0] ) {
asistentes[posChar][3] = asistentes[posChar][3] + 1 ;
LE.mostrarAdvertencia ( "Usted se ha inscrito a esta charla de forma exitosa" ) ;
} else {
LE.mostrarError ("Lo sentimos, la charla seleccionada no cuenta con vacantes");
}
}

public void userInvitado ( int posChar ) {
if ( asistentes[posChar][3] + asistentes[posChar][4]< asistentes[posChar][0] ) {
asistentes[posChar][4] = asistentes[posChar][4] + 1 ;
LE.mostrarAdvertencia ( "Usted se ha inscrito a esta charla de forma exitosa" ) ;
} else {
LE.mostrarError ( "Lo sentimos, la charla seleccionada no cuenta con vacantes");
}
}

Pg. 247

Clase PrgCharlas
..

public String completarConBlancosXDer ( String cadena, int total ) {
int longitud = cadena.length ( ) ;
if ( longitud < total ) {
int falta = total - longitud ;
for ( int i = 0; i < falta; i++ )
cadena += " " ;
}
return cadena ;
}

}


Pg. 248


Es posible mejorar la solucin desarrollada para el problema anterior. Utilice el mtodo
ordenar que se muestra a continuacin:

Mtodo OrdenarDatos
..

public void ordenarDatos ( ) {
String charla ;
String asis ;
for ( int i = 0; i < numChar - 1; i++ ) {
for ( int j = i + 1; j < numChar; j++ ) {

if ( charlas[i].compareToIgnoreCase(charlas[j]) > 0 ) {
charla = charlas[i] ;
charlas[i] = charlas[j] ;
charlas[j] = charla ;

for ( int k = 0; k < 5; k++ ) {
asis= Asistentes [i][k] ;
asistentes [i][k] = asistentes [j][k] ;
asistentes [j][k] = asis ;
}
}
}
}

LE.mostrarAdvertencia ( La operacin fue realizada con xito ) ;

} // Fin ordenarDatos

Observe que cuando se tienen matrices en una solucin, se puede utilizar tambin una
tercera estructura de repeticin DESDE que permita intercambiar los datos almacenados
en dicha matrices.


Pg. 249

Problema 029

Enunciado:
Un grupo de alumnos asistieron a un evento en un conocido restaurante de nuestra ciudad.
En dicho restaurante existan tantas mesas que los alumnos empezaron a discutir cmo
podan controlar el consumo de cada una de las mesas. El alumno Yarlequ propuso la
Grfica de Estructuras de Datos mostrada. Desarrolle una solucin utilizando un men de
opciones y mtodos para el manejo de los datos.

Dados los arreglos:

clientes datos
nom num (0) cac (1) cat (2)
0 0
1 1
2 2
3 3
: : : :
: : : :
numMes = 0
9999 9999 (int)

(String) (String)

Donde: numMes permite almacenar el nmero de mesas del restaurante.

nom= Nombre del cliente que actualmente ocupa una mesa.

num = Nmero de mesa.

cac = Cuenta actual del cliente.

cat = Cuenta acumulada total por mesa.


Clase PrgRestaurante
..


public class PrgRestaurante {

String clientes[ ] ;
int numMesa ;


Pg. 250

..
public static void main ( String[] args ) {
PrgRestaurante obj = new PrgRestaurante ( ) ;
obj.menu ( ) ;
}

public PrgRestaurante ( ) {
clientes = new String[10000] ;
numMesa = 0 ;
} // Fin PrgRestaurante

String menu1 = "*********** BOHEMIA RESTAURANT & MAS ************\n"
+ "--------------------------------------------------------------\n"
+ "[1] Ingreso de datos \n"
+ "[0] Finalizar operacin\n"
+ "--------------------------------------------------------------\n"
+ "Elija opcin deseada:\n";

String menu2 = "*********** BOHEMIA RESTAURANT & MAS ************\n"
+ "---------------------------------------------------------------\n"
+ "[1] Ingreso de datos \n"
+ "[2] Mostrar datos generales \n"
+ "[3] Mostrar datos individuales \n"
+ "[4] Utilizar mesa \n"
+ "[5] Calcular ganancias \n"
+ "[6] Ordenar datos \n"
+ "[7] Modificar datos \n"
+ "[8] Eliminar datos \n"
+ "[0] Finalizar operacin\n"
+ "----------------------------------------------------------------\n"

String menu = menu1, mesa ;
int opc, pos, rpta ;

do {
switch ( opc ) {
case 1: // Ingreso de datos
ingresarDatos ( ) ;
acceso = true ;
menu = menu2 ;
break ;

case 2: // Mostrar datos generales
if ( acceso ) {
mostrarDatosGenerales ( ) ;
} else {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
break ;

Pg. 251

..

case 3: // Mostrar datos invididuales
if ( acceso ) {
mesa = LE.leerString ( "Ingrese el Nro de la mesa: " ) ;
pos = buscarMesa ( mesa ) ;
if ( pos != -1 ) {
mostrarDatosIndividuales ( pos ) ;
} else {
LE.mostrarError ( "Error, el Nro de mesa ingresado es incorrecto;
"" reintente" ) ;
}
} else {
LE.mostrarError ("Error, la opcin ingresada es incorrecta; reintente") ;
}
break ;

case 4: // Utilizar mesa
if ( acceso ) {
mesa = LE.leerString ( "Ingrese el Nro de la mesa: " ) ;
if ( pos != -1 ) {
utilizarMesa ( pos ) ;
} else {
"" reintente" ) ;
}
} else {
}
break ;

case 5: // Calcular ganancias
if ( acceso ) {
menuCalculos ( ) ;
} else {
}
break ;

case 6: // Ordenar datos
if ( acceso ) {
menuOrdenar ( ) ;
} else {
}
break ;

case 7: // Modificar datos
if ( acceso ) {
mesa = LE.leerString ("Ingrese el Nro de mesa que desea modificar") ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2 ( "Desea modificar los datos de la
"" mesa: " + datos[pos][0] ) ;
if ( rpta == 0 ) {

Pg. 252

..
menuModificar ( pos ) ;
} else {
LE.mostrarAdvertencia ( "La operacin fue cancelada" ) ;
}
} else {
LE.mostrarError ( "Error, el Nro de la mesa es incorrecto; reintente") ;
}
} else {
}
break ;

case 8: // Eliminar datos
if ( acceso ) {
mesa = LE.leerString ("Ingrese el Nro de mesa que desea eliminar" ) ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2( "Desea eliminar los datos de la
"" mesa: " + datos[pos][0] ) ;
if ( rpta == 0 ) {
eliminarDatos ( pos ) ;
} else {
}
} else {
LE.mostrarError ( "Error, el Nro de la mesa es incorrecto; reintente") ;
}
} else {
}
if ( numMesa == 0 ) {
acceso = false ;
menu = menu1 ;
}
break ;

case 0: // Finalizar operacin
LE.mostrarAdvertencia ( "La operacin ha sido finalizada" ) ;
break ;
default :
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente") ;
break ;
}
} while ( opc != 0 ) ;
} // Fin menu

int rpta ;
do {
if ( numMesa == clientes.length ) {
}
clientes[numMesa] = "Vaco" ;
int mesa = 0 ;

Pg. 253

..

do {
do {
do {
datos[numMesa][0] = LE.leerString ( "Ingrese el Nro de Mesa del cliente "
"" ) ;
if ( !datos[numMesa][0].matches( "[0-9]+" ) ) {
LE.mostrarError ( "Error, el tipo de dato ingresado es incorrecto;
"" reintente" ) ;
}
} while ( !datos[numMesa][0].matches( "[0-9]+" ) ) ;

mesa = Integer.parseInt( datos[numMesa][0] ) ;
if ( mesa < 1 ) {
"" reintente" ) ;
}
} while ( mesa < 1 ) ;

if ( buscarMesa (datos[numMesa][0]) != -1 ) {
LE.mostrarError ( "Error, el Nro de mesa ingresado ya existe; reintente" );
}
} while ( buscarMesa(datos[numMesa][0]) != -1 ) ;

datos[numMesa][1] = "0" ;
datos[numMesa][2] = "0" ;

numMesa++ ;
rpta = LE.mostrarPreguntaOpcion2 ( "Desea agregar ms mesas?" ) ;

} while ( rpta == 0 ) ;
} // Fin ingresarDatos

public int buscarMesa ( String mesa ) {
int pos = -1 ;
for ( int i = 0; i < numMesa; i++ ) {
if ( mesa.equalsIgnoreCase(datos[i][0]) ) {
pos = i ;
break ;
}
}
return pos ;
} // Fin buscarMesa

public void aumentarTamaoArreglo ( ) {
String clien[] = new String[clientes.length + 10] ;
String dat[][] = new String[clientes.length + 10][3] ;
clien[i] = clientes[i] ;
for ( int j = 0; j < 3; j++ ) {
dat[i][j] = datos[i][j] ;
}
}

Pg. 254

..
clientes = clien ;
datos = dat ;
} // Fin aumentarTamaoArreglo

for ( int i = pos; i < numMesa; i++ ) {
clientes[i] = clientes[i + 1] ;
for ( int j = 0; j < 3; j++ ) {
datos[i][j] = datos[i + 1][j] ;
}
}
numMesa-- ;
} // Fin eliminarDatos

public void menuModificar ( int pos ) {
int subOpc ;
String subMenu = "********-- Modificar Datos --********\n"
+ "-----------------------------------------------------------\n"
+ "ltimo cliente que us la mesa: "
+ clientes[pos]
+ "\n"
+ "Nro de Mesa: "
+ datos[pos][0]
+ "\n"
+ "Cuenta acumulada: "
+ "S/."
+ datos[pos][2]
+ "\n\n"
+ "[1] Modificar todos los datos de mesa \n"
+ "[2] Modificar nmero de mesa\n"
+ "[3] Regresar al men principal\n"
+ "-----------------------------------------------------------\n"
+ "Elija opcin deseada:\n";

do {
subOpc = LE.leerInt ( subMenu ) ;
switch ( subOpc ) {
case 1 :
modificarDatosGenerales ( pos ) ;
break ;

case 2 :
modificarDatosIndividuales ( pos ) ;
break ;

case 3 :
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente" ) ;

Pg. 255

..
}
} while ( subOpc != 3 && subOpc != 2 && subOpc != 1 ) ;
}// Fin menuModificar

public void modificarDatosIndividuales ( int pos ) {
double mesa = 0 ;
do {
do {
datos[pos][0] = LE.leerString ( "Ingrese el nuevo Nro de mesa" ) ;
if ( !datos[pos][0].matches ( "[0-9]+" ) ) {
LE.mostrarError ( "Error, el tipo de dato ingresado es incorrecto; reintente" ;
}
} while ( !datos[pos][0].matches ( "[0-9]+" ) ) ;
mesa = Integer.parseInt( datos[pos][0] ) ;
if ( mesa < 1 ) {
LE.mostrarError ( "Error, el Nro de mesa ingresado es incorrecto; reintente");
}
} while ( mesa < 1 ) ;
} // Fin modificarDatosIndividuales

public void modificarDatosGenerales ( int pos ) {
modificarDatosIndividuales ( pos ) ;
double saldo = 0 ;
do {
do {
datos[pos][2] = LE.leerString ( "Ingrese el nuevo saldo acumulado de la mesa
"" Nro" + " " + datos[pos][0] ) ;
LE.mostrarError ( "Error, el tipo de dato ingresado es incorrecto; reintente" );
}
saldo = Integer.parseInt(datos[pos][2] ) ;
if ( saldo < 1 ) {
LE.mostrarError ( "Error, el saldo ingresado es incorrecto; reintente" ) ;
}
} while ( saldo < 1 ) ;
} // Fin modificarDatosGenerales

public void menuOrdenar ( ) {
int subOpc ;
String subMenu = "*********** BOHEMIA RESTAURANT & MAS ************\n"
+ "-----------------------------------------------------------------\n"
+ "[1] Ordenar alfabticamente \n"
+ "[2] Ordenar de acuerdo al Nro de mesas \n"
+ "[3] Regresar al menu principal \n"
+ "-----------------------------------------------------------------\n"
+ "Elejir opcin deseada: \n" ;
do {
switch ( subOpc ) {
case 1 :
ordenarPorNombre ( ) ;

Pg. 256

..
break ;

case 2 :
ordenarPorMesa ( ) ;
break ;

case 3 :
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta" ) ;
}
} while ( subOpc != 3 ) ;
} // Fin menuOrdenar

public void ordenarPorNombre ( ) {
String cliente ;
String dato ;
for ( int i = 0; i < numMesa - 1; i++ ) {
for ( int j = i + 1; j < numMesa; j++ ) {
if ( clientes[i].compareToIgnoreCase ( clientes[j]) > 0 ) {
cliente = clientes[i] ;
clientes[i] = clientes[j] ;
clientes[j] = cliente ;
for ( int k = 0; k < 3; k++ ) {
dato = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dato ;
}
}
}
}
} // Fin ordenarPorNombre

public void ordenarPorMesa ( ) {
String cliente, dato ;
int temp1, temp2 ;
for ( int i = 0; i < numMesa - 1; i++ ) {
temp1 = Integer.parseInt( datos[i][0] ) ;
for ( int j = i + 1; j < numMesa; j++ ) {
temp2 = Integer.parseInt ( datos[j][0] ) ;
if ( temp1 > temp2 ) {
cliente = clientes[i] ;
clientes[i] = clientes[j] ;
clientes[j] = cliente ;
for ( int k = 0; k < 3; k++ ) {
}
}

Pg. 257

..
}
}

} // Fin ordenarPorMesa

public void mostrarDatosGenerales ( ) {
String listado = " " ;
listado = "Nombre del cliente || Nro mesa || Cta. actual del cliente || Cta.
qqq total acumulada por cliente \n----------------------------------------------------------
"" ------------------------------------------------------\n" ;
listado = listado + "\n" ;

listado = listado + completarConBlancosXDer ( clientes[i], 45 ) ;
for ( int j = 0; j < 3; j++ ) {
if ( j > 0 ) {
listado = listado + completarConBlancosXDer ( "S/." + datos[i][j], 35 ) ;
} else {
listado = listado + completarConBlancosXDer ( datos[i][j], 35 ) ;
}
}
}
listado = listado + "-------------------------------------------------------------------------------------
"" -----------------------------\n" ;

} // Fin mostrarDatosGenerales

public void mostrarDatosIndividuales ( int pos ) {
String listado = " " ;
listado = "Nombre del cliente || Nro mesa || Cta. actual del cliente || Cta.
q qqtotal acumulada por cliente \n-----------------------------------------------------------
"" -----------------------------------------------------\n" ;

listado = listado + completarConBlancosXDer ( clientes[pos], 45 )
+ completarConBlancosXDer ( datos[pos][0], 35 )
+ completarConBlancosXDer ( "S/." + datos[pos][1], 35 )
+ completarConBlancosXDer ( "S/." + datos[pos][2], 35 ) ;

} // Fin mostrarDatosIndividuales

public void utilizarMesa ( int pos ) {
do {
do {
clientes[pos] = LE.leerString ( "Ingrese el nombre del cliente: " ) ;
clientes[pos] = clientes[pos].trim ( ) ;

Pg. 258

..
clientes[pos] = clientes[pos].toUpperCase ( ) ;
if (!clientes[pos].matches ( "[A-Z]+" ) ) {
LE.mostrarError ("Error, el tipo de dato ingresado es incorrecto; reintente") ;
}
} while ( !clientes[pos].matches ( "[A-Z]+" ) ) ;
String letra, resto ;
letra = clientes[pos].substring (0, 1) ;
letra = letra.toUpperCase ( ) ;
resto = clientes[pos].substring(1) ;
resto = resto.toLowerCase ( ) ;
clientes[pos] = letra + resto ;
if (clientes[pos].length ( ) < 3) {
LE.mostrarError ( "Error, el nombre ingresado es incorrecto; reintente" ) ;
}
} while ( clientes[pos].length ( ) < 3 ) ;

double costoAcu = Double.parseDouble ( datos[pos][2] ) ;
double suma = 0 ;
double costo ;

do {
costo = LE.leerDouble ( "Ingrese el monto a pagar " ) ;
if ( costo < 0 ) {
LE.mostrarError ( "Error, el monto ingresado es incorrecto, reintente" ) ;
}
} while ( costo < 0 ) ;

suma = costoAcu + costo ;
datos[pos][1] = String.valueOf ( costo ) ;
datos[pos][2] = String.valueOf ( suma ) ;
menuMesa ( pos ) ;

} // Fin utilizarMesa

public void masPedidos ( int pos ) {
double costoPos = Double.parseDouble ( datos[pos][1] ) ;
double costoAcu = Double.parseDouble ( datos[pos][2] ) ;
double suma1 = 0, suma2 = 0 ;
double costo ;
do {
costo = LE.leerDouble ( "Ingrese el monto a pagar" ) ;
if ( costo < 0 ) {
LE.mostrarError ( "Error, el monto ingresado es incorrecto, reintente" ) ;
}
} while ( costo < 0 ) ;
suma1 = costoPos + costo ;
suma2 = costoAcu + costo ;
datos[pos][1] = String.valueOf ( suma1 ) ;
datos[pos][2] = String.valueOf ( suma2 ) ;
menuMesa ( pos ) ;
} // Fin masPedidos


Pg. 259

..
public void menuMesa ( int pos ) {
+ "------------------------------------------------------------------\n"
+ "Cliente: "
+ clientes[pos]
+ "\n"
+ "Nro de mesa: "
+ datos[pos][0]
+ "\n"
+ "Saldo actual: S/."
+ datos[pos][1]
+ "\n\n"
+ "[1] Realizar ms pedidos a la mesa \n"
+ "[2] Cancelar el saldo de la cuenta acumulada\n"
+ "------------------------------------------------------------------\n"

int subOpc ;
do {
switch ( subOpc ) {
case 1 :
masPedidos ( pos ) ;
break ;

case 2 :
LE.mostrarAdvertencia ( " Su cuenta fue cancelada " ) ;
LE.mostrarAdvertencia ( " Gracias por su preferencia, regrese pronto " ) ;
datos[pos][1] = String.valueOf ( 0 ) ;
break ;
default :
LE.mostrarError ( " Error, la opcin ingresada es incorrecta; reintente " ) ;
}
} while ( subOpc != 1 && subOpc != 2 ) ;

} // Fin menuMesa

public void menuCalculos ( ) {
String subMenu = "*********** BOHEMIA RESTAURANT & MAS ************\n"
+ "-------------------------------------------------------------------------\n"
+ "[1] Calcular ganancia por mesa \n"
+ "[2] Calcular ganancia total \n"
+ "[3] La mesa con la cuenta acumulada ms alta \n"
+ "[4] La mesa con la cuenta acumulada ms baja \n"
+ "[5] Regresar al men principal \n"
+ "-------------------------------------------------------------------------\n"
+ "Seleccione la opcin deseada: \n" ;
String mesa ;
int subOpc, pos ;

do {
switch ( subOpc ) {
case 1 :

Pg. 260

..
mesa = LE.leerString ( "Ingrese el Nro de mesa " ) ;
if ( pos != -1 ) {
gananciaPorMesa ( pos ) ;
} else {
LE.mostrarError ( "Error, el Nro de mesa es incorrecto; reintente" ) ;
}
break ;

case 2 :
gananciaTotal ( ) ;
break ;

case 3 :
cuentaMayor ( ) ;
break ;

case 4 :
cuentaMenor ( ) ;
break ;

case 5 :
break ;
default :
}
}

public void gananciaPorMesa ( int pos ) {
LE.mostrarInformacion ( "La ganancia de la mesa Nro: " + datos[pos][0] + " es:
"" S/." + datos[pos][2] ) ;
} // Fin gananciaPorMesa

public void gananciaTotal ( ) {
double sumaTotal = 0 ;
double cantidad = 0 ;

cantidad = Double.parseDouble ( datos[i][2] ) ;
sumaTotal = sumaTotal + cantidad ;
}
LE.mostrarInformacion ( "La ganancia total es: S/. " + sumaTotal ) ;

} // Fin gananciaTotal

public void cuentaMayor ( ) {
double mayor = 0, actual ;
int pos = -1 ;
actual = Double.parseDouble ( datos[i][2] ) ;

Pg. 261

..
if ( mayor < actual ) {
mayor = actual ;
pos = i ;
}
}

} // Fin cuentaMayor

public void cuentaMenor ( ) {
double menor = 999999999, actual ;
int pos = -1 ;
actual = Double.parseDouble ( datos[i][2] ) ;
if ( menor > actual ) {
menor = actual ;
pos = i ;
}
}

} // Fin cuentaMenor

cadena += " " ;
}
return cadena ;
} // Fin completarConBlancosXDer
} // Fin de clase


Pg. 262

Problema 030

Enunciado:
La empresa La Moderna SA, se dedica a la venta de equipos de todo tipo. Hace unos das
han detectado algunos problemas en su inventario y desean realizar una aplicacin que les
permita mantenerlo actualizado. El sobrino del gerente de la empresa, estudiante de la FIA,
le ha recomendado que utilice el lenguaje de programacin Java y sugiera se desarrolle la
aplicacin utilizando las siguientes estructuras de datos:

Dados los arreglos:

nombres datos
nom CA (0) PC (1) PV (2)
0 0
1 1
2 2
3 3
: : : :
: : : :
numEqu = 0
9999 9999 (int)

(String) (String)

Donde: numEqu permite almacenar el nmero de tipos de equipos en inventario.

nom= Nombre del tipo de equipo.

CA = Cantidad de equipos de un determinado tipo.

PC = Precio de Compra de un tipo de equipo.

PV = Precio de Venta de un tipo de equipo.

Desarrolle una solucin utilizando mtodos y un men de opciones.


Clase PrgInventario
..


public class PrgInventario {

int numEqu ;
String nombres[ ] ;

Pg. 263

Clase PrgInventario
..

public static void main ( String[] args ) {
PrgInventario obj = new PrgInventario ( ) ;
obj.menu ( ) ;
}

public PrgInventario ( ) {
numEqu = 0 ;
nombres = new String[10000] ;
} // Fin PrgInventario

String menu1 = "************--:MENU PRINCIPAL:--************\n"
+ "-----------------------------------------------------------\n"
+ "[1] Ingresar datos \n"
+ "[0] Salir de aplicacin \n"
+ "-----------------------------------------------------------\n"
+ "Elija opcin deseada: \n";
String menu2 = "************--:MENU PRINCIPAL:--************\n"
+ "-----------------------------------------------------------\n"
+ "[1] Ingresar datos \n"
+ "[2] Mostrar datos\n"
+ "[3] Mostrar datos individuales\n"
+ "[4] Obtener utilidades\n"
+ "[5] Ordenar datos\n"
+ "[6] Modificar datos\n"
+ "[7] Eliminar datos\n"
+ "[0] Salir de aplicacin \n"
+ "------------------------------------------------------------\n"
+ "Elija opcin deseada: \n" ;

int opc, pos, rpta ;
String nom, menu = menu1 ;

do {
opc = LE.leerInt (menu) ;
switch (opc) {
case 1 : /* Ingresar datos */
ingresarDatos ( ) ;
acceso = true ;
menu = menu2 ;
break ;

case 2 : /* Mostrar datos */
if (acceso) {
} else {
}
break ;

Pg. 264

Clase PrgInventario
..

case 3 : /* Mostrar datos individuales */
if ( acceso ) {
nom = LE.leerString ( "Ingrese el nombre del equipo: " ) ;
nom = nom.trim ( ) ;
pos = buscar (nom) ;
if ( pos != -1 ) {
} else {
LE.mostrarError ( "Error, el nombre del equipo es incorrecto; reintente" ) ;
}
} else {
}
break ;

case 4 : /* Obtener utilidad */
if ( acceso ) {
menuUtilidades ( ) ;
} else {
}
break ;

case 5 : /* Ordenar Datos */
if ( acceso ) {
menuOrdenar ( ) ;
} else {
}
break ;

case 6 : /* Modificar Datos */
if ( acceso ) {
nom = LE.leerString ( "Ingrese el nombre del equipo que desea modificar: "
"" ) ;
pos = buscar (nom) ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2 ( " Desea modificar los datos de
"" equipos de: " + nombres[pos] ) ;
if ( rpta == 0 ) {
menuModificar ( pos ) ;
} else {
LE.mostrarAdvertencia ( " La operacin fue cancelada " ) ;
}
} else {
LE.mostrarError ( "Error, el nombre ingresado del equipo es incorrecto;
qqqqqqqqqqqqqqqqqqqqqqqqqqreintente " ) ;
}
} else {
}
break ;


Pg. 265

Clase PrgInventario
..
case 7 : /* Eliminar Datos */
if ( acceso ) {
nom = LE.leerString ( "Ingrese el nombre del equipo que desea eliminar " ) ;
pos = buscar ( nom ) ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2 ( "Desea eliminar los datos de
"" equipos de: " + nombres[pos] ) ;
if ( rpta == 0 ) {
eliminarDatos ( pos ) ;
} else {
}
} else {
LE.mostrarError ( "Error, el nombre ingresado del equipo es incorrecto;
qqqqqqqqqq qreintente" ) ;
}
} else {
}
if ( numEqu == 0 ) {
acceso = false ;
menu = menu1 ;
}
break ;

case 0 : /* Finalizar operacin */
LE.mostrarAdvertencia ( "La operacin ha finalizado" ) ;
break ;
default :
}
} while ( opc != 0 ) ;
} // Fin men principal

public void agrandarTamaoArreglo ( ) {
String nom[] = new String[nombres.length + 10] ;
String dat[][] = new String[nombres.length + 10][3] ;
for ( int i = 0; i < numEqu; i++ ) {
nom[i] = nombres[i] ;
for ( int j = 0; j < 3; j++ ) {
}
}
nombres = nom ;
datos = dat ;
}

public int buscar ( String nom ) {
int pos = -1 ;
if ( nom.equalsIgnoreCase ( nombres[i] ) ) {
pos = i ;

Pg. 266

Clase PrgInventario
..
break ;
}
}
return pos ;
} // Fin buscar

String lista = " " ;
lista = "Nombre de Equipo || Cantidad || Precio de Compra || Precio de
qqqqqqqqqVenta\n" + "--------------------------------------------------------------------------------------
"" ----------------------\n" ;
lista = lista + "\n" ;
lista = lista + completarConBlancosXDer ( nombres[i], 35 ) ;
for ( int j = 0; j < 3; j++ ) {
if ( j > 0 ) {
lista = lista + completarConBlancosXDer ( "S/." + datos[i][j], 35 ) ;
} else {
lista = lista + completarConBlancosXDer ( datos[i][j], 35 ) ;
}
}
}
lista = lista + "--------------------------------------------------------------------------------------------
"" -----------------\n" ;

String lista = "" ;
lista = "Nombre de Equipo || Cantidad || Precio de Compra || Precio de
qqqqqqqqqVenta\n" + "---------------------------------------------------------------------------------\n" ;
lista = lista + completarConBlancosXDer ( nombres[pos], 20 )
+ completarConBlancosXDer ( datos[pos][0], 30 )
+ completarConBlancosXDer ( "S/." + datos[pos][1], 30 )
+ completarConBlancosXDer ( "S/." + datos[pos][2], 30 ) ;
lista = lista + "---------------------------------------------------------------------------------------\n" ;

public void ordenarPorNombre ( ) {
String nombre ;
String dato ;
for ( int i = 0; i < numEqu - 1; i++ ) {
for ( int j = i + 1; j < numEqu; j++ ) {
if ( nombres[i].compareToIgnoreCase ( nombres[j]) > 0 ) {
nombres[i] = nombres[j] ;
nombres[j] = nombre ;
for ( int k = 0; k < 3; k++ ) {

Pg. 267

Clase PrgInventario
..
}
}
}
}
} // Fin ordenarPorNombre

public void ordenarPorCantidad ( ) {
String nombre ;
String dato ;
int cant1, cant2 ;
cant1 = Integer.parseInt ( datos[i][0] ) ;
cant2 = Integer.parseInt ( datos[j][0] ) ;
if ( cant1 > cant2 ) {
for ( int k = 0; k < 3; k++ ) {
}
}
}
}
LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;
} // Fin ordenarPorCantidad

public void ordenarPorPrecioCompra ( ) {
String nombre ;
String dato ;
int precioCom1, precioCom2 ;
precioCom1 = Integer.parseInt ( datos[i][1] ) ;
precioCom2 = Integer.parseInt ( datos[j][1] ) ;
if ( precioCom1 > precioCom2 ) {
for ( int k = 0; k < 3; k++ ) {
}
}
}
}

Pg. 268

Clase PrgInventario
..
} // Fin ordenarPorPrecioCompra

public void ordenarPorPrecioVenta ( ) {
String nombre ;
String dato ;
int precioVen1, precioVen2 ;
precioVen1 = Integer.parseInt ( datos[i][2] ) ;
precioVen2 = Integer.parseInt ( datos[j][2] ) ;
if ( precioVen1 > precioVen2 ) {
for ( int k = 0; k < 3; k++ ) {
}
}
}
}
} // Fin ordenarPorPrecioVenta

for ( int i = pos; i < numEqu; i++ ) {
nombres[i] = nombres[i + 1] ;
for ( int j = 0; j < 3; j++ ) {
}
}
numEqu-- ;

String subMenu = "********--Ordenar Datos--********\n"
+ "----------------------------------------\n"
+ "[1] Ordenar alfabticamente \n"
+ "[2] Ordenar por cantidades \n"
+ "[3] Ordenar de acuerdo a precios de compra\n"
+ "[4] Ordenar de acuerdo a precios de venta\n"
+ "----------------------------------------\n"
int subOpc ;
do {
switch ( subOpc ) {
case 1 :

Pg. 269

Clase PrgInventario
..
ordenarPorNombre ( ) ;
break ;

case 2 :
ordenarPorCantidad ( ) ;
break ;

case 3 :
ordenarPorPrecioCompra ( ) ;
break ;

case 4 :
ordenarPorPrecioVenta ( ) ;
break ;

case 5 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta, reintente" ) ;
}
} // Fin menuOrdenar

public void menuUtilidades ( ) {
String subMenu = "********-- Obtener Utilidad --********\n"
+ "-------------------------------------\n"
+ "[1] Utilidad por Equipo \n"
+ "[2] Utilidad General de Equipos\n"
+ "[3] Equipo que tiene la utilidad ms alta\n"
+ "[4] Equipo que tiene la utilidad ms baja\n"
+ "[5] Regresar al Men principal\n"
+ "-------------------------------------\n"
String nombre ;
int subOpc, pos ;
do {
switch ( subOpc ) {
case 1 :
nombre = LE.leerString ( "Ingrese el nombre del equipo que desea obtener su
qqqqqqqqqqqqqqqqqqqqqqqqqqqutilidad: " ) ;
nombre = nombre.trim ( ) ;
pos = buscar ( nombre ) ;
if ( pos != -1 ) {
utilidadEquipo ( pos ) ;
} else {
LE.mostrarError ( "Error, el nombre del equipo es incorrecto; reintente" ) ;
}
break ;

Pg. 270

Clase PrgInventario
..

case 2 :
utilidadTotal ( ) ;
break ;

case 3 :
utilidadAlta ( ) ;
break ;

case 4 :
utilidadBaja ( ) ;
break ;

case 5 :
break ;
default :
}
} // Fin menuUtilidades

+ "-----------------------------------------------------------\n"
+ "Equipo: "
+ "\t"
+ nombres[pos]
+ "\n"
+ "Cantidad: "
+ "\t"
+ datos[pos][0]
+ "\n"
+ "Precio de compra: "
+ "\t"
+ datos[pos][1]
+ "\n"
+ "Precio de venta:"
+ "\t"
+ datos[pos][2]
+ "\n\n"
+ "[1] Modificar todos los datos \n"
+ "[2] Modificar datos complementarios de equipo\n"
+ "[3] Regresar al Men principal\n"
+ "-----------------------------------------------------------\n"
+ "Seleccione la opcin deseada:\n" ;
int subOpc ;
do {
switch ( subOpc ) {
case 1 :
modificarDatosGenerales ( pos ) ;
break ;


Pg. 271

Clase PrgInventario
..
case 2 :
modificarDatosComplementarios ( pos ) ;
break ;

case 3 :
break ;
default :
}
} while ( subOpc != 3 && subOpc != 2 && subOpc != 1 ) ;
} // Fin menuMmodificar

do {
do {
nombres[pos] = LE.leerString ( " Ingrese el nuevo nombre del equipo " ) ;
nombres[pos]=nombres[pos].trim ( ) ;
nombres[pos]=nombres[pos].toUpperCase ( ) ;
if ( !nombres[pos].matches ( "[A-Z]+" ) ) {
LE.mostrarError ( " El tipo de dato ingresado es incorrecto; reintente " ) ;
}
} while ( !nombres[pos].matches ( "[A-Z]+" ) ) ;
if ( nombres[pos].length ( ) < 3 ) {
LE.mostrarError ( " Error, el nombre ingresado es incorrecto, reintente " ) ;
}
} while ( nombres[pos].length ( ) < 3 ) ;
nombres[pos] = context ( nombres[pos] ) ;

public void modificarDatosComplementarios ( int pos ) {
do {
datos[pos][0] = LE.leerString ( "Ingrese la nueva cantidad de equipos de: " +
qqqqqnombres[pos] ) ;
LE.mostrarError ( "Error, La cantidad ingresada es incorrecta; reintente " ) ;
}
do {
datos[pos][1] = LE.leerString ( "Ingrese el nuevo precio de compra de equipos
"" de: " + nombres[pos] ) ;
if ( !datos[pos][1].matches ( "[0-9]+" ) || datos[pos][1].compareToIgnoreCase (
qqqqqqqqdatos[pos][1] ) > 0 ) {
LE.mostrarError ( " Error, La cantidad ingresada es incorrecta; reintente " ) ;
}
} while ( !datos[pos][1].matches ( "[0-9]+" ) || datos[pos][1].compareToIgnoreCase
( qqqqqqqqqqqdatos[pos][1] ) > 0 ) ;
do {
datos[pos][2] = LE.leerString ( "Ingrese el nuevo precio de venta de equipos de:
"" "+ nombres[pos] ) ;
if ( !datos[pos][2].matches ( "[0-9]+" ) || datos[pos][2].compareToIgnoreCase(
qqqqqqqqdatos[pos][1] ) <= 0 ) {

Pg. 272

Clase PrgInventario
..
LE.mostrarError ( "Error, La cantidad ingresada es incorrecta; reintente" ) ;
}
} while ( !datos[pos][2].matches ( "[0-9]+" ) || datos[pos][2].compareToIgnoreCase (
qqqqqqqqqqdatos[pos][1] ) <= 0 ) ;
} // Fin modificarDatosComplementarios

int rpta ;

do {
if ( numEqu == nombres.length ) {
agrandarTamaoArreglo ( ) ;
}
do {
do {
nombres[numEqu] = LE.leerString ( " Ingrese nombre del equipo Nro " +
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq(numEqu + 1 ) ) ;
nombres[numEqu] = nombres[numEqu].trim ( ) ;
nombres[numEqu] = nombres[numEqu].toUpperCase ( ) ;
if ( !nombres[numEqu].matches ( "[A-Z]+" ) ) {
LE.mostrarError ( "Error, el tipo de dato ingresado es incorrecto;
"" reintente" ) ;
}
} while ( !nombres[numEqu].matches ( "[A-Z]+" ) ) ;
if ( buscar (nombres[numEqu]) != -1 || nombres[numEqu].length ( ) < 3 ) {
LE.mostrarError ( "Error, el nombre ingresado es incorrecto, reintente " ) ;
}
} while ( buscar (nombres[numEqu]) != -1 || nombres[numEqu].length ( ) < 3 ) ;
nombres[numEqu] = context ( nombres[numEqu] ) ;

int cantidad = 0, precioCompra = 0, precioVenta = 0 ;

do {
do {
datos[numEqu][0] = LE.leerString ( "Ingrese la cantidad de equipos de: " +
"" + nombres[numEqu] ) ;
if ( !datos[numEqu][0].matches ( "[0-9]+" ) ) {
LE.mostrarError ( " Error, el tipo de dato ingresado es incorrecto;
"" reintente" ) ;
}
} while ( !datos[numEqu][0].matches ( "[0-9]+" ) ) ;
cantidad = Integer.parseInt ( datos[numEqu][0] ) ;
if ( cantidad < 1 ) {
LE.mostrarError ( "Error, la cantidad ingresada es incorrecta; reintente" ) ;
}
} while ( cantidad < 1 ) ;

do {
do {
datos[numEqu][1] = LE.leerString ( "Ingrese el precio de compra de equipos
"" de:" + nombres[numEqu] ) ;

Pg. 273

Clase PrgInventario
..
"" reintente " ) ;
}
precioCompra = Integer.parseInt ( datos[numEqu][1] ) ;
if ( precioCompra < 1 ) {
LE.mostrarError ( " Error, el precio de compra ingresado es incorrecto;
"" reintente " ) ;
}
} while ( precioCompra < 1 ) ;

do {
do {
datos[numEqu][2] = LE.leerString ( "Ingrese el precio de venta de equipos
"" de: " + nombres[numEqu]);
"" reintente " ) ;
}
precioVenta = Integer.parseInt ( datos[numEqu][2] ) ;
if ( precioVenta <= precioCompra ) {
LE.mostrarError ( "Error, el precio de venta ingresado es incorrecto;
"" reintente " ) ;
}
} while ( precioVenta <= precioCompra ) ;

numEqu++ ;
rpta = LE.mostrarPreguntaOpcion2 ( " Desea agregar ms datos? " ) ;

} while ( rpta == 0 ) ;
} // Fin de ingreso

public void utilidadEquipo ( int pos ) {
double utilidad, precioCompra = 0, precioVenta = 0, cantidad = 0 ;
precioCompra = Double.parseDouble ( datos[pos][1] ) ;
precioVenta = Double.parseDouble ( datos[pos][2] ) ;
cantidad = Double.parseDouble ( datos[pos][0] ) ;
precioCompra = precioCompra * cantidad ;
precioVenta = precioVenta * cantidad ;
utilidad = precioVenta - precioCompra ;
LE.mostrarInformacion ( "La utilidad de equipos de: " + ( nombres[pos] + " es: " +
qqq utilidad ) ) ;
} // Fin utilidadEquipo

public void utilidadTotal ( ) {
double utilidadTotal = 0, precioVentaTotal = 0, precioCompraTotal = 0 ;
double precioCompra, precioVenta, cantidad ;

cantidad = Double.parseDouble ( datos[i][0] ) ;
precioCompra = Double.parseDouble ( datos[i][1] ) ;
precioVenta = Double.parseDouble ( datos[i][2] ) ;
precioCompraTotal = precioCompraTotal + ( cantidad * precioCompra ) ;

Pg. 274

Clase PrgInventario
..
precioVentaTotal = precioVentaTotal + ( cantidad * precioVenta ) ;
}
utilidadTotal = precioVentaTotal - precioCompraTotal ;
LE.mostrarInformacion ( " La utilidad total es: " + utilidadTotal ) ;

} // Fin utilidadTotal

public void utilidadAlta ( ) {
double utilidad[ ] = new double[numEqu] ;
double mayor = 0, precioCompra = 0, precioVenta = 0 ;
utilidad[i] = precioVenta - precioCompra ;
}
int pos = -1 ;
for ( int j = 0; j < numEqu; j++ ) {
if ( mayor < utilidad[j] ) {
mayor = utilidad[j] ;
pos = j ;
}
}
} // Fin utilidadAlta

public void utilidadBaja ( ) {
double utilidad[] = new double[numEqu] ;
double menor = 999999999, precioCompra = 0, precioVenta = 0 ;
utilidad[i] = precioVenta - precioCompra ;
}
int pos = -1 ;
for ( int j = 0; j < numEqu; j++ ) {
if ( menor > utilidad[j] ) {
menor = utilidad[j] ;
pos = j ;
}
}
} // Fin utilidadBaja

public String context ( String nom ) {
letra = nom.substring ( 0, 1 ) ;
resto = nom.substring(1) ;
nom = letra + resto ;
return nom ;
} // Fin context

Pg. 275

Clase PrgInventario
..

cadena += " " ;
}
return cadena ;
} // Fin de clase


Pg. 276

Problema 031

Enunciado:
En las siguientes estructuras se tienen almacenados los nombres, las direcciones y distritos
de los domicilios, los DNI, y los sueldos de los trabajadores de una empresa. Desarrollar una
aplicacin utilizando mtodos y un men de opciones que permita manejar los datos
almacenados.

Dados los arreglos:

datos DNI sueldos

nom (0) dir (1) dis (2)

0

1

2
numEmp = 0

: : : : :
(int)

: : : : :

9999
: : : : :

(String) (long) (double)

Donde: numEmp permite almacenar el nmero de trabajadores de la empresa.

nom= Nombre del trabajador.

dir = Direccin del trabajador.

dis = Distrito donde vive el trabajador.


Clase PrgEmpresa
..


import javax.swing.* ;

public class PrgEmpresa {

int numEmp ;
long dni[ ] ;
double sueldos[ ] ;

PrgEmpresa obj = new PrgEmpresa ( ) ;
obj.menu ( ) ;

Pg. 277

Clase PrgEmpresa
..
}

public PrgEmpresa ( ) {
numEmp = 0 ;
dni = new long[10000] ;
sueldos = new double[10000] ;
}

String menu = "************--: EMPRESA S.A :--************\n"
+ "-----------------------------------------------------------\n"
+ "[1] Ingreso de usuario \n"
+ "[2] Ingreso de administrador \n"
+ "[3] Finalizar \n"
+ "-----------------------------------------------------------\n"
int opc ;
do {

opc = LE.leerInt (menu) ;
switch (opc) {
case 1: /* Ingreso de usuario */
menuUser ( ) ;
break ;

case 2: /* Ingreso de administrador */
menuAdmin ( ) ;
break ;

case 3: /* Finalizar operacin */
LE.mostrarAdvertencia ( " La operacin fue finalizada " ) ;
break ;
default:
}
} while ( opc != 3 ) ;
} // Fin menu

public void menuUser ( ) {
String menu1 = "************--: EMPRESA S.A :--************\n"
+ "-----------------------------------------------------------\n"
+ "Bienvenido usuario \n"
+ " [1] Ingresar datos \n"
+ " [0] Regresar men principal \n"
+ "-----------------------------------------------------------\n"


Pg. 278

Clase PrgEmpresa
..

String menu2 = "************--: MENU PRINCIPAL :--************\n"
+ "--------------------------------------------------------------\n"
+ "Bienvenido usuario \n"
+ " [2] Mostrar datos generales\n"
+ " [3] Mostrar datos individuales\n"
+ " [4] Calculos generales\n"
+ " [5] Ordenar datos\n"
+ " [0] Regresar men principal \n"
+ "------------------------------------------------------------\n"

int opc ;
String menu ;

if (numEmp > 0) {
menu = menu2 ;
acceso = true ;
} else {
menu = menu1;
acceso = false ;
}
do {
switch ( opc ) {
case 1 : /* Ingresar datos */
ingresoDeDatos ( ) ;
acceso = true ;
menu = menu2 ;
break ;

case 2 : /* Mostrar datos generales */
if ( acceso ) {
} else {
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente " ) ;
}
break ;

case 3 : /* Mostrar Datos Individuales */
if ( acceso ) {
String nom1 = LE.leerString ( "Ingrese el nombre del empleado: " ) ;
nom1 = nom1.trim ( ) ;
int pos1 = buscar ( nom1 ) ;
if ( pos1 != -1 ) {
mostrarDatosIndividuales ( pos1 ) ;
} else {
LE.mostrarError ( "Error, el nombre del empleado es incorrecto; reintente
"" " ) ;
}
} else {
}

Pg. 279

Clase PrgEmpresa
..
break ;

case 4 : /* Clculos generales */
if (acceso) {
menuCalculosGenerales ( ) ;
} else {
}
break ;

case 5 : /* Ordenar Datos */
if ( acceso ) {
menuOrdenar ( ) ;
} else {
}
break ;

case 0 : /* Finalizar operacin */
LE.mostrarAdvertencia ( " La operacin ha finalizado " ) ;
break ;

default :
}
} while ( opc != 0 ) ;
} // Fin menu usuario

public void menuAdmin ( ) {
String password = "123456" ;
String pass ;
int intento = 0 ;

do {
pass = LE.leerString ( " Ingrese password de administrador: " ) ;

if ( pass.equalsIgnoreCase ( password ) ) {
String menuadmin = "***********--: MENU PRINCIPAL :--************\n"
+ "--------------------------------------------------------------\n"
+ "Bienvenido administrador\n"
+ " [2] Mostrar datos \n"
+ " [3] Buscar datos \n"
+ " [4] Ordenar datos\n"
+ " [5] Modificar datos\n"
+ " [6] Eliminar datos\n"
+ " [0] Regresar al men principal \n"
+ "--------------------------------------------------------------\n"

int opc ;
do {
opc = LE.leerInt ( menuadmin ) ;
switch ( opc ) {

Pg. 280

Clase PrgEmpresa
..
case 1 : /* Ingreso de datos */
ingresoDeDatos ( ) ;
break ;

case 2 : /* Mostrar datos generales */
break ;

case 3 : /* Buscar Datos */
String nom1 = LE.leerString ( "Ingrese el nombre del empleado que
"" desea buscar: " ) ;
if ( pos1 != -1 ) {
mostrarDatosIndividuales ( pos1 ) ;
} else {
LE.mostrarError ( "Error, el nombre del empleado es incorrecto;
"" reintente " ) ;
}
break ;

case 4 : /* Ordenar datos */
menuOrdenar ( ) ;
break ;

case 5 : /* Modificar datos */
String nom2 = LE.leerString ( "Ingrese nombre del empleado a modificar:
"" " ) ;

if ( pos2 != -1 ) {
int rpta2 = LE.mostrarPreguntaOpcion2( "Desea modificar los datos
"" del empleado: " +
"" datos[pos2][0] ) ;
if ( rpta2 == 0 ) {
menuModificar ( pos2 ) ;
} else {
LE.mostrarAdvertencia ( " operacin fue cancelada " ) ;
}
} else {
"" reintente " ) ;
}
break ;

case 6 : /* Eliminar datos */
String nom3 = LE.leerString ( " Ingrese el nombre del empleado que
"" desea eliminar " ) ;
if ( pos3 != -1 ) {
int rpta3 = LE.mostrarPreguntaOpcion2 ( "Desea eliminar los datos del
q empleado: " +
"" datos[pos3][0] ) ;

Pg. 281

Clase PrgEmpresa
..
if ( rpta3 == 0 ) {
eliminarDatos ( pos3 ) ;
} else {
LE.mostrarAdvertencia ( " La operacin fue cancelada " ) ;
}
} else {
"" reintente " ) ;
}
if ( numEmp == 0 ) {
opc = 0 ;
}
break ;

case 0 : /* Regresar men principal */
break ;
default :
LE.mostrarError ( " La opcin ingresada es incorrecta; reintente " ) ;
}
} while ( opc != 0 ) ;
break ;
} else {
LE.mostrarError ( "Error, el password ingresado es incorrecto " ) ;
}
intento++ ;
if ( intento == 3 ) {
LE.mostrarAdvertencia ( "Usted ha superado el mximo de intentos
"" permitidos" ) ;
}
} while ( intento != 3 ) ;

} // Fin menu administrador

public void ingresoDeDatos ( ) {
int rpta ;
do {
if ( numEmp == dni.length ) {
agrandarTamaoArreglo ( ) ;
}
// Ingreso de nombre
do {
do {
datos[numEmp][0] = LE.leerString ( "Ingrese nombre del empleado Nro: " +
"" ( numEmp + 1 ) ) ;
datos[numEmp][0] = datos[numEmp][0].trim ( ) ;
datos[numEmp][0] = datos[numEmp][0].toUpperCase ( ) ;
if ( !datos[numEmp][0].matches ( "[A-Z]+ " ) ) {
"" reintente " ) ;
}
} while ( !datos[numEmp][0].matches ( "[A-Z]+" ) ) ;

if ( buscar (datos[numEmp][0]) != -1 || (datos[numEmp][0].length ( ) < 3 ) ){

Pg. 282

Clase PrgEmpresa
..
LE.mostrarError ( " Error, el nombre ingresado es incorrecto, reintente " ) ;
}
} while ( buscar (datos[numEmp][0]) != -1 || (datos[numEmp][0].length ( ) < 3 ) );
datos[numEmp][0] = contexto( datos[numEmp][0] ) ;
// Ingreso de direccin
do {
datos[numEmp][1] = LE.leerString ( " Ingrese la direccin del empleado: " +
q datos[numEmp][0] ) ;

if ( datos[numEmp][1].length ( ) < 4 ) {
LE.mostrarError ( " Error, la direccin ingresada es incorrecta, reintente " ) ;
}
} while (datos[numEmp][1].length ( ) < 4 ) ;
datos[numEmp][1] = contexto ( datos[numEmp][1] ) ;
// Ingreso de distrito
do {
datos[numEmp][2] = LE.leerString ( "Ingrese el distrito del empleado: " +
q datos[numEmp][0]) ;

if ( datos[numEmp][2].length ( ) < 3 ) {
LE.mostrarError ( " Error, el distrito ingresado es incorrecto, reintente " ) ;
}
} while (datos[numEmp][2].length ( ) < 3 ) ;
datos[numEmp][2] = contexto ( datos[numEmp][2] ) ;
// Ingreso de DNI en String
String dnitemp ;
do {
do {
dnitemp = LE.leerString ( "Ingrese el D.N.I del empleado: " +
q datos[numEmp][0] ) ;

if ( !dnitemp.matches ( "[0-9]{8}" ) ) {
LE.mostrarError ( " Error, el DNI ingresado es incorrecto; reintente " ) ;
}
} while ( !dnitemp.matches ( "[0-9]{8}" ) ) ;

dni[numEmp] = Long.parseLong ( dnitemp ) ;

if ( buscarDni ( dni[numEmp] ) != -1 ) {
LE.mostrarError ( "Error, el DNI ingresado ya pertenece a un empleado
q registrado; reintente " ) ;
}
} while ( buscarDni ( dni[numEmp] ) != -1 ) ;
// Ingreso del sueldo
do {
sueldos[numEmp] = LE.leerDouble ( " Ingrese el sueldo del empleado: " + (
q datos[numEmp][0] ) ) ;
if (sueldos[numEmp] < 1 ) {
LE.mostrarError ( " Error, el sueldo ingresado es incorrecto; reintente " ) ;
}
} while ( sueldos[numEmp] < 1 ) ;

numEmp++ ;

Pg. 283

Clase PrgEmpresa
..

rpta = LE.mostrarPreguntaOpcion2 ( "Desea aadir ms datos? " ) ;
} while ( rpta == 0 ) ;

} // Fin ingresoDeDatos

public int buscar ( String nom ) {
int pos = -1 ;
for ( int i = 0; i < numEmp; i++ ) {
if (nom.equalsIgnoreCase(datos[i][0]) ) {
pos = i ;
break ;
}
}
return pos ;
} // Fin buscar

public long buscarDni ( long c ) {
int pos = -1 ;
if ( c == dni[i] ) {
pos = i ;
break ;
}
}
return pos ;
} // Fin buscarDNI

public void agrandarTamaoArreglo ( ) {
String dat[][] = new String[dni.length + 10][3] ;
long dnitemp[] = new long[dni.length + 10] ;
double suel[] = new double[dni.length + 10] ;
for ( int j = 0; j < 3; j++ ) {
}
dnitemp[i] = dni[i] ;
suel[i] = sueldos[i] ;
}
datos = dat ;
dni = dnitemp ;
sueldos = suel ;
}

String submenu = "********--Ordenar Datos--********\n"
+ "----------------------------------------------------------\n"
+ "[1] Ordenar por nombres \n"
+ "[2] Ordenar por distrito \n"
+ "[3] Ordenar por escala de sueldos\n"

Pg. 284

Clase PrgEmpresa
..
+ "----------------------------------------------------------\n"
int subopc ;
do {
subopc = LE.leerInt (submenu) ;
switch (subopc) {
case 1 :
ordenarporNombre ( ) ;
break ;

case 2 :
ordenarporDistrito ( ) ;
break ;

case 3 :
ordenarporSueldos ( ) ;
break ;

case 4 :
break ;

default :
LE.mostrarError ( " Error, la opcin ingresada es incorrecta, reintente " ) ;
}
} while ( subopc != 4 ) ;
} // Fin menu ordenar

public void ordenarporNombre ( ) {
long dnitemp ;
double suel ;
String dat ;
for ( int i = 0; i < numEmp - 1; i++ ) {
for ( int j = i + 1; j < numEmp; j++ ) {
if ( datos[i][0].compareToIgnoreCase(datos[j][0]) > 0 ) {
for ( int k = 0; k < 3; k++ ) {
dat = datos[i][k] ;
datos[j][k] = dat ;
}
dnitemp = dni[i] ;
dni[i] = dni[j] ;
dni[j] = dnitemp ;

suel = sueldos[i] ;
sueldos[i] = sueldos[j] ;
sueldos[j] = suel ;
}
}
}
LE.mostrarAdvertencia ( " Los datos fueron ordenados con xito " ) ;

Pg. 285

Clase PrgEmpresa
..
} // Fin ordenarporNombre

public void ordenarporDistrito ( ) {
long dnitemp ;
double suel ;
String dat ;
if ( datos[i][2].compareToIgnoreCase( datos[j][2] ) > 0 ) {
for ( int k = 0; k < 3; k++ ) {
dat = datos[i][k] ;
datos[j][k] = dat ;
}
dnitemp = dni[i] ;
dni[i] = dni[j] ;
dni[j] = dnitemp ;

suel = sueldos[i] ;
sueldos[j] = suel ;
}
}
}

} // Fin ordenarporDistrito

public void ordenarporSueldos ( ) {
long dnitemp ;
double suel ;
String dat ;
if ( sueldos[i] > sueldos[j] ) {
dnitemp = dni[i] ;
dni[i] = dni[j] ;
dni[j] = dnitemp ;

suel = sueldos[i] ;
sueldos[j] = suel ;

for ( int k = 0; k < 3; k++ ) {
dat = datos[i][k] ;
datos[j][k] = dat ;
}
}
}
}


Pg. 286

Clase PrgEmpresa
..
} // Fin ordenarporSueldos

for ( int i = pos; i < numEmp; i++ ) {
for ( int j = 0; j < 3; j++ ) {
}
dni[i] = dni[i + 1] ;
sueldos[i] = sueldos[i + 1] ;
}
numEmp-- ;

String submenu = "********-- Modificar Datos --********\n"
+ "---------------------------------------------------------------\n"
+ "Nombre del empleado: "
+ "\t"
+ datos[pos][0]
+ "\n"
+ "Domicilio: "
+ "\t"
+ datos[pos][1]
+ "\n"
+ "Distrito: "
+ "\t"
+ datos[pos][2]
+ "\n"
+ "DNI: "
+ "\t"
+ dni[pos]
+ "\n"
+ "Sueldo actual: "
+ "\t"
+ "S/."
+ sueldos[pos]
+ "\n\n"
+ "[1] Modificar todos los datos del empleado \n"
+ "[2] Modificar datos complementarios del empleado\n"
+ "---------------------------------------------------------------\n"
+ "Seleccione la opcin deseada:\n" ;

int subopc ;
do {
subopc = LE.leerInt (submenu) ;
switch (subopc) {
case 1 :
modificarDatosGenerales(pos) ;
break ;

case 2 :

Pg. 287

Clase PrgEmpresa
..
modificarDatosComplementarios(pos) ;
break ;

case 3 :
break ;

default :
}
} while ( subopc != 3 && subopc != 2 && subopc != 1 ) ;

} // Fin menu modificar

public void modificarDatosComplementarios ( int pos ) {
do {
datos[pos][1] = LE.leerString ( " Ingrese la nueva direccin del empleado: " +
q datos[pos][0] ) ;
datos[pos][1] = datos[pos][1].trim ( ) ;
if ( datos[pos][1].length ( ) < 4 ) {
LE.mostrarError ( " Error, la direccin ingresada es incorrecta; reintente " ) ;
}
} while ( datos[pos][1].length ( ) < 4 ) ;

datos[pos][1] = contexto( datos[pos][1] ) ;

do {
datos[pos][2] = LE.leerString ("Ingrese el distrito del empleado: " +datos[pos][0]) ;
LE.mostrarError ( " Error, el distrito ingresado es incorrecto; reintente " ) ;
}


String dnitemp ;
do {
dnitemp = LE.leerString ( "Ingrese el DNI del empleado: " + datos[numEmp][0]) ;
if ( !dnitemp.matches ( "[0-9]{8}" ) ) {
LE.mostrarError ( " Error, el DNI ingresado es incorrecto; reintente " ) ;
}
} while ( !dnitemp.matches ( "[0-9]{8}" ) ) ;

dni[pos] = Long.parseLong ( dnitemp ) ;

do {
sueldos[pos] = LE.leerDouble ( " Ingrese el nuevo sueldo del empleado: " +
q datos[pos][0] ) ;
if ( sueldos[pos] < 1 ) {
LE.mostrarError ( " Error, el sueldo ingresado es incorrecto; reintente " ) ;
}
} while ( sueldos[pos] < 1 ) ;


Pg. 288

Clase PrgEmpresa
..
LE.mostrarAdvertencia ( " Los datos fueron modificados con xito " ) ;

} // Fin modificarDatosComplementarios

do {
do {
datos[pos][0] = LE.leerString ( " Ingrese el nuevo nombre del empleado " ) ;
datos[pos][0] = datos[pos][0].toUpperCase ( ) ;
if ( !datos[pos][0].matches ( "[A-Z]+" ) ) {
LE.mostrarError ("Error, el tipo de dato ingresado es incorrecto; reintente") ;
}
} while ( !datos[pos][0].matches ( "[A-Z]+" ) ) ;
LE.mostrarError ( " Error, el nombre ingresado es incorrecto; reintente " ) ;
}



JTextArea muestraInformacion = new JTextArea (20, 48) ;
JScrollPane desplazaInformacion = new JScrollPane(muestraInformacion) ;

String listado ;
listado = "Nombres || Direccin || Distrito || DNI
"" || Sueldo\n + ------------------------------------------------------------------------
"" -----------------------------------------------\n" ;

for ( int j = 0; j < 3; j++ ) {
listado = listado + completarConBlancosXDer( datos[i][j], 25 ) ;
}
listado = listado + completarConBlancosXDer( "" + dni[i], 30 ) +
"" completarConBlancosXDer( "S/. " + sueldos[i], 30 ) ;
}
listado = listado + "\n" + "-----------------------------------------------------------------------------
"" ------------------------------------------\n" + "\n" + " || El total de empleados
"" registrados son " + (numEmp) ;

muestraInformacion.append( listado ) ;
JOptionPane.showMessageDialog (null, desplazaInformacion, "LISTA DE
"" EMPLEADOS",
"" JOptionPane.INFORMATION_MESSAGE ) ;


Pg. 289

Clase PrgEmpresa
..
JTextArea muestraInformacion = new JTextArea ( 10, 48 ) ;
JScrollPane desplazaInformacion = new JScrollPane ( muestraInformacion ) ;

String listado ;
listado = "Nombres || Direccin || Distrito || DNI
"" || Sueldo \n"+ "---------------------------------------------------------------------
"" ------------------------------------------------\n" ;

listado = listado + completarConBlancosXDer( datos[pos][0], 25 )
+ completarConBlancosXDer( datos[pos][1], 25 )
+ completarConBlancosXDer( datos[pos][2], 25 )
+ completarConBlancosXDer( "" + dni[pos], 30 )
+ completarConBlancosXDer( "S/. " + sueldos[pos], 30 ) ;
listado = listado + "\n"
+ "-----------------------------------------------------------------------------------------------
"" ------------------------\n"
+ "\n"
+ " || El empleado se encuentra en la "" posicin "
+ pos ;
muestraInformacion.append( listado ) ;
JOptionPane.showMessageDialog (null, desplazaInformacion, "LISTA DE
"" EMPLEADOS",
"" JOptionPane.INFORMATION_MESSAGE) ;


public void menuCalculosGenerales ( ) {
String submenu = "********--Clculos Generales--********\n"
+ "-------------------------------------------------------------\n"
+ "[1] Clculo del empleado con el sueldo ms alto \n"
+ "[2] Clculo del empleado con el sueldo ms bajo \n"
+ "[3] Calculo total de sueldos a pagar por la empresa\n"
+ "-------------------------------------------------------------\n"

int subopc ;
do {
subopc = LE.leerInt ( submenu ) ;
switch (subopc) {
case 1 :
sueldoMayor ( ) ;
break ;

case 2 :
sueldoMenor ( ) ;
break ;

case 3 :
totalSueldos ( ) ;
break ;

Pg. 290

Clase PrgEmpresa
..

case 4 :
break ;

default :
LE.mostrarError ( " Error, la opcin ingresada es incorrecta, reintente " ) ;
}
} while ( subopc != 4 ) ;
} // Fin menu calculos generales

public void sueldoMayor ( ) {
double mayor = 0 ;
int pos = -1 ;
if ( mayor < sueldos[i] ) {
mayor = sueldos[i] ;
pos = i ;
}
}
mostrarDatosIndividuales(pos) ;
} // Fin sueldoMayor

public void sueldoMenor ( ) {
double menor = 999999999 ;
int pos = -1 ;
if ( menor > sueldos[i] ) {
menor = sueldos[i] ;
pos = i ;
}
}
mostrarDatosIndividuales( pos ) ;
} // Fin sueldoMenor

public void totalSueldos ( ) {
double total = 0 ;
total = total + sueldos[i] ;
}
LE.mostrarInformacion ( " El total a pagar a los empleados es: S/. " + total ) ;
} // Fin totalSueldos

public String contexto ( String nom ) {
letra = nom.substring(0, 1) ;
resto = nom.substring(1) ;
nom = letra + resto ;
return nom ;
} // Fin contexto

Pg. 291

Clase PrgEmpresa
..

cadena += " " ;
}
return cadena ;

} // Fin de clase


Pg. 292

Problema 032

Enunciado:
La institucin educativa Carreras del maana desea implementar un sistema que les permita
manejar de manera ptima los datos de sus postulantes. Entre sus principales requerimientos
se tiene que solo ingresan aquellos postulantes que superen el puntaje mnimo, que es los
700 puntos. Se debe considerar que el puntaje obtenido de cada postulante debe ser
generado de forma aleatoria. Y una vez generado dicho puntaje se debe registrar su situacin
(ingresante o no ingresante).

Para desarrollar dicho sistema se plantea utilizar la siguiente grfica de estructura de datos.

datos

Nombre sexo edad

codigo

0 1 1

puntaje

situacion
0 0 0 0
1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
: : : : : : : : :
:
99999

99999

99999

99999

(int)

(String)

(int)

(String)

Donde: numPos: Almacena el nmero de postulantes.
codigo: Almacenan los cdigos de los postulantes.
puntaje: Almacena el puntaje de los postulantes.
situacion: Almacena la situacin de ingresantes y no ingresantes de los postulantes.
datos: Matriz que almacena 3 datos para cada postulante:
nombre: Almacena todos los nombres de los postulantes.
sexo: Almacena los sexos respectivos de los postulantes.
edad: Almacena la edad de todos los postulantes.

numPos = 0
(int)


Pg. 293


Clase PrgPostulantes



public class PrgPostulantes {
String datos[][];
String situacion[];
int puntaje[];
int codigo[];
int conta;

public PrgPostulantes ( ){
datos= new String[1000][3];
situacion=new String[1000];
puntaje=new int[1000];
codigo=new int [1000];
conta=0;
}

PrgPostulantes obj = new PrgPostulantes ( );
obj.mostrarMenu ( );
}

public void mostrarMenu ( ){
char opc;
char fin = ' ';

String menu = "Menu Principal\n";
menu += "---------------------------------\n";
menu += "[1] Ingreso de Datos\n";
menu += "[2] Mostrar Datos\n";
menu += "[3] Ordenar Datos\n";
menu += "[4] Modificar Datos\n";
menu += "[5] Eliminar\n";
menu += "[6] Mostrar lista de Ingresantes\n";
menu += "[7] Mostrar el puntaje ms alto y el ms bajo\n";
menu += "[S] Salir\n";
menu += "---------------------------------\n";
menu += "Seleccione la opcin deseada:";

do{
opc = Character.toUpperCase(LE.leerChar(menu));
switch(opc){
case '1': ingresarDatos ( );
break;

case '2': mostrarListado ( );

Pg. 294

break;

case '3': Ordenar ( );
break;

case '4': Modificar ( );
break;

case '5': Eliminar ( );
break;

case '6': MostrarIngresantes ( );
break;

case '7': MayorMenor ( );
break;

default: LE.mostrarError ("Lo sentimos, la opcin ingresada es incorrecta");
}
}while(opc!='S' && fin!='F');

}

public void Modificar ( ){

String menu = "Menu Modificar\n"
+ "--------------------------------\n"
+ "[1] Modificar datos generales\n"
+ "[2] Modificar Puntaje\n"
+ "[R] Modificar Puntaje\n"
+ "--------------------------------\n"
+ "Seleccione su opcin";

char opc;
char fin = ' ';

do {
opc = LE.leerChar(menu);
switch (opc) {
case '1':
int cod;
do{
cod = LE.leerInt ("Ingrese el cdigo del postulante que desea modificar :");
if((cod<1000 || cod>9999)){
LE.mostrarAdvertencia ("Lo sentimos, los cdigos de postulante estan
"" entre 1000 y 9999");
}
}while((cod<1000 || cod>9999));
int pos = buscarXCodigo(cod);
if (pos!=-1){
int resp = LE.mostrarPreguntaOpcion2("Desea modificar los datos del
"" postulante: " + datos[pos][0]);
if (resp==0){
do{
datos[pos][0]=LE.leerString ("Ingrese el nuevo nombre y apellidos del
"" postulante con cdigo:" +

Pg. 295

"" codigo[pos]).toUpperCase ( );
if(!datos[pos][0].matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][A-
"" Z]+){0,1}")){
LE.mostrarAdvertencia ("Lo sentimos, los datos ingresados son
"" incorrectos!");
}
}while(!datos[pos][0].matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][A-
"" Z]+){0,1}"));
do{
datos[pos][1]=LE.leerString ("Ingrese el sexo del postulante: \n [F]:
"" Femenino \n [M]:
"" Masculino").toUpperCase ( );
if(!datos[pos][1].matches("[FM]")){
LE.mostrarAdvertencia ("Lo sentimos, el caracter ingresado es
"" incorrecto!");
}
}while(!datos[pos][1].matches("[FM]"));
do{
datos[pos][2]=LE.leerString ("Ingrese la nueva edad del postulante:");
if(!datos[pos][2].matches("[0123456789][0123456789]")){
LE.mostrarAdvertencia ("Lo sentimos, la edad que ha ingresado es
"" incorrecta!") ;
}
}while(!datos[pos][2].matches("[0123456789][0123456789]"));

}else{
LE.mostrarAdvertencia ("Usted cancel la operacin");
}

}else{
LE.mostrarInformacion ("Lo sentimos, el cdigo ingresado no existe!");
}
break;

case '2':
do{
cod = LE.leerInt ("Ingrese codigo del postulante que desea modificar :");
if((cod<1000 || cod>9999)){
LE.mostrarAdvertencia ("Lo sentimos, los cdigos de postulante estan
"" entre 1000 y 9999");
}
}while((cod<1000 || cod>9999));
pos = buscarXCodigo(cod);

if (pos!=-1){
int resp = LE.mostrarPreguntaOpcion2("Desea modificar el puntaje del
"" postulante: " + datos[pos][0]);
if (resp==0){
puntaje[pos]=LE.leerInt ("Ingrese el nuevo puntaje del postulante: ");
if(puntaje[pos]>=700){
situacion[pos]="Ingreso";
}else{
situacion[pos]="No ingreso";
}
}else{
LE.mostrarAdvertencia ("Usted cancel la operacin");
}

Pg. 296

}else{
}
break;

default:
LE.mostrarAdvertencia ("Lo sentimos, la opcin ingresada es incorrecta!");
break;
}
}while(opc!='R' && fin!='F');
}//Fin de Mtodo Modificar

public int buscarXCodigo (int codBus){
for (int i = 0 ;i<conta;i++){
if (codigo[i] == codBus){
return i;
}
}
return -1;
}

public int buscarXNombre (String nomBus){
for (int i = 0 ;i<conta;i++){
if (datos[i][0].equalsIgnoreCase(nomBus)){
return i;
}
}
return -1;
}

public void generarPuntaje ( ){
for(int i=0;i<conta;i++){
int valor=(int)(Math.random ( )*(1000-500+1)+500);
puntaje[i]=valor;
}
}

public void leerPuntaje ( ){
int i=0;
for(;i<conta;i++){
if(puntaje[i]>=700){
situacion[i]="Ingreso";
}else{
situacion[i]="No ingreso";
}
}
}

public void ingresarDatos ( ){
int resp;
do{
do{


Pg. 297


codigo[conta]=LE.leerInt ("Ingrese el codigo del Postulante: ");
if(codigo[conta]<1000 || codigo[conta]>9999){
LE.mostrarAdvertencia ("Lo sentimos, los cdigos de postulante estan entre
"" 1000 y 9999");
}
if(buscarXCodigo(codigo[conta])!=-1){
LE.mostrarAdvertencia ("Lo sentimos, el cdigo ingresado ya existe en
"" nuestra base de datos!");
}
}while((codigo[conta]<1000 || codigo[conta]>9999) ||
"" buscarXCodigo(codigo[conta])!=-1);

do{
datos[conta][0]=LE.leerString ("Ingrese el nombre y apellidos del postulante con
"" cdigo:" + codigo[conta]).toUpperCase ( );
if(!datos[conta][0].matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][A-
"" Z]+){0,1}")){
LE.mostrarAdvertencia ("Lo sentimos, los datos ingresados son
"" incorrectos!");
}
}while(!datos[conta][0].matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][A-
"" Z]+){0,1}"));

do{
datos[conta][1]=LE.leerString ("Ingrese el sexo del postulante: \n [F]: Femenino
"" \n [M]:Masculino").toUpperCase ( );
if(!datos[conta][1].matches("[FM]")){
LE.mostrarAdvertencia ("Lo sentimos, el caracter ingresado es incorrecto!");
}
}while(!datos[conta][1].matches("[FM]"));

do{
datos[conta][2]=LE.leerString ("Ingrese la edad del postulante:");
if(!datos[conta][2].matches("[0123456789][0123456789]")){
LE.mostrarAdvertencia ("Lo sentimos, la edad que ha ingresado es
"" incorrecta!");
}
}while(!datos[conta][2].matches("[0123456789][0123456789]"));
LE.mostrarAdvertencia ("Los datos del estudiante: "+ datos[conta][0] + " fueron
"" registrados de forma exitosa!");
conta++;
resp = LE.mostrarPreguntaOpcion2("Desea aadir otro postulante?");

}while(resp==0);
generarPuntaje ( );
leerPuntaje ( );
}

public void OrdenarCodigos ( ){
for (int i=0;i<conta-1;i++){
for (int j=i+1;j<conta;j++){
if (codigo[i]>codigo[j]){
int aux = codigo[i];
codigo[j] = aux;


Pg. 298


String aux2 = datos[i][0];
datos[i][0] = datos[j][0];
datos[j][0] = aux2;

datos[j][1] = aux3;

datos[j][2] = aux4;

int aux5 = puntaje[i];
puntaje[i]=puntaje[j];
puntaje[j]=aux5;

String aux6 = situacion[i];
situacion[i]=situacion[j];
situacion[j]=aux6;

}
}
}
String lis = "Listado de alumnos Ordenados Por Codigos\n\n";
for (int i =0;i<conta;i++){
lis += (i+1)+") "+codigo[i]+"-->"+datos[i][0]+" "+"("+datos[i][1]+") "+datos[i][2]+"
"" Resultado--> "+puntaje[i]+"-->"+situacion[i]+"\n";
}
LE.mostrarResultado(lis);
}

public void OrdenarNombres ( ){
for (int i=0;i<conta-1;i++){
for (int j=i+1;j<conta;j++){
if (datos[i][0].compareTo(datos[j][0])>0){
datos[j][0] = aux2;

datos[j][1] = aux3;

datos[j][2] = aux4;

int aux = codigo[i];
codigo[j] = aux;

int aux5 = puntaje[i];
puntaje[i]=puntaje[j];
puntaje[j]=aux5;


Pg. 299


String aux6 = situacion[i];
situacion[i]=situacion[j];
situacion[j]=aux6;
}
}
}
String lis = "Listado de alumnos Ordenados Por Codigos\n\n";
lis += (i+1)+") "+codigo[i]+"-->"+datos[i][0]+" "+"("+datos[i][1]+") "+datos[i][2]+"
"" Resultado--> "+puntaje[i]+"-->"+situacion[i]+"\n";
}
}

public void MostrarIngresantes ( ){
String list = "Listado de Ingresantes\n"+
"------------------------------\n"+
"Cdigo:\t\t Nombres y Apellidos:\t\t Sexo:\t\t Edad:\t\t Puntaje\t\t
"" Situacion: \n";
if(puntaje[i]>=700){
list +=+codigo[i]+"\t\t\t "+datos[i][0]+"\t\t\t "+datos[i][1]+" \t\t\t"+datos[i][2]+"
"" \t\t\t "+puntaje[i]+"\t\t\t "+situacion[i]+"\n";
}
}
LE.mostrarResultado(list);
}

public void Ordenar ( ){
char opc;
char fin = ' ';
String menu = "Menu Ordenar\n";
menu += "-----------------------------\n";
menu += "[1] Por codigos\n";
menu += "[2] Por Nombres\n";
menu += "[R] regresar\n";
menu += "-----------------------------\n";

do{
switch(opc){
case '1':OrdenarCodigos ( );break;

case '2': OrdenarNombres ( );break;
}
}

public void Eliminar ( ){
char opc;
char fin = ' ';
String menu = "Menu Eliminar\n";


Pg. 300


menu += "-----------------------------\n";
menu += "[1] Por codigos\n";
menu += "[2] Por Nombres\n";
menu += "[3] Los que no ingresaron\n";
menu += "[R] Regresar\n";
menu += "-----------------------------\n";
do{
switch(opc){
case '1':EliminarCodigo ( );
break;

case '2':EliminarNombre ( );
break;

case '3':ElminarNoingresantes ( );
break;
}

}

public void EliminarNombre ( ){
String nomBus;

do{
nomBus = LE.leerString ("Ingrese el nombre del postulante que desea eliminar
"" :").toUpperCase ( );
if(!nomBus.matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][A-Z]+){0,1}")){
LE.mostrarAdvertencia ("Lo sentimos, los datos ingresados son incorrectos!");
}
}while(!nomBus.matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][A-Z]+){0,1}"));
int pos = buscarXNombre(nomBus);

if (pos!=-1){
int resp = LE.mostrarPreguntaOpcion2("Esta seguro que desea eliminar:\n"+
"\tCodigo :"+codigo[pos]+"\n"+
"\tNombre :"+datos[pos][0]+"\n");
if (resp==0){
eliminarGen(pos);
}
}else{
}
}

public void EliminarCodigo ( ){
int cod;
do{
cod = LE.leerInt ("Ingrese el cdigo del postulante que desea eliminar :");
if((cod<1000 || cod>9999)){


Pg. 301


LE.mostrarAdvertencia ("Lo sentimos, los cdigos de postulantes estn entre
"" 1000 y 9999");
}
}while((cod<1000 || cod>9999));
int pos = buscarXCodigo(cod);
if (pos!=-1){
int resp = LE.mostrarPreguntaOpcion2("Esta seguro que desea eliminar:\n"+
"\tCodigo :"+codigo[pos]+"\n"+
"\tNombre :"+datos[pos][0]+"\n");
if (resp==0){
eliminarGen(pos);
}

}else{
LE.mostrarInformacion ("Codigo Inexistente !");
}
}

public void eliminarGen (int pos){
for (int i=pos;i<conta-1;i++){
codigo[i] = codigo[i+1];
datos[i][0] = datos[i+1][0];
situacion[i]=situacion[i+1];
puntaje[i]=puntaje[i+1];
}
conta--;
}

public void ElminarNoingresantes ( ){
if(situacion[i].equalsIgnoreCase("No ingreso")){
eliminarGen(i);
}
}
mostrarListado ( );
}

public void mostrarListado ( ){
String lis = "Listado de alumnos\n"+
"--------------------------\n"+
"" Situacion: \n";
lis +=+codigo[i]+"\t\t\t "+datos[i][0]+"\t\t\t "+datos[i][1]+" \t\t\t"+datos[i][2]+" \t\t\t
"" "+puntaje[i]+"\t\t\t "+situacion[i]+"\n";
}
}


Pg. 302


public void MayorMenor ( ){
int may=0,men=1000;
String resultados="";
may=Math.max(may,puntaje[i]);
men=Math.min(men,puntaje[i]);
}
String lis = "El puntaje ms alto es:\n"+
"--------------------------\n"+
"" Situacion: \n";
String lis2 = "El puntaje ms bajo es:\n"+
"--------------------------\n"+
"" Situacion: \n";
if(puntaje[i]==may){
lis +=+codigo[i]+"\t\t\t "+datos[i][0]+"\t\t\t "+datos[i][1]+" \t\t\t"+datos[i][2]+" \t\t\t
"" "+puntaje[i]+"\t\t\t "+situacion[i]+"\n";
}
if(puntaje[i]==men){
lis2 +=+codigo[i]+"\t\t\t "+datos[i][0]+"\t\t\t "+datos[i][1]+" \t\t\t"+datos[i][2]+"
"" \t\t\t "+puntaje[i]+"\t\t\t "+situacion[i]+"\n";
}
}
resultados=lis+lis2;
LE.mostrarResultado(resultados);
}
}


Pg. 303

Problema 033

Enunciado:
La empresa de transportes Norteito S.A ha automatizado su servicio de transporte
interprovincial de pasajeros dotando a cada una de sus unidades (buses) con una
computadora porttil. Desarrolle una solucin que permita manejar los datos del servicio
brindado y permita controlar las ganancias de la empresa en base a las rutas parciales que
cubre especificadas en el siguiente cuadro:

N RUTAS PARCIALES COSTO
1 Lima Trujillo S/. 10.00
2 Lima Chiclayo S/. 15.00
3 Trujillo Chiclayo S/. 5.00
4 Chiclayo Trujillo S/. 5.00
5 Chiclayo Lima S/. 15.00
6 Trujillo Lima S/. 10.00


datos

documento nombre

0 1

ruta
0 0
1 1
2 2
3 3
4 4
: : : : :
99999

99999

(String)

(int)

Donde: numPas: Almacena el nmero pasajeros.
ruta: Almacena todas las rutas disponibles.
costo: Almacena los costos de las rutas disponibles.
datos: Matriz que almacena 3 datos para cada pasajero:
documento: Almacena todos los documentos de los pasajeros.
nombre: Almacena todos los nombres de los pasajeros.

numPas = 0
(int)


Pg. 304


Clase PrgNorteito



public class PrgNorteito {

String datos[][];
int ruta[];
int numPas;
int contaMen;


PrgNorteito oBarranquita = new PrgNorteito ( );
oBarranquita.menu ( );
}// Fin mtodo Main

public PrgNorteito ( ) {

datos = new String[10][2];
ruta = new int[10];
numPas = 0;
contaMen = 1000;
}// Fin Mtodo Constructor


String menu1 = " NORTEITO S.R.L. \n"
+ "------------------------------------ \n"
+ "[1] Ingresar Datos del Pasajero \n" + "[0] Finalizar \n"
+ "------------------------------------ \n"
+ "Seleccione su opcin \n";

String menu2 = " NORTEITO S.R.L. \n"
+ "------------------------------------ \n"
+ "[1] Ingresar Datos del Pasajero \n" + "[2] Mostrar Datos \n"
+ "[3] Modificar Datos \n" + "[4] Eliminar Datos \n"
+ "[5] Ordenar Datos \n"
+ "[6] Obtener Cantidad de Pasajeros por Ruta \n"
+ "[7] Obtener Ganancias totales \n" + "[0] Finalizar \n"
+ "------------------------------------ \n"
+ "Seleccione su opcin \n";

int opc;
String menu = menu1;
boolean sw = false;

do {
opc = LE.leerInt (menu);
switch (opc) {
case 1:

Pg. 305

Clase PrgNorteito
ingresar ( );
menu = menu2;
sw = true;
break;

case 2:
if (sw) {
mostrar ( );
} else {
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada.");
}
break;

case 3:
if (sw) {
modificar ( );
} else {
}
break;

case 4:
if (sw) {
eliminar ( );
if (numPas == 0) {
sw = false;
menu = menu1;
}
} else {
LE .mostrarError("Lo sentimos, su solicitud no puede ser procesada.");
}
break;

case 5:
if (sw) {
ordenar ( );
} else {
}
break;

case 6:
if (sw) {
calcularPasajeroPorRuta ( );
} else {
}
break;

case 7:
if (sw) {
calcularGananciaPorRuta ( );
} else {
}
break;


Pg. 306

Clase PrgNorteito
case 0:
finalizar ( );
break;

default:
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada");
break;
}// Fin de Switch
} while (opc != 0);
}// Fin menu


int pos;
int rpta;

do {
if (numPas == ruta.length) {
aumentarArreglo ( );
}

rpta = LE.mostrarPreguntaOpcion2("Usted es mayor de edad?");

if (rpta == 0) {

do {
do {
datos[numPas][0] = LE .leerString("Ingrese su nmero de DNI");
pos = buscar (datos[numPas][0]);
if (pos != -1) {
LE.mostrarError ("Lo sentimos, el nmero de DNI ya existe en
"" nuestra base de datos");
}
} while (pos != -1);

if (!datos[numPas][0].matches("[0-9]{8}")) {
LE.mostrarError ("Lo sentimos, el nmero de DNI debe contener 8
"" caracteres");
}

} while (!datos[numPas][0].matches("[0-9]{8}"));

} else {

datos[numPas][0] = String.valueOf(contaMen);
}// Fin de ingreso de dni

do {
datos[numPas][1] = LE.leerString ("Ingrese su nombre");
datos[numPas][1] = datos[numPas][1].trim ( );

if (datos[numPas][1].length ( ) < 2) {
LE.mostrarError ("Lo sentimos, el nombre tiene que contener ms de 2
"" caracteres");
}
} while (datos[numPas][1].length ( ) < 2);

Pg. 307

Clase PrgNorteito

do {
ruta[numPas] = LE.leerInt ("NORTEITO S.R.L \n"
+ "[1] Lima - Huacho \n" + "[2] Lima - Barranca \n"
+ "[3] Huacho -Barranca \n"
+ "[4] Barranca - Huacho \n" + "[5] Barranca - Lima \n"
+ "[6] Huacho - Lima \n"
+ "---------------------------- \n"
+ "Seleccione su Ruta");
if (1 > ruta[numPas] || ruta[numPas] > 6) {
LE.mostrarError ("Lo sentimos, la ruta que eligi no existe");
}
} while (1 > ruta[numPas] || ruta[numPas] > 6); // Fin de Ingreso de
// Ruta

numPas++;
contaMen++;

rpta = LE.mostrarPreguntaOpcion2("Desea ingresar otro pasajero?");

}// Fin mtodo Ingresar

public void aumentarArreglo ( ) {

String dat[][] = new String[ruta.length + 5][2];
int rut[] = new int[ruta.length + 5];

for (int i = 0; i < rut.length; i++) {
dat[i][0] = datos[i][0];
dat[i][1] = datos[i][1];
rut[i] = ruta[i];
}
datos = dat;
ruta = rut;
}// Fin mtodo aumentarArreglo


int pos, rpta;
String cod, nombre;
rpta = LE.mostrarPreguntaOpcion2("El pasajero que desea Modificar sus datos es
"" mayor de edad?");

if (rpta == 0) {
// Modificacion de pasajero mayor de edad
cod = LE.leerString ("Ingrese el nmero de DNI del pasajero");
pos = buscar (cod);

if (pos != -1) {
rpta = LE.mostrarPreguntaOpcion2("Esta seguro que desea modificafr los
"" datos del pasajero :" + datos[pos][1]
+ " Cuyo DNI es: " + datos[pos][0]);
if (rpta == 0) {
menuModificar(pos);
} else {
LE.mostrarAdvertencia ("usted ha cancelado la modificacin");

Pg. 308

Clase PrgNorteito
}
} else {
LE .mostrarAdvertencia("Lo sentimos, el pasajero que usted ha ingresado no
"" existe");
}

} else {
// Modificacion de pasajero menor de edad
nombre = LE.leerString ("Ingrese el nombre del pasajero");
pos = buscarNombre(nombre);

if (pos != -1) {
rpta = LE.mostrarPreguntaOpcion2("Esta seguro que desea modificar los
+ "Cuyo cdigo asignado es: "
+ datos[pos][0]);
if (rpta == 0) {
menuModificar2(pos);
} else {
LE.mostrarAdvertencia ("Usted ha cancelado la modificacin");
}
} else {
LE.mostrarAdvertencia ("Lo sentimos, el pasajero que usted ha ingresado no
"" existe");
}
}
}

public void menuModificar(int pos) {

String menu = "-*-*-*-Menu Modificar-*-*-*-*-*-\n"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n"
+ "[1] Modificar Documento\n" + "[2] Modificar Nombre\n"
+ "[3] Modificar Ruta\n" + "[4] Retroceder\n"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n" + "Seleccione su opcin";
int opc;

do {
switch (opc) {
case 1:
do {
datos[pos][0] = LE.leerString ("Ingrese el nuevo nmero de DNI");
if (!datos[pos][0].matches("[0-9]{8}")) {
"" caracteres");
}
} while (!datos[pos][0].matches("[0-9]{8}"));
LE.mostrarAdvertencia ("La operacin fu realizada con xito");
break;

case 2:
do {
datos[pos][1] = LE.leerString ("Ingrese el nuevo nombre");
datos[pos][1] = datos[pos][1].trim ( );


Pg. 309

Clase PrgNorteito
if (datos[pos][1].length ( ) < 2) {
"" caracteres");
}
} while (datos[pos][1].length ( ) < 2);
break;

case 3:
do {
ruta[pos] = LE.leerInt ("BARRANQUITA S.R.L \n"
+ "[4] Barranca - Huacho \n"
+ "[5] Barranca - Lima \n" + "[6] Huacho - Lima \n"
+ "----------------------------\n"

if (1 > ruta[pos] || ruta[pos] > 6) {
}
} while (1 > ruta[pos] || ruta[pos] > 6); // Fin de Ingreso de
// Ruta
break;

case 4:
LE.mostrarAdvertencia ("Regresando al men anterior");
break;

default:
break;
}
} while (opc != 4);
}// Fin mtodo menuModificar

public void menuModificar2(int pos) {

String menu = "-*-*-*-Menu Modificar-*-*-*-*-*-\n"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n"
+ "[1] Modificar Nombre\n" + "[2] Modificar Ruta\n"
+ "[3] Retroceder\n" + "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n"
+ "Seleccione su opcin";
int opc;

do {
switch (opc) {
case 1:
do {
datos[pos][1] = LE.leerString ("Ingrese el nuevo nombre");
datos[pos][1] = datos[pos][1].trim ( );

if (datos[pos][1].length ( ) < 2) {
"" caracteres");

Pg. 310

Clase PrgNorteito
}
} while (datos[pos][1].length ( ) < 2);
break;

case 2:
do {
ruta[pos] = LE.leerInt ("NORTEITO S.R.L \n"
+ "[4] Barranca - Huacho \n"
+ "[5] Barranca - Lima \n" + "[6] Huacho - Lima \n"
+ "----------------------------"

if (1 > ruta[pos] || ruta[pos] > 6) {
}
} while (1 > ruta[pos] || ruta[pos] > 6);
break;

case 3:
break;

default:
break;
}
} while (opc != 3);
}// Fin mtodo menuModificar2


String informacion = "Datos de todos los pasajeros \n \n ", rut = "";

for (int i = 0; i < numPas; i++) {

switch (ruta[i]) {
case 1:
rut = " [1] Lima - Huacho";
break;

case 2:
rut = " [2] Lima - Barranca";
break;

case 3:
rut = " [3] Huacho - Barranca";
break;

case 4:
rut = " [4] Barranca - Huacho";
break;

case 5:

Pg. 311

Clase PrgNorteito
rut = " [5] Barranca - Lima";
break;

case 6:
rut = " [6] Huacho - Lima";
break;

default: LE.mostrarInformacion ("Lo sentimos, La opcin ingresada es
"" incorrecta");
break;
}// fin de switch

informacion += "Pasajero: " + (i + 1) + "\n Documento: "
+ datos[i][0] + "\n Nombre: " + datos[i][1] + "\n Ruta:"
+ rut + "\n --------------\n";

}// fin de for
LE.mostrarResultado(informacion);
}// Fin mtodo mostrar

public int buscar (String cod) {

int estado = -1;
if (cod.equalsIgnoreCase(datos[i][0])) {
estado = i;
break;
}
}
return estado;
}// Fin mtodo buscar

public int buscarNombre(String nombre) {

int estado = -1;
if ((nombre.trim ( )).equalsIgnoreCase(datos[i][1])) {
estado = i;
break;
}
}
return estado;
}// Fin mtodo buscar


int pos, rpta;
String cod, nombre;
rpta = LE.mostrarPreguntaOpcion2("El pasajero que desea eliminar es mayor de
"" edad?");

if (rpta == 0) {
// Eliminar mayor de edad
cod = LE.leerString ("Ingrese el nmero de DNI del pasajero que desea eliminar");
pos = buscar (cod);


Pg. 312

Clase PrgNorteito

if (pos != -1) {
rpta = LEmostrarPreguntaOpcion2("Esta seguro que desea eliminar los datos
"" del pasajero :" + datos[pos][1] + " Cuyo
"" DNI es: " + datos[pos][0]);
if (rpta == 0) {
for (int i = 0; i < numPas - 1; i++) {
datos[i][0] = datos[i + 1][0];
ruta[i] = ruta[i + 1];
}
numPas--;
LE.mostrarInformacion ("Los datos fueron eliminados de forma exitosa");

} else {
LE.mostrarAdvertencia ("Usted ha cancelado la operacin");
}
} else {
"" existe");
}

} else {
// Eliminacin de pasajero menor de edad
nombre = LE.leerString ("Ingrese el nombre del pasajero que desea eliminar");
pos = buscarNombre(nombre);

if (pos != -1) {
rpta = LE.mostrarPreguntaOpcion2("Esta seguro que desea eliminar los
+ "Cuyo cdigo asignado es: " +
"" datos[pos][0]);

if (rpta == 0) {
ruta[i] = ruta[i + 1];
}
numPas--;
LE.mostrarInformacion ("Los datos fueron eliminados de forma exitosa");
} else {
LE.mostrarAdvertencia ("Usted ha cancelado la modificacin");
}
} else {
"" existe");
}
}
}// Fin mtodo eliminar

public void calcularGananciaPorRuta ( ) {

double rut, r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0;


Pg. 313

Clase PrgNorteito
switch (ruta[i]) {
case 1:
r1 += 10;
break;

case 2:
r2 += 15;
break;

case 3:
r3 += 5;
break;

case 4:
r4 += 5;
break;

case 5:
r5 += 15;
break;

case 6:
r6 += 10;
break;
}// Fin de switch
}// Fin de for

rut = r1 + r2 + r3 + r4 + r5 + r6;
LE.mostrarInformacion ("NORTEITO S.R.L \n" + "Ganancia por Ruta\n"
+ "----------------------------\n" + "[1] Lima - Huacho: $ "
+ r1 + "\n" + "[2] Lima - Barranca: $ " + r2 + "\n"
+ "[3] Huacho - Barranca : $ " + r3 + "\n"
+ "[4] Barranca - Huacho: $ " + r4 + "\n"
+ "[5] Barranca - Lima: $ " + r5 + "\n"
+ "[6] Huacho - Lima: $ " + r6 + "\n"
+ "----------------------------\n"
+ "El total de ganancia es: $ " + rut);
}// Fin mtodo Calcular Ganancia por Ruta

public void calcularPasajeroPorRuta ( ) {

double rut, r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0;

switch (ruta[i]) {
case 1:
r1++;
break;

case 2:
r2++;
break;

case 3:
r3++;
break;


Pg. 314

Clase PrgNorteito
case 4:
r4++;
break;

case 5:
r5++;
break;

case 6:
r6++;
break;
}
}

rut = r1 + r2 + r3 + r4 + r5 + r6;
LE.mostrarInformacion ("NORTEITO S.R.L \n"
+ "Cantidad de Pasajeros por Ruta\n"
+ "----------------------------------------\n"
+ "[1] Lima - Huacho: " + r1 + "\n"
+ "[2] Lima - Barranca: " + r2 + "\n"
+ "[3] Huacho - Barranca : " + r3 + "\n"
+ "[4] Barranca - Huacho: " + r4 + "\n"
+ "[5] Barranca - Lima: " + r5 + "\n" + "[6] Huacho - Lima: "
+ r6 + "\n" + "----------------------------------------\n"
+ "El total de pasajeros es: " + rut);
}// Fin mtodo Calcular Pasajero por Ruta


String menu = "-*-*-*-Menu Ordenar-*-*-*-*-*-\n"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n"
+ "[1] Ordenar por Documento\n" + "[2] Ordenar por Nombre \n"
+ "[3] Ordenar por Ruta\n" + "[4] Retroceder\n"
int opc;

do {
switch (opc) {
case 1:
OrdenarPorSeleccion ( );
mostrar ( );
break;

case 2:
OrdenarEnBurbuja ( );
mostrar ( );
break;

case 3:
OrdenarEnQuickSort(0, numPas - 1);
mostrar ( );
break;

case 4:
break;

Pg. 315

Clase PrgNorteito

default:
break;
}
} while (opc != 4);

}// Fin mtodo ordenar
public void OrdenarEnBurbuja ( ) {
int tempRuta;
String tempDatos;

for (int j = i + 1; j < numPas; j++) {
tempRuta = ruta[i];
ruta[i] = ruta[j];
ruta[j] = tempRuta;

for (int k = 0; k < 2; k++) {
tempDatos = datos[i][k];
datos[i][k] = datos[j][k];
datos[j][k] = tempDatos;
}

}
}
}
LE.mostrarAdvertencia ("Los datos fueron ordenados correctamente");
}// Fin ordenar en Burbuja

public void OrdenarEnQuickSort (int primero, int ultimo) {

int pivote, tempRuta;
pivote = ruta[(primero + ultimo) / 2];

String tempDatos;

do {
while (ruta[i] < pivote) {
i++;
}

while (ruta[j] > pivote) {
j--;
}
if (i <= j) {
tempRuta = ruta[i];
ruta[i] = ruta[j];
ruta[j] = tempRuta;

for (int k = 0; k < 2; k++) {

Pg. 316

Clase PrgNorteito
}
i++;
j--;
}
} while (i <= j);

if (primero < j) {
}
if (ultimo > i) {
}
}// Fin ordenar en QuickSort
public void OrdenarPorSeleccion ( ){

int dniTemp, k, j;
int tempRuta=0;
String tempNombres="";

for (int i=0;i<numPas;i++) {
dniTemp = Integer.parseInt(datos[i][0]);
k=i;

for (j=i+1;j<numPas;j++){
if ((Integer.parseInt(datos[j][0]))<dniTemp) {
k = j ;
dniTemp = Integer.parseInt(datos[k][0]);
tempRuta=ruta[k];
tempNombres=datos[k][1];
}
}

datos[k][0] = datos[i][0] ;
datos[i][0]=""+dniTemp;
datos[k][1] = datos[i][1] ;
datos[i][1]=tempNombres;
ruta[k]=ruta[i];
ruta[i]=tempRuta;
}
}
LE.mostrarAdvertencia ("Usted ha finalizado el programa");
}
}// Fin PrgNorteito


En la presente solucin se implementa los diversos mtodos de ordenamiento explicados en
el presente captulo. Como son el mtodo de ordenar por seleccin, que se ocupa de realizar
el ordenamiento de todos los pasajeros de acuerdo al nmero de su DNI. El ordenamiento por
orden alfabtico se realiza mediante el mtodo de intercambio y por ltimo, el mtodo de
ordenamiento rpido QuickSort se utiliz para ordenar los datos de acuerdo al nmero de ruta

Pg. 317

que escoje un pasajero, como se puede observar a continuacin:

Mtodo ordenar
..

String menu = "-*-*-*-Menu Ordenar-*-*-*-*-*-\n"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n"
+ "[1] Ordenar por Documento\n" + "[2] Ordenar por Nombre \n"
+ "[3] Ordenar por Ruta\n" + "[4] Retroceder\n"

int opc;
do {
switch (opc) {
case 1:
OrdenarPorSeleccion ( );
mostrar ( );
break;

case 2:
OrdenarEnBurbuja ( );
mostrar ( );
break;

case 3:
OrdenarEnQuickSort(0, numPas - 1);
mostrar ( );
break;

case 4:
break;

default:
break;
}
} while (opc != 4);}// Fin mtodo ordenar
}

Como vemos, el mtodo de ordenamiento rpido QuickSort recibe el primer parmetro
inicializado en 0, ya que ser el primer valor que reciba nuestro mtodo. Y el segundo
parmetro que viene a ser el nmero de alumnos disminuido en 1. Este valor ser el
segundo parmetro que recibir nuestro mtodo para que realice las primeras
comparaciones, y posteriormente las comparaciones recursivas.


Pg. 318

..
public void OrdenarEnQuickSort(int primero, int ultimo) {
int pivote, tempRuta;
pivote = ruta[(primero + ultimo) / 2];
String tempDatos;

do {

while (ruta[i] < pivote) {
i++;
}

while (ruta[j] > pivote) {
j--;
}

if (i <= j) {
tempRuta = ruta[i];
ruta[i] = ruta[j];
ruta[j] = tempRuta;

for (int k = 0; k < 2; k++) {
}
i++;
j--;

}
} while (i <= j);

if (primero < j) {
}

if (ultimo > i) {
}

}// Fin ordenar en QuickSort

Tambin se puede apreciar en la solucin desarrollada, la implementacin del mtodo
Matches de la clase String. Ideal para la validacin de datos para evitar todo tipo de
anomalas.
Llamada recursiva al
mtodo
OrdenarEnQuickSort ( );

Pg. 319

Podemos apreciar dichas implementaciones en las validaciones siguientes:

Validacin de datos
..
do {

do {
datos[numPas][0] = LE.leerString ("Ingrese su nmero de DNI");
pos = buscar (datos[numPas][0]);

if (pos != -1) {
LE .mostrarError("Lo sentimos, el nmero de DNI ya existe en nuestra
base de datos");
}
} while (pos != -1);

if (!datos[numPas][0].matches("[0-9]{8}")) {
caracteres");
}
} while (!datos[numPas][0].matches("[0-9]{8 }"));

Como vemos en el anterior recuadro. Se realizan dos validaciones para el ingreso del
DNI de un pasajero.

El primero con un mtodo de buscar para evitar que no existan dos documentos iguales
dentro del vector DNI.

El segundo con el mtodo matches para que permita slo el ingreso de datos que estn
comprendidos entre el 0 y el 9. Y que slo pueda permitir el ingreso de 8 caracteres. De
este modo asegurando la legitimidad de los datos ingresados.


Pg. 320

PROBLEMAS PROPUESTOS

1. Desarrollar una solucin que permita registrar los nombres y las edades de todas las
personas que estn inscritas para una conferencia en la FIA. Mostrar el nombre de las
personas que tienen ms de 18 aos. Utilice la Grfica de Estructura de Datos mostrada.

Dados los vectores:

nombre edad
0
1
2
3
: :
: :
9999
numPer = 0

(String) (int) (int)

Donde numPer permite almacenar el nmero de personas.

2. Se desea registrar los cdigos, nombres y el promedio final de los alumnos del curso de
Algoritmo y Estructura de datos I, y determinar cul es el porcentaje de alumnos
aprobados y desaprobados. Adicionalmente determinar quin es el alumno que ha
obtenido la mayor nota. Utilice la Grfica de Estructura de Datos mostrada.

Dados los vectores:

nombre codigo promedio
0
1
2
3
: : :
: : :
numAlu - 1
numAlu




Pg. 321

3. Desarrollar una solucin que permita ingresar y almacenar el nombre, el cdigo y las
notas de las prcticas de todos los alumnos de un saln de clase. Determinar el
porcentaje de alumnos aprobados y desaprobados.

Dados los arreglos:

nombre codigo nota
0 1 numPra-1
0
1
2
3
. . . . . numAlu
: : : : :
( int )
numAlu - 1
numPra
(String) (long) (double) ( int )

Donde: numAlu permite almacenar el nmero de alumnos.
numPra permite almacenar el nmero de prcticas.

4. La Librera Boligrafito S.A., ubicada cerca de la FIA, vende diversos artculos de oficina.
Desarrolle una aplicacin para determinar la ganancia por cada artculo si se vendiera
todo lo que se tiene en el almacn. Mostrar los artculos ordenados por la cantidad de
artculos. Utilice la Grfica de Estructura de Datos mostrada.

Dados los arreglos:

nombre cantidad precio

PV (0) PC (1)

0
1
2
3
: : :
: : :
9999
numArt = 0

(String) (lint) double) (double) (int)

Donde: numArt permite almacenar el nmero de artculos.


Pg. 322

5. Cinco estudiantes del curso se fueron de paseo a Paracas. Ah se alojaron en la posada
Don Alfonso que se encuentra cerca de Pisco. El administrador de la posada al
enterarse que los estudiantes eran alumnos de la FIA les solicit que desarrollen un
programa de computadora que le ayudara a controlar si las habitaciones estaban
ocupadas o no, y cunto era su ganancia por el alquiler de las habitaciones. A cambio del
programa el administrador les realizara un excelente descuento. La delegada del curso
sugiri desarrollar una aplicacin que manejar los datos de la posada, utilizando la
Grfica de Estructuras de Datos mostrada.

Dada la matriz:

datosHotel

NH (0) VA (1) EH (2) NA (3)

0
1
2
3
: : :
: : :
numHab - 1
numHab

(int) (int)

Donde: numHab permite almacenar el nmero de habitaciones de la
posada.

NH = Nmero de la habitacin.
VA = Valor del alquiler.
EH = Estado de la habitacin (1=ocupado, 2=desocupado).
NA = Nmero de veces alquilado.

6. El alumno Torres tiene ms de 1000 cintas de video con pelculas de accin, drama,
suspenso y comedia. Torres decide alquilar sus cintas de video a un costo bajo. Para ello,
copi las mejores cintas de video que posea y desarroll un programa de computadora
para mantener un adecuado control del alquiler de las cintas de video y sus respectivas
copias. Para el desarrollo del programa de computadora determin que era necesario
utilizar la Grfica de Estructuras de Datos mostrada. Desarrolle una solucin utilizando
un men de opciones.

Dadas las matrices:

pelicula alquiler
nom (0) cod (1) cos (0) sto (1) alq (2) tot (3)
0 0
1 1
2 2
3 3
: : : : : :
: : : : : :
numPel = 0
9 9 (int)

(String) (long)


Pg. 323

Donde: numPel permite almacenar el nmero de videos / pelculas que tiene el alumno.

nom= Nombre de la pelcula.

cod = Cdigo de la pelcula.

cos = Costo del alquiler de la pelcula.

sto = Nmero de cintas de video por pelcula.

alq = Nmero de cintas que en un determinado momento estn alquiladas.

tot = Nmero total de veces que se ha alquilado un video.

7. Un grupo de alumnos asistieron a un evento en un conocido restaurante de nuestra
ciudad. En dicho restaurante existan tantas mesas que los alumnos empezaron a discutir
cmo podan controlar el consumo de cada una de las mesas. El alumno Yarlequ
propuso la Grfica de Estructuras de Datos mostrada. Desarrolle una solucin utilizando
un men de opciones.

Dados los arreglos:

cliente datos
nom num (0) cac (1) cat (2)
0 0
1 1
2 2
3 3
: : : :
: : : :
numMes = 0
9999 9999 (int)

(String) (double)

Donde: numMes permite almacenar el nmero de mesas del restaurante.

nom= Nombre del cliente que actualmente ocupa una mesa.

num = Nmero de mesa.

cac = Cuenta actual del cliente.

cat = Cuenta acumulada total por mesa.


Pg. 324

8. Durante el partido de ftbol entre la seleccin de Argentina contra Serbia y Montenegro,
los alumnos Osores y Chia discutan cmo podan programar la tabla de posiciones con
los resultados de los partidos del mundial de ftbol. Luego de un gran debate propusieron
la siguiente Grfica de Estructuras de Datos para almacenar los datos de los resultados
de los partidos. Desarrolle una solucin utilizando un men de opciones.

Dados los arreglos:

Equipo datos
Nom PJ (0) PG (0) PE (0) GF (1) GC (2) PA (3)
0 0
1 1
2 2
3 3
: : : : : : :
: : : : : : :
numEqu
numEqu -1 numEqu - 1 (int)

( String ) ( int )

Donde: numEqu permite almacenar el nmero de equipos que participan en el mundial.

nom= Nombre del equipo participante en el mundial de ftbol.

PJ = Partidos Jugados.

PG = Nmero de Partidos Ganados.

PE = Nmero de Partidos Empatados.

GF = Goles a Favor.

GC = Goles en Contra.

PA = Puntaje Actual. Puntaje en un determinado momento.

9. La empresa La Moderna SA, se dedica a la venta de equipos de todo tipo. Hace unos
das han detectado algunos problemas en su inventario y desean realizar una aplicacin
que les permita obtener la utilidad al realizar la venta de equipos. El sobrino del gerente
de la empresa, estudiante de la FIA, ha recomendado que se utilice el lenguaje de
programacin Java y que se desarrolle la aplicacin utilizando un men de opciones y la
Grfica de Estructuras de Datos mostrada.

Dados los arreglos:

nombre datos
CA (0) PC (1) PV (2)
0 0
1 1
2 2
3 3
: : : :
: : : :
numEqu = 0
9999 9999 (int)

(String) (double)

Pg. 325

Donde: numEqu permite almacenar el nmero de tipos de equipo en inventario.

En el vector nombres se almacena el tipo de equipo.

CA = Cantidad de equipos.



10. Un grupo de estudiantes visitaron diversos colegios del cono norte de Lima apoyando a
los docentes en el dictado de diversas charlas. En total visitaron aproximadamente 15
colegios y observaron que todos los colegios posean computadoras donadas por
instituciones privadas. El alumno Gutirrez coment a sus compaeros que podan
desarrollar una aplicacin que permita controlar las vacantes a cada una de las charlas
programadas. Desarrollar una solucin utilizando mtodos y arreglos en paralelo, que
permita ingresar, almacenar y manejar los datos en base a la Grfica de Estructuras de
Datos mostrada. Se deber desarrollar un men.

Dados los arreglos:
charlas asistentes
vac (0) cos (0) des (0) ins (1) inv (2)
0 0
1 1
2 2
3 3
: : : : : :
: : : : : :
numCha = 0
9 9 (int)

(String) (double)

Donde: numCha permite almacenar el nmero de charlas.

vac = Nmero mximo de asistentes a una charla.

cos = Costo de particiacin.

des = Descuento por participacin.

Ins = Nmero de inscritos

inv = Nmero de invitados.


Pg. 326

PROYECTOS SUGERIDOS

1. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que
permita manejar y controlar el alquiler y venta de videos en una tienda de video.

permita manejar y controlar el prstamo y devolucin de libros en una biblioteca.

permita manejar y controlar el tiempo de uso de las computadoras en una cabina de
internet.

permita manejar y controlar la asistencia de todos los empleados en una empresa.

permita manejar y controlar la agenda de una persona.

permita manejar y controlar todas las computadoras instaladas en una universidad.

permita manejar y controlar el abastecimiento de productos en una bodega.

permita manejar y controlar la disponibilidad de habitaciones en un hotel.

permita manejar y controlar el consumo de las mesas de un restaurante.

permita manejar y controlar la venta de productos en una farmacia.


Pg. 327

11. Los empleados de la empresa La Virtual trabajan en diferentes reas en la
organizacin. Desarrolle una solucin con un men de opciones que permita ingresar
y mantener actualizados los datos de todos los empleados, en base a la grfica de
estructura de datos mostrada. Incluya tambin una opcin que permita determinar
cul sera el costo para la empresa si se decidiera a aumentar un porcentaje del
sueldo a todos los empleados de una determinada rea.

nombres

area

sueldo
0 Rosa 0 Aulas Virtuales 0 900
1 Frank 1 Second Life 1 800
2 Jos 2 Web Docente 2 850
3 Luis 3 Second Life 3 800
4 Mara 4 Aulas Virtuales 4 900
: : : : : :
99999

99999

99999

(String)

(String)

(Double)

Donde: numEmp: Almacena el nmero de empleados.
nombres: Almacena todos los nombres de los empleados.
area: Almacena el rea de trabajo de los empleados.
sueldo: Almacena el sueldo respectivo de los empleados.

12. La bodega La Esquinita comercializa diversos artculos. Para lo cual se desea
desarrollar una solucin en el lenguaje de programacin Java que permita almacenar
los cdigos, nombres, cantidad, precio de compra y precio de venta de todos los
artculos de la bodega y generar informes como la ganancia total por los artculos
vendidos y la ganancia parcial por articulo.

datos

CA PC PV

codigo

nombre

0 1 2
0 0 0
1 1 1
2 2 2
3 3 3
4 4 4
: : : : : : : :
99999

99999

99999

(String)

(String)

(Double)

Donde: numArt: Almacena el nmero de productos del inventario.
codigo: Almacena todos los cdigos de los productos ingresados a inventario.
nombre: Almacena todos los nombres de los productos ingresados a inventario.rm
datos: Matriz que almacena 3 datos para cada producto del inventario.
CA: Almacena la cantidad de cada tipo de producto.
PC: Almacena el precio de compra de cada producto.
PV: Almacena el precio de venta de cada producto.
(int)


Pg. 328

13. En las siguientes estructuras se tienen almacenados los nombres, las direcciones,
distritos, los DNI y los sueldos de los trabajadores de una empresa. Se busca una
desarrollar una solucin en el lenguaje de programacin Java que permita obtener el
total de sueldos que paga la empresa y que permita organizar adecuadamente los
datos de los trabajadores de la empresa,

datos

nombres direcciones distrito

0 1 2

dni

sueldo
0 0 0
1 1 1
2 2 2
3 3 3
4 4 4
: : : : : : : :
99999

99999

99999

(Double)

(long)

(Double)

Donde: numEmp: Almacena el nmero de todos los empleados..
dni: Almacena el nmero de DNI de los empleados.
sueldos: Almacena el sueldo respectivo de todos los empleados.
datos: Matriz que almacena 3 datos por cada empleado.
nombres: Almacena los respectivos nombres.
direcciones: Almacena las direcciones de los respectivos empleados.
sueldos: Almacena los respectivos sueldos de los empleados.

14. La coordinadora del curso de introduccin a la computacin desea gestionar
adecuadamente los cdigos, nombres y datos que registra el promedio de trabajos,
examen parcial y examen final de los alumnos de clase. Para lo cual se plantea
desarrollar una solucin utilizando el lenguaje de programacin Java para obtener los
promedios finales de los alumnos. La frmula establecida para hallar dicho promedio
se define de la siguiente manera: Promedio = (PTR + EXP + 2*EXF)/4

datos

PTR EXP EXF

codigo

nombre

0 1 2
0 0 0
1 1 1
2 2 2
3 3 3
4 4 4
: : : : : : : :
99999

99999

99999

(long)

(String)

(Double)

numEmp = 0
(int)

(int)


Pg. 329

Donde: numAlu: Almacena el nmero de los alumnos.
codigo: Almacena todos los cdigos de los alumnos.
nombre: Almacena todos los nombres de los alumnos.
notas: Matriz que almacena 3 datos para cada alumno:
PTR: Almacena el promedio de los trabajos.
EXP: Almacena la nota del examen parcial.
EXF: Almacena la nota del examen final.

15. La empresa barranquita S.R.L ha automatizado su servicio de transporte
interprovincial de pasajeros dotando a cada una de sus unidades (buses) con una
computadora porttil. Desarrolle una solucin que permita manejar los datos del
servicio brindado y permita controlar las ganancias de la empresa en base a las rutas
parciales que cubre especificadas en el siguiente cuadro:

N RUTAS PARCIALES COSTO
1 Lima Huacho S/. 8.00
2 Lima Barranca S/. 8.00
3 Huacho Barranca S/. 8.00
4 Barranca Huacho S/. 8.00
5 Barranca Lima S/. 8.00
6 Huacho Lima S/. 8.00

Utilice la grfica de estructura de datos mostrada y desarrolle un men con las
opciones obtener la ganancia por ruta parcial, cantidad de pasajeros por ruta parcial,
ganancia total.

datos

documento nombre direccion

0 1 2

ruta

costo
0 0 0
1 1 1
2 2 2
3 3 3
4 4 4
: : : : : : :
:
99999

99999

99999

(Double)

(long)

(Double)

Donde: numpas: Almacena el nmero pasajeros.
ruta: Almacena todas las rutas disponibles.
costo: Almacena los costos de las rutas disponibles.
datos: Matriz que almacena 3 datos para cada alumno:
documento: Almacena todos los documentos de los pasajeros.
nombre: Almacena todos los nombres de los pasajeros.
direccion: Almacena todas las direcciones de los pasajeros.
numPas = 0
(int)


Pg. 330

Para el desarrollo de los mens de los problemas propuestos anteriormente, deber
considerar como mnimo las siguientes opciones:

[1] Ingreso al manejo de la aplicacin.
[1.1] Ingreso de datos. Si los arreglos utilizados se llenan desarrolle un
algoritmo para hacer que los arreglos aumenten su tamao (valide los
datos ingresados. Defina qu datos no podrn repetirse, como por ejemplo
el cdigo de un alumno o de un empleado).
[1.2] Visualizacin de informacin necesaria para el usuario.
[1.3] Consulta de datos importantes para el usuario.
[1.4] Realizar la venta, prstamo o servicio segn el tipo de aplicacin que est
desarrollando.
[1.X] Salir.

[2] Ingreso al mantenimiento de datos de la aplicacin (considere el uso de un
nombre de usuario y una clave como medida de seguridad).
[2.1] Ordenar datos.
[2.2] Modificar datos (deber definir qu datos no se debern modificar).
[2.3] Eliminar datos.
[2.4] Salir.

[3] Finalizar.

Considerar que las opciones pueden tener submens para manejar adecuadamente la
informacin que se requiera. Plantee el Diagrama de Estructuras de Datos en base a las
necesidades de almacenamiento de datos del usuario. Recuerde que la participacin del
usuario o cliente en el desarrollo de la aplicacin es sumamente importante.

Incorpore Interfaz Grfica en sus aplicaciones (GUI). Los conceptos de las GUIs sern
tratados en captulos posteriores.


Pg. 331

INTNTALO

1. Desarrollar una solucin que permita ingresar, almacenar y manejar los datos de un
ranking de msica en base a la Grfica de Estructuras de Datos mostrada.

Dados los arreglos:

codigo datos1 datos2
nom (0) aut (1) sol (0) exp (1)
0 0 0
1 1 1
2 2 2
3 3 3
: : : : :
: : : : :
numTem = 0
9 9 9 (int)

(long) (String) (int)

Donde: numTem permite almacenar el nmero de temas / canciones que tiene el ranking.

nom= Nombre del tema musical.

aut = Autor del tema musical.

sol = Nmero de veces solicitado un tema musical.

exp = Opinin del experto (utilizada para diferenciar temas que estn empates en el ranking).

Se deber desarrollar un men con dos opciones generales y cada opcin con un
submen:

[1] Ingreso al manejo del RANKING.
[1.1] Ingreso de datos. Si los arreglos utilizados se llenan desarrolle un
algoritmo para poder hacer que los arreglos aumenten su tamao (valide
los datos ingresados. No permitir el ingreso de un cdigo que ya existe).
[1.2] Visualizacin un determinado tema por cdigo.
[1.3] Registrar votacin de un tema (cuando se solicita un tema se registra un
voto).
[1.4] Establecer y mostrar el RANKING de msica (este se ordena y se muestra
desde el ms votado al menos votado).
[1.5] Salir.

[2] Ingreso al mantenimiento de datos del ranking (utilizar un usuario y clave).
[2.1] Ordenar datos por cdigo.

Pg. 332

[2.2] Modificar datos por codigo (no se podr modificar los cdigos ni el nmero
de veces que un tema ha sido solicitado).
[2.3] Eliminar datos por cdigo.
[2.4] Salir.

[3] Finalizar.

Consideraciones:

Es importante indicar que la solucin a desarrollar deber permitir el manejo de los
datos de un ranking de temas musicales. Por este motivo, en la solucin se incluyen
opciones para ingresar, mostrar, buscar, ordenar, eliminar y modificar datos, con
algunas restricciones, de tal forma que nos permita un adecuado control y
mantenimiento de los datos almacenados en las estructuras de datos utilizadas.

Adicionalmente, se tienen opciones especficas para manejar el ranking de temas
musicales tales como registro de votacin, registro de la opinin del experto y
establecimiento y visualizacin del ranking. A travs de la opcin de registro de
votacin, se podr agregar un voto a un determinado tema musical y a travs de la
opcin de establecimiento y visualizacin del ranking, se podr obtener el ranking,
donde el tema musical que tenga ms votos se ubicar en el primer lugar del ranking.
Tambin, se ha incluido la opcin registro de la opinin del experto, la cual permitir
manipular las posiciones del ranking en caso que exista un empate en las votaciones
entre los diferentes temas musicales.

Arreglos en Paralelo v.2012 PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Arreglos en Paralelo v.2012 PDF

Transféré par

Droits d'auteur :

Formats disponibles

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Vous aimerez peut-être aussi