Arreglos en Paralelo v.2012

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.
Captulo
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.
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.
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.
MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA
Etapa 02
Definicin
Solucin
Diseo
Solucin
Etapa 04
Desarrollo
Solucin
Pg. 92
LISTA DE PASOS
SENTENCIAS
DESCRIPCIN
DE DATOS
DECLARACIN Y
DEFINICIN DE
DATOS
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.
ALMACENADOS EN:
Estructuras de datos tipo variables.
Estructuras de datos tipo arreglo.
MANEJO DE DATOS:
Bsquedas y Ordenamientos.
Modificacin y Eliminacin.
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.
Pg. 93
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. 94
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
X0
X1
X2
...
X I-1
...
i -1
Donde:
nombre
X0...X i -1
i
=
=
=
Nombre del vector.

Datos almacenados en el vector.
Tamao del vector.
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;
Pg. 95
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. 96
En Java, existe tambin una forma directa

unidimensionales, utilizando el siguiente formato:
para
declarar
crear
arreglos
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. 97
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:
nombre
Columnas
Filas
X 0,0
X 0,1
X 0,2
X 1,0
X 2,0
i-1
X i-1,0
j-1
X 0,j -1
X i-1,j -1
(i, j)
Donde:
nombre
X0,0...Xi-1, j -1
i*j
=
=
=
Nombre de la matriz.
Datos almacenados en la matriz.
Tamao de la matriz.
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.
Pg. 98
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:
Datos del mismo

trabajador.
nombre
sueldo
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.
Pg. 99
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
Rodrigo
12
.
:
.
:
.
:
Datos del mismo

socio.
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
(String)
Donde:
(double)
( int )
numArt permite almacenar el nmero de Artculos.

PC = Precio de compra.
PV = Precio de venta.
Pg. 100
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
Danae
1000
.
:
.
:
1
2
3
99999
numTrab = 0
(String)
(double)
( int )
Donde numTrab indica el nmero de trabajadores cuyos datos se han almacenado.
Pg. 101
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
:
:
:
:
:
:
(double)
(String)
(double)
0
1
2
3
9999
numAlu = 0
(int)
Donde numAlu permite almacenar el nmero de alumnos cuyos datos se han almacenado.
Disee el algoritmo de la solucin en Pseudocdigo.
Pg. 102
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. 103
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
:
:
:
:
:
:
(double)
(String)
(double)
0
1
2
3
9999
numEmp = 0
(int)
Donde numEmp permite almacenar el nmero de alumnos cuyos datos se han almacenado.
Pg. 104

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. 105
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
:
:
:
:
:
:
(Double)
(lint)
(double)
:
:
9999
numAlu = 0
N1 = Es la primera nota.
Donde:
N2 = Es la segunda nota.
N3 = Es la tercera nota.
Pg. 106
(int)

Clase PrgPromedio2
public class PrgPromedio2 {

double notas[][]=new double[numAlum][3];
Se utiliza una estructura

de repeticin para el
ingreso de las notas
dado que es una matrz
que recibir 3 notas.
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);
}
}
Pg. 107
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
0
1
2
3
:
:
:
:
(Double)
(lint)
:
:
:
:
numNotas - 1
:
:
:
:
:
:
:
:
9999
numAlu = 0
( (double)
Donde:
Donde numNotas permite almacenar el nmero de notas de cada alumno.
Pg. 108
(int)

Clase PrgPromedioGeneral
public class PrgPromedioGeneral {

int numNotas=LE.leerInt("Ingrese el nmero de notas :");
double notas[][]=new double[numAlum][numNotas];
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.
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);
}
}
Pg. 109
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. 110
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.
Entonces, sea el vector:
notas
numAlu = 10.
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
12
0
numAlu = 10.
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.
notas
12
15
14
17
19
08
13
16
17
13
numAlu = 10.
Pg. 111
En el siguiente ejemplo veremos el ingreso de datos de la siguiente estructura:

Dados los vectores:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
numAlu = 10
(long)
(String)
(double)
(int)
Donde numAlu permite almacenar el nmero de alumnos.
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
Tenemos que recordar que el arreglo tuvo que ser creado con un tamao del numAlu, que
segn la estructura es de 10 registros.
Pg. 112
Tambin podemos implementar los mtodos que sirven para validar los datos de ingreso,
como se puede ver en la siguiente cuadro.

// 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 );
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.
Pg. 113
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.
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.
notas
numAlu = 10.
i=2
i=1
i=0
12
15
14
17
19
08
13
16
17
13
lista = lista + notas[i]

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. 114
En el siguiente ejemplo podremos observar el desarrollo de lo mencionado:

Dados los vectores:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
numAlu = 10
(long)
(String)
(double)
(int)
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. 115
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. 116
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. 117
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.
Sea el vector:
Notas
3
10
11
13
15
17
19
numAlu = 10.
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.
Pg. 118
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]
Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.
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).
Pg. 119
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. 120
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]
Conjunto de
instrucciones que

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).
Pg. 121
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. 122
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]
Conjunto de
instrucciones que

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.
Pg. 123

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. 124
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. 125

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. 126

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. 127

Bsqueda Lineal Mtodo buscarCantidadSec ( )

public int buscarCantidadSec ( int valor ) {
int i, cantidad = 0 ;
cantidad ++ ;
}
}
return cantidad ;
}
Pg. 128
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
100
100
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. 129
Suponga que tenemos el siguiente arreglo de notas con numAlu = 10 (donde numAlu es el
nmero de elementos del arreglo notas):
Sea el vector:
notas
3
10
11
13
15
17
19
numAlu = 10.
Podemos afirmar que el nmero mximo de comparaciones

para este ejemplo ser de 2x >= 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.
Pg. 130
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
Conjunto de
instrucciones que
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
Pg. 131

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. 132
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. 133

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. 134
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.
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 ;
}
}
}
Observe el uso del mtodo equalsIgnoreCase ( ) de la clase String de Java.
Pg. 135
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. 136
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. 137
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;
Sea el vector:
notas
20
18
13
17
19
numAlu = 5.
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.
Pg. 138
Se selecciona el elemento del vector notas que tenga el nmero

menor:
20
18
13
17
19
El elemento seleccionado se intercambia con el primer elemento:
13
18
20
17
19
Ahora, se selecciona el elemento del vector que tenga el nmero

menor entre los elementos restantes:
13
18
20
17
19
El elemento seleccionado se intercambia con el segundo elemento

del vector:
13
17
20
18
19

13
17
20
18
19
El elemento seleccionado se intercambia con el tercer elemento del

vector:
13
17
18
20
19
Pg. 139

13
17
18
20
19
El elemento seleccionado se intercambia con el cuarto elemento del

vector:
13
17
18
19
20
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.
Pg. 140
A continuacin se muestra el algoritmo del mtodo de ordenacin por seleccin:

Algoritmo PrgOrdenacionSeleccion
ENTRADA: numAlu, notas[ ]
SALIDA:
notas[ ]
INICIO
NUMERO notas[ ], numAlu, i
Conjunto de
instrucciones que
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
Pg. 141

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. 142
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;
Sea el vector:
notas
20
18
13
17
19
numAlu = 5.
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.
Pg. 143
Se toma el segundo elemento del vector notas:

x = 18
20
18
El elemento tomado se inserta en el lugar que le corresponde entre

los dos primeros elementos, quedando ordenada esta parte del
vector:
18
20
Ahora, se toma el tercer elemento del vector:

x = 13
18
20
13

los tres primeros elementos, quedando ordenada esta parte del
vector:
13
18
20
Ahora, se toma el cuarto elemento del vector:

x = 17
13
18
20
17
Pg. 144

los cuatro primeros elementos, quedando ordenada esta parte del
vector:
13
17
18
20
Ahora, se toma el ltimo elemento del vector:

x = 19
13
17
18
20
19
El ltimo elemento tomado se inserta en el lugar que le corresponde

entre los todos los elementos, quedando ordenado todo el vector:
13
17
18
19
20
Finalmente, podemos afirmar que este mtodo se basa en insertar

cada elemento del arreglo en el lugar adecuado.
Pg. 145
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
Pg. 146
Conjunto de
instrucciones que
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
Pg. 147
Conjunto de
instrucciones que
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
Pg. 148
Conjunto de
instrucciones que

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. 149
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. 150
Algoritmo PrgOrdenacionIntercambio
SALIDA:
notas[ ]
INICIO
Conjunto de
instrucciones que
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.
Pg. 151

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. 152

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. 153
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;
Sea el vector:
notas
6
numAlu = 7
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.
Pg. 154
Comenzaremos con el vector completo donde el elemento divisor

ser el 6:
p
Comparamos con el 6 por la izquierda y el 5 por la derecha con el

pivote.
p
j
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.
p
j
3
4
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.
p
j
Pg. 155
3
4
8 NO es menor que 7 y 5 NO es mayor que 7.
p
j
3
4
Como i=2 y j=6, i es menor que j, as que intercambiamos los valores

de notas[i] y de notas[j].
p
j
3
4
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):
p
j
i
2
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:
Pg. 156
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));
}
}
Pg. 157
..
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);
}
}
}
Pg. 158
Llamada recursiva al mtodo

OrdenarEnQuickSort( );
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:
Llamada recursiva al
mtodo factorial
public long factorial ( long n ) {

// Declaramos la lgica del algortmo.
if (n == 0) {
return 1;
} else {
return n * factorial ( n 1 );
}
}
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.
Pg. 159
Problema 018
Enunciado:
Utilizando mtodos y un men de opciones desarrolla la codificacin
solucin que permita :
en JAVA de una
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
:
:
:
:
:
:
(double)
(String)
(double)
0
1
2
3
9999
numAlu = 0
(int)
Pg. 160

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. 161
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. 162
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: " + "
}
}
Pg. 163
" + total ) ;
Problema 019
Enunciado:
Utilizando mtodos y un men de opciones desarrolla la codificacin
solucin que permita :
en JAVA de una
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
:
:
:
:
:
:
(double)
(String)
(double)
0
1
2
3
9999
numEmp = 0
(int)
Donde numEmp permite almacenar el nmero de alumnos cuyos datos se han almacenado.
Pg. 164
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. 165
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. 166
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. 167
" + total ) ;
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. 168
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:
codigos
nombres
notas
:
:
:
:
:
:
(long)
(String)
(double)
0
1
2
3
9999
numAlu = 0
Pg. 169
(int)
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
10
JUAN
19
20
CARMIEN
13
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
(long)
(String)
(double)
9999
numAlu = 5
(int)
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. 170
Cdigo buscado = 20
codigos
nombres
Notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
(long)
(String)
(double)
0
1
9999
numAlu = 5
(int)
Datos reemplazados:
Nuevo nombre = Carmen
Nueva nota
= 17
Pg. 171
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
Conjunto de
instrucciones que
Conjunto de
instrucciones que
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
Pg. 172
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. 173
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. 174
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
:
:
:
:
:
:
:
:
(long)
(String)
(double)
0
1
2
3
9999
numAlu = 0
(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
10
JUAN
19
true
20
CARMEN
17
true
30
DANAE
15
true
40
RODRIGO
16
true
50
JOS
09
true
:
:
:
:
:
:
:
:
(long)
(String)
(double)
9999
numAlu = 5
(int)
Pg. 175
(boolean)
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:
codigos
nombres
notas
estado
10
JUAN
19
true
20
CARMEN
17
false
30
DANAE
15
true
40
RODRIGO
16
true
50
JOS
09
true
:
:
:
:
:
:
:
:
(long)
(String)
(double)
9999
numAlu = 5
(int)
(boolean)
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. 176
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:
codigos
nombres
notas
estado
10
JUAN
19
true
20
CARMEN
17
false
30
DANAE
15
false
40
RODRIGO
16
true
50
JOS
09
false
:
:
:
:
:
:
:
:
(long)
(String)
(double)
9999
numAlu = 5
(int)
(boolean)
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. 177
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:
codigos
nombres
notas
:
:
:
:
:
:
(long)
(String)
(double)
0
1
2
3
9999
numAlu = 0
(int)
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. 178
Cdigo buscado = 20
Dados los vectores:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
(long)
(String)
(double)
9999
numAlu = 5
(int)
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:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
(long)
(String)
(double)
0
1
9999
numAlu = 5
(int)
Pg. 179
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:
codigos
nombres
notas
10
JUAN
19
30
DANAE
15
40
RODRIGO
16
50
JOS
09
50
JOS
09
:
:
:
:
:
:
(long)
(String)
(double)
9999
numAlu = 4
(int)
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. 180
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]
Conjunto de
instrucciones que
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
Pg. 181
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. 182
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. 183
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
:
:
:
:
:
:
(String)
(long)
(double)
estado
0
1
2
3
9999
numAlu = 0
(boolean)
(int)
Pg. 184

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. 185
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. 186
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. 187
" + total ) ;
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
:
:
:
:
:
:
(String)
(long)
(double)
0
1
2
3
9999
numArt = 0
Donde numArt permite almacenar el nmero de artculos de una bodega.
Pg. 188
(int)

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. 189
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. 190
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. 191
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:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
10
numAlu = 10
(long)
(String)
(double)
(int)
Pg. 192
El mtodo que desarrollamos fue el siguiente:

notas[i]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
}
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:
// 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. 193
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:
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) );
E

notas[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
}
numAlu++;
rpta = LE.mostrarPreguntaOpcion2 (Desea aadir ms registros ?
SI = 0 NO=1] );
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.
Pg. 194
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.
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
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.
Pg. 195
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:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
10
numAlu = 10
(long)
(String)
(double)
(int)
Si por ejemplo tenemos que insertar un nuevo registro donde los datos son:
codigos
nombres
notas
25
LUIS
14
Pg. 196
Entonces podemos seguir los pasos definido los cuales se muestran a continuacin:
1. Ubicar la posicin donde debera insertarse los datos ingresados.
Dados los vectores:
codigos: 25
nombres: Luis
notas:
14
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
30
DANAE
15
40
RODRIGO
16
50
JOS
09
:
:
:
:
:
:
10
numAlu = 10
(long)
(String)
(double)
(int)
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:
codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
2
.
30
DANAE
15
40
RODRIGO
16
10
50
JOS
09
:
:
:
:
:
:
numAlu = 10
(long)
Pg. 197
(String)
(double)
(int)
3. Insertar los Datos
Datos ingresados
correctamente.
Dados los vectores:

codigos
nombres
notas
10
JUAN
19
20
CARMEN
17
25
LUIS
14
30
DANAE
15
40
RODRIGO
16
50
JOS
09
10
:
:
:
:
:
:
numAlu = 10
(long)
(String)
(double)
(int)
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.
public void posicionCodigo (long cod ) {

for ( int i = 0 ; i<=numAlu ; i++- ){
if (cod<codigos)[i]){
return i;
}
}
return numAlu;
}
Pg. 198
Finalmente procedemos a desarrollar el mtodo para insertar datos.
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. 199
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. 200
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
:
:
:
:
:
:
(String)
(long)
(double)
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. 201
(int)
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. 202
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. 203
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.
No se ha incluido una validacin, de tal forma que no se permita el ingreso de un

cdigo de alumno repetido.
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. 204
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. 205
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
:
:
:
:
(String)
(lint)
:
:
9999
numArt = 0
Donde:
(double)
(double)
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. 206
(int)
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. 207
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?");
}
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. 208
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");
}
}

1

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.
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. 209
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)
Donde:
(int)
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. 210
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. 211
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. 212
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. 213
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. 214
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. 215

1

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.
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. 216
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
nom (0)
alquileres
cod (1)
cos (0)
sto (1)
alq (2)
tot (3)
:
:
:
:
:
:
:
:
:
:
:
:
9
(String)
Donde:
(int)
(double)
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. 217
numPel = 0
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. 218
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. 219
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. 220
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. 221

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. 222
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
0
PJ (0)
PG (0)
PE (0)
GF (1)
GC (2)
PA (3)
:
:
:
:
:
:
:
:
:
:
:
:
:
:
9999
9999
(int)
( String )
Donde:
numEqu = 0
( int )
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. 223
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. 224
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. 225
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. 226
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. 227
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. 228
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. 229
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)
:
:
:
:
:
:
:
:
9999
9999
(double)
Donde:
(int)
(String)
numAlu permite almacenar el nmero de alumnos.

nom = Nombre del alumno.
ape = Apellido del alumno.
cod = Cdigo del alumno.
Pg. 230
numAlu = 0
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. 231
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. 232
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. 233
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. 234
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. 235
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. 236

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
}
Observe cmo se utilizan los componentes de Java para mejorar la visualizacin de los
datos.
Pg. 237
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)
:
:
:
:
:
:
:
:
:
:
:
:
9
numChar = 0
(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. 238

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. 239
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. 240
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. 241
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. 242
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. 243
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. 244
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. 245
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. 246
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. 247

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. 248
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
0
num (0)
cac (1)
cat (2)
:
:
:
:
:
:
:
:
9999
numMes = 0
9999
(String)
Donde:
(int)
(String)
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. 249
..
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. 250
..
""
""
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. 251
..
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. 252
..
""
""
""
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. 253
..
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. 254
..
}
} 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. 255
..
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. 256
..
}
}
} // 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. 257
..
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. 258
..
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. 259
..
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. 260
..
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. 261
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
0
CA (0)
PC (1)
PV (2)
:
:
:
:
:
:
:
:
9999
9999
(String)
Donde:
numEqu = 0
(int)
(String)
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. 262
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. 263
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. 264
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. 265
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. 266
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. 267
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. 268
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. 269
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. 270
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. 271
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. 272
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. 273
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. 274
Clase PrgInventario
..

cadena += " " ;
}
return cadena ;
} // Fin de clase
Pg. 275
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
nom (0)
dir (1)
dis (2)
:
:
:
:
:
:
DNI
sueldos
:
:
:
:
:
:
(long)
(double)
0
1
2
numEmp = 0
:
:
:
9999
(String)
Donde:
(int)
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. 276
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. 277
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. 278
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. 279
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 ;
""
""
""
""
""
q
""
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
empleado: " +
datos[pos3][0] ) ;
Pg. 280
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. 281
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: " +
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: " +
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: " +
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
registrado; reintente " ) ;
}
} while ( buscarDni ( dni[numEmp] ) != -1 ) ;
// Ingreso del sueldo
do {
sueldos[numEmp] = LE.leerDouble ( " Ingrese el sueldo del empleado: " + (
datos[numEmp][0] ) ) ;
if (sueldos[numEmp] < 1 ) {
LE.mostrarError ( " Error, el sueldo ingresado es incorrecto; reintente " ) ;
}
} while ( sueldos[numEmp] < 1 ) ;
numEmp++ ;
Pg. 282
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. 283
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. 284
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. 285
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. 286
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: " +
datos[pos][0] ) ;
if ( sueldos[pos] < 1 ) {
LE.mostrarError ( " Error, el sueldo ingresado es incorrecto; reintente " ) ;
}
} while ( sueldos[pos] < 1 ) ;
Pg. 287
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",
""
Pg. 288
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. 289
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. 290
Clase PrgEmpresa
..

cadena += " " ;
}
return cadena ;
} // Fin de clase
Pg. 291
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
codigo
Nombre
sexo
edad
puntaje
situacion
:
:
numPos = 0
(int)
99999
99999
(int)
99999
(String)
Donde:
99999
(int)
(String)
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.
Pg. 292
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. 293
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. 294
""
""
""
""
""
""
""
""
codigo[pos]).toUpperCase ( );
if(!datos[pos][0].matches("[A-Z][A-Z]+[ ][A-Z][A-Z]+([ ][A-Z][AZ]+){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][AZ]+){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. 295
}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. 296
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][AZ]+){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][AZ]+){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. 297
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. 298
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. 299
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. 300
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. 301
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. 302
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
Lima Trujillo
S/. 10.00
Lima Chiclayo
S/. 15.00
Trujillo Chiclayo
S/. 5.00
Chiclayo Trujillo
S/. 5.00
Chiclayo Lima
S/. 15.00
Trujillo Lima
S/. 10.00

datos
documento
nombre
1
0
4
:
numPas = 0
99999
:
99999
(String)
Donde:
ruta
(int)
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.
Pg. 303
(int)

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. 304
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. 305
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. 306
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. 307
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. 308
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. 309
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. 310
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. 311
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. 312
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. 313
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. 314
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. 315
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. 316
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. 317
..
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--;
Llamada recursiva al
mtodo
OrdenarEnQuickSort ( );
}
} 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.
Pg. 318
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. 319
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
:
:
:
:
(String)
(int)
0
1
2
3
9999
numPer = 0
(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
:
:
:
:
:
:
(String)
(long)
(double)
0
1
2
3
numAlu - 1
numAlu
Pg. 320
(int)
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
numPra-1
0
1
2
.
:
.
:
.
:
(String)
(long)
.
:
.
:
numAlu
( int )
numAlu - 1
numPra
(double)
( int )
numAlu permite almacenar el nmero de alumnos.

numPra permite almacenar el nmero de prcticas.
Donde:
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
:
:
:
:
(String)
(lint)
:
:
9999
numArt = 0
Donde:
double)
(double)
numArt permite almacenar el nmero de artculos.

Pg. 321
(int)
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)
Donde:
(int)
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
nom (0)
alquiler
cod (1)
cos (0)
sto (1)
alq (2)
tot (3)
:
:
:
:
:
:
:
:
:
:
:
:
9
(String)
(int)
(long)
Pg. 322
numPel = 0
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
0
num (0)
cac (1)
cat (2)
:
:
:
:
:
:
:
:
9999
numMes = 0
9999
(String)
Donde:
(int)
(double)
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. 323
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
0
PJ (0)
PG (0)
PE (0)
GF (1)
GC (2)
PA (3)
:
:
:
:
:
:
:
:
:
:
:
:
:
:
numEqu -1
numEqu
numEqu - 1
(int)
( String )
( int )
numEqu permite almacenar el nmero de equipos que participan en el mundial.
Donde:
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)
:
:
:
:
:
:
:
:
9999
9999
(String)
(int)
(double)
Pg. 324
numEqu = 0
numEqu permite almacenar el nmero de tipos de equipo en inventario.
Donde:
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)
:
:
:
:
:
:
:
:
:
:
:
:
9
(int)
(String)
(double)
Donde:
numCha = 0
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. 325
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. 326
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
0
1
2
3
4
:
area
Rosa
Frank
Jos
Luis
Mara
:
0
1
2
3
4
:
99999
900
800
850
800
900
:
0
1
2
3
4
:
99999
99999
(String)
Donde:
sueldo
Aulas Virtuales
Second Life
Web Docente
Second Life
Aulas Virtuales
:
(String)
(Double)
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
codigo
nombre
99999
Donde:
PC
PV
99999
(String)
CA
99999
(String)
(int)
(Double)
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.
Pg. 327
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
dni
sueldo
99999
99999
numEmp = 0
(int)
99999
(Double)
Donde:
(long)
(Double)
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
codigo
nombre
99999
EXP
EXF
99999
(long)
PTR
99999
(String)
Pg. 328
(int)
(Double)
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:
RUTAS PARCIALES
COSTO
Lima Huacho
S/. 8.00
Lima Barranca
S/. 8.00
Huacho Barranca
S/. 8.00
Barranca Huacho
S/. 8.00
Barranca Lima
S/. 8.00
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
ruta
costo
99999
99999
(Double)
Donde:
99999
(long)
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.
Pg. 329
(Double)
numPas = 0
(int)
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. 330
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
nom (0)
datos2
aut (1)
:
:
9
Donde:
exp (1)
:
:
:
:
:
:
:
:
9
(long)
sol (0)
numTem = 0
9
(String)
(int)
(int)
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. 331
[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.
Pg. 332

Arreglos en Paralelo v.2012

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Arreglos en Paralelo v.2012

Enviado por

Direitos autorais:

Formatos disponíveis

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Estructuras lgicas de secuencia.

Estructuras lgicas de decisin.

Estructuras lgicas de repeticin.

Clases incorporadas en el lenguaje

Estructuras de datos tipo variables.

Estructuras de datos tipo arreglo.

En este captulo se presenta un resumen sobre los conceptos ms importantes relacionados

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

ESTRUCTURA DE DATOS - ARREGLOS

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

Un arreglo no puede almacenar datos de diferente tipo. Se puede tener un arreglo de

Dependiendo del tipo de arreglo, unidimensional o bidimensional, se necesitar uno o

Antes de crear un arreglo es necesario conocer el nmero exacto de datos que se

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

ARREGLOS UNIDIMENSIONALES - VECTORES

Nombre del vector.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

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

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

En Java, existe tambin una forma directa

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

ARREGLOS BIDIMENSIONALES - MATRICES

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Datos del mismo

Donde numTrab permite almacenar el nmero de trabajadores.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Dados los vectores:

Datos del mismo

Donde numSoc permite almacenar el nmero de socios.

Finalmente, en la siguiente Grfica de Estructura de Datos se utiliza una variable, un vector y

Dados los vectores:

numArt permite almacenar el nmero de Artculos.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

ARREGLOS DE GRAN TAMAO

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

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

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Defina el nombre del proyecto, desarrolle la definicin de paquetes, el diagrama de paquetes, la

5. Grfica de Estructura de Datos.

Dados los vectores:

Disee el algoritmo de la solucin en Pseudocdigo.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Etapa 04 Desarrollo de la codificacin.

public static void main(String[] args) {

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Defina el nombre del proyecto, desarrolle la definicin de paquetes, el diagrama de paquetes, la

5. Grfica de Estructura de Datos.

Dados los vectores:

Disee el algoritmo de la solucin en Pseudocdigo.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Etapa 04 Desarrollo de la codificacin.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.

Defina el nombre del proyecto, desarrolle la definicin de paquetes, el diagrama de paquetes, la

5. Grfica de Estructura de Datos.

Dados los arreglos:

Disee el algoritmo de la solucin en Pseudocdigo.

PROCESAMIENTO DE DATOS (PD): USO DE ARREGLOS EN PARALELO.