Está en la página 1de 244

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.

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Problema 015
Etapa 01 - Descripcin del problema.
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.
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

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.

Disee el algoritmo de la solucin en Pseudocdigo.

Pg. 104

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgUniversidad

package dominioDeLaAplicacion;
import biblioteca.LE;
public class PrgUniversidad {
public static void main(String[] args) {
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

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

Problema 016
Etapa 01 - Descripcin del problema.
Enunciado:
Desarrolle la codificacin en JAVA de una solucin que permita ingresar y almacenar el
cdigo, nombre y las tres notas de todos los alumnos, calcular y mostrar el promedio de cada
alumno.
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 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.

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

Disee el algoritmo de la solucin en Pseudocdigo.

Pg. 106

(int)

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgPromedio2

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

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][3];
String nombre[]=new String[numAlum];

Se utiliza una estructura


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

for(int r=0;r<numAlum;r++){
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";
for(int i=0;i<numAlum;i++){
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

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

Problema 017
Etapa 01 - Descripcin del problema.
Enunciado:
Desarrolle la codificacin en JAVA de una solucin que permita ingresar y almacenar el
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.
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 arreglos:


codigo

nombre

notas
0

0
1
2
3

:
:

:
:

(Double)

(lint)

:
:

:
:

numNotas - 1

:
:
:
:
:
:

:
:

9999

numAlu = 0
( (double)

Donde:

Donde numAlu permite almacenar el nmero de alumnos cuyos datos se han almacenado.
Donde numNotas permite almacenar el nmero de notas de cada alumno.

Disee el algoritmo de la solucin en Pseudocdigo.

Pg. 108

(int)

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgPromedioGeneral
package dominioDeLaAplicacion;
import biblioteca.LE;
public class PrgPromedioGeneral {

public static void main(String[] args) {


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

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.

for(int r=0;r<numAlum;r++){
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";
for(int i=0;i<numAlum;i++){
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 (PD): USO DE ARREGLOS EN PARALELO.

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

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

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

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

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

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

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

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 con su respectiva validacin.
do{
codigos[i]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
if (codigos[i]<0 ){
LE.mostrarError ( Lo sentimos, el cdigo ingresado es incorrecto );
}
} while (codigos[i]<0 );
// Ingreso del Nombre con validacin.
do{
nombres[i]=LE.leerString ( Ingrese el nombre del alumno: + (i+1) );
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 );

}// Fin del mtodo IngresarDatos

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

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

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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


for ( int i = 0 ; i < numAlu ; i++ ){
// 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

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

PROCESAMIENTO DE DATOS UTILIZANDO ARREGLOS

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

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

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

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

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

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

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
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
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

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

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

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

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
ENTRADA: numAlu, notas[ ], valor
SALIDA:
mensaje
INICIO
TEXTO mensaje
NUMERO notas[ ], numAlu, pos = -1, valor, i
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 la posicin de
un valor en el vector notas
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
SI ( notas[i] = valor )
ENTONCES
pos = i
TERMINAR
FINSI
FINDESDE
SI ( pos >= 0 )
ENTONCES
mensaje = Valor encontrado en la posicin + pos
SINO
mensaje = Valor no encontrado
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

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

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.

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

PrgBuscarPosicionSec main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgBuscarPosicionSec {
public static void main ( String [ ] args ) {
int notas[ ], numAlu = 0, valor, pos = -1, i ;
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) {
pos = i ;
break ;
}
}
if ( pos >= 0 )
mensaje = "Valor encontrado en la posicin " + pos ;
else {
mensaje = "Valor no encontrado " ;
}
System.out.println (mensaje) ;
}
}

Pg. 122

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

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

Algoritmo PrgBuscarCantidadSec
ENTRADA: numAlu, notas[ ], valor
SALIDA:
mensaje
INICIO
TEXTO mensaje
NUMERO notas[ ], numAlu, cantidad = 0, valor, i
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 del nmero de
veces que se encuentra un valor en el vector notas
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
SI ( notas[i] = valor )
ENTONCES
cantidad = cantidad + 1
FINSI
FINDESDE
SI ( cantidad > 0 )
ENTONCES
mensaje = Valor encontrado + cantidad + veces.
SINO
mensaje = Valor no encontrado
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

PrgBuscarCantidadSec main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgBuscarCantidadSec {
public static void main ( String [ ] args ) {
int notas[ ], numAlu = 0, valor, cantidad = 0, i ;
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 ) {
cantidad ++ ;
}
}
if ( cantidad > 0 )
mensaje = "Valor encontrado " + cantidad + " veces" ;
else {
mensaje = "Valor no encontrado" ;
}
System.out.println (mensaje) ;
}
}

Pg. 124

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

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
SI ( notas[i] = valor )
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.
Algoritmo Bsqueda Lineal Mtodo buscarValorSec ( )
public boolean buscarValorSec ( int valor ) {
int i ;
boolean estado = false ;
for ( i = 0; i < notas.lenght; i++ ) {
if ( notas[i] == valor ) {
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
DESDE i = 0 HASTA notas.LONGITUD - 1
SI ( notas[i] = valor )
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

Bsqueda Lineal Mtodo buscarPosicionSec ( )


public int buscarPosicionSec ( int valor ) {
int i, pos = -1 ;
for ( i = 0; i < notas.lenght; i++ ) {
if ( notas[i] == valor ) {
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
DESDE i = 0 HASTA notas.LONGITUD - 1
SI ( notas[i] = valor )
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

Bsqueda Lineal Mtodo buscarCantidadSec ( )


public int buscarCantidadSec ( int valor ) {
int i, cantidad = 0 ;
for ( i = 0; i < notas.lenght; i++ ) {
if ( notas[i] == valor ) {
cantidad ++ ;
}
}
return cantidad ;
}

Pg. 128

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

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

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

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

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

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
ENTRADA: numAlu, notas[ ], valor
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
constituyen la parte
central del algoritmo.

alto = numAlu - 1
central = (bajo+alto) DIVIDIR 2
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 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
mensaje = Valor no encontrado
FINSI
ESCRIBIR mensaje
FIN

Pg. 131

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

PrgBuscarPosicionBin main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgBuscarPosicionBin {
public static void main ( String [ ] args ) {
int notas[ ], numAlu, pos = -1 ;
int bajo = 0, alto, central, valor = 0 ;
String mensaje ;
System.out.print ( "Ingrese el nmero de alumnos: " ) ;
numAlu = Lectura.leerInt ( ) ;
notas = new int[numAlu] ;
alto = numAlu - 1 ;
central = (bajo + alto) / 2 ;
for ( int 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 ( ) ;
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 {
mensaje = "Valor no encontrado" ;
}
System.out.print ( mensaje ) ;
}
}

Pg. 132

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

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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

Algoritmo Bsqueda Binaria Mtodo buscarPosicionBin ( )


package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgBuscarPosicionBin {
public static void main ( String [ ] args ) {
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

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

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 ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgBuscarPosicionSec {
public static void main ( String [ ] args ) {
int numAlu = 0, pos = -1, i ;
String nombres[ ], valor, mensaje ;
System.out.print ( Ingrese el nmero de alumnos: ) ;
numAlu = Lectura.leerInt ( ) ;
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 ;
}
System.out.println (mensaje) ;
}
}

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

Pg. 135

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

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

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

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

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

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

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

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

Ahora, se selecciona el elemento del vector que tenga el nmero


menor entre los elementos restantes:

13

17

20

18

19

El elemento seleccionado se intercambia con el tercer elemento del


vector:
13

17

18

20

19

Pg. 139

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

Ahora, se selecciona el elemento del vector que tenga el nmero


menor entre los elementos restantes:

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

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

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
constituyen la parte
central del algoritmo.

LEER numAlu
CREAR notas[numAlu]
COMENTARIO Ingresar datos al vector notas
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
LEER notas[i]
FINDESDE
COMENTARIO Ordenacin por seleccin
NUMERO k, j, nota
DESDE i = 0 HASTA i = numAlu - 2 INCREMENTA 1
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
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
ESCRIBIR notas[i]
FINDESDE
FIN

Pg. 141

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

PrgOrdenacionSeleccion main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgOrdenacionSeleccion {
public static void main ( String [ ] args ) {
int notas[ ], numAlu, i ;
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 ( ) ;
}
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

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

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

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

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

El elemento tomado se inserta en el lugar que le corresponde entre


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

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

El elemento tomado se inserta en el lugar que le corresponde entre


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

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

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

Algoritmo PrgOrdenacionInsercion
ENTRADA: numAlu, notas[ ]
SALIDA:
notas[ ]
INICIO
NUMERO notas[ ], numAlu, i
LEER numAlu
CREAR notas[numAlu]
COMENTARIO Ingresar datos al vector notas
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
LEER notas[i]
FINDESDE
COMENTARIO Ordenacin por insercin
NUMERO j, nota, sw
DESDE i = 1 HASTA i = numAlu - 1 INCREMENTA 1
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
COMENTARIO Mostrar datos ordenados
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
ESCRIBIR notas[i]
FINDESDE
FIN

Pg. 146

Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.

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

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

Algoritmo PrgOrdenacionInsercion
ENTRADA: numAlu, notas[ ]
SALIDA:
notas[ ]
INICIO
NUMERO notas[ ], numAlu, i
LEER numAlu
CREAR notas[numAlu]
COMENTARIO Ingresar datos al vector notas
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
LEER notas[i]
FINDESDE
COMENTARIO Ordenacin por insercin
NUMERO j, nota
DESDE i = 1 HASTA i = numAlu - 1 INCREMENTA 1
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
COMENTARIO Mostrar datos ordenados
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
ESCRIBIR notas[i]
FINDESDE
FIN

Pg. 147

Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.

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

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


continuacin:

Algoritmo PrgOrdenacionInsercion
ENTRADA: numAlu, notas[ ]
SALIDA:
notas[ ]
INICIO
NUMERO notas[ ], numAlu, i
LEER numAlu
CREAR notas[numAlu]
COMENTARIO Ingresar datos al vector notas
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
LEER notas[i]
FINDESDE
COMENTARIO Ordenacin por insercin
NUMERO j, tempNota
DESDE i = 1 HASTA i = numAlu - 1 INCREMENTA 1
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
COMENTARIO Mostrar datos ordenados
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
ESCRIBIR notas[i]
FINDESDE
FIN

Pg. 148

Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

PrgOrdenacionInsercion main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgOrdenacionInsercion {
public static void main ( String [ ] args ) {
int notas[], numAlu, i ;
numAlu = LE.leerInt( "Ingrese el nmero de alumnos: " ) ;
notas = new int[numAlu] ;
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++ ) {
System.out.println ( "La nota " + (i+1) + " es: " + notas[i] ) ;
}
}
}

Pg. 149

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

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

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

Algoritmo PrgOrdenacionIntercambio
ENTRADA: numAlu, notas[ ]
SALIDA:
notas[ ]
INICIO
NUMERO notas[ ], numAlu, i

Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.

LEER numAlu
CREAR notas[numAlu]
COMENTARIO Ingresar datos al vector notas
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
LEER notas[i]
FINDESDE
COMENTARIO Ordenacin por insercin
NUMERO j, nota
DESDE i = 0 HASTA i = numAlu - 2 INCREMENTA 1
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
COMENTARIO Mostrar datos ordenados
DESDE i = 0 HASTA numAlu 1 INCREMENTA 1
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


programacin Java del algoritmo anterior.

PrgOrdenacionIntercambio main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgOrdenacionIntercambio {
public static void main ( String [ ] args ) {
int notas[ ], numAlu, i ;
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 ( ) ;
}
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++ ) {
System.out.println ( "La nota " + (i+1) + " es: " + notas[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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


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 ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgOrdenacionIntercambio {
public static void main ( String [ ] args ) {
int numAlu, i ;
String nombres[], nombre ;
System.out.print ( "Ingrese el nmero de alumnos: " ) ;
numAlu = Lectura.leerInt ( ) ;
nombres = new String[numAlu] ;
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

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

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

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

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

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

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

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

El mismo procedimiento se aplicar al otro subvector. Al finalizar y


unir todos los subarrays queda el array inicial ordenado en forma
ascendente.

A continuacin se muestra el desarrollo de la codificacin en lenguaje de


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

Mtodo OrdenarEnQuickSort
..

package dominioDeLaAplicacion;
import biblioteca.*;
public class PrgOrdenamientoQuickSort {
int notas[];
int numAlu;
public PrgOrdenamientoQuickSort ( ) {
numAlu = LE.leerInt("Ingrese la cantidad de alumnos: ");
notas = new int[numAlu];
}
public static void main(String[] args) {
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

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

Mtodo OrdenarEnQuickSort
..

public void Mostrar ( ) {


String lista = "";
for (int i = 0; i < numAlu; i++) {
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( );

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

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

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

Problema 018
Etapa 01 - Descripcin del problema.
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.
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. 160

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgAlumnos
package dominioDeLaAplicacion;
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

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

Clase PrgAlumnos
case 3:
if ( sw )
buscar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 4:
if ( sw )
ordenar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 5:
if ( sw )
mostrar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
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

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

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 = " " ;
for ( int i=0; i<numAlu; i++ ) {
total += "\n" + codigo[i] + "/" + nombre[i] + "/" + nota[i] ;
}
LE.mostrarResultado ( " Los datos de los alumnos son: " + "
}
}

Pg. 163

" + total ) ;

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

Problema 019
Etapa 01 - Descripcin del problema.
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.

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

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.

Disee el algoritmo de la solucin en Pseudocdigo.

Pg. 164

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

Etapa 04 Desarrollo de la codificacin.

Clase PrgUniversidad
package dominioDeLaAplicacion;
import biblioteca.LE ;

public class PrgUniversidad {


String nombre[ ] ;
long codigo[ ] ;
double sueldo[ ] ;
int numEmp ;
public PrgUniversidad ( ) {
numEmp = 0 ;
nombre = new String [9999] ;
codigo = new long [9999] ;
sueldo = new double [9999] ;
}

public static void main ( String[ ] args ) {


PrgUniversidad obj = new PrgUniversidad ( ) ;
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

Pg. 165

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

Clase PrgUniversidad
LE.mostrarError ( " Error...Ingrese los datos " ) ;
break ;
case 3:
if ( sw )
buscar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 4:
if ( sw )
ordenar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 5:
if ( sw )
mostrar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 6:
break ;
default:
LE.mostrarError ( " Opcin no vlida Reintente! " ) ;
}
} while ( opc != 6 ) ;
}
public void ingresar () {
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++ ;
rpta = LE.mostrarPreguntaOpcion2 ( " Desea continuar ? " ) ;
} while ( rpta == 0 ) ;
}
public void calcular ( ) {
double prom = 0, suma = 0 ;
for ( int i=0; i<numEmp; i++ ) {
suma += sueldo[i] ;
}

Pg. 166

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

Clase PrgUniversidad
prom = suma / numEmp ;
prom = Math.round ( prom*100 ) / 100.0 ;
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<numEmp; i++ ) {
if (codigo[i] == aux){
LE.mostrarInformacion("Datos del Alumno: "+"codigo:"+ codigo[i]+"
nombre: "+ nombre[i]+" sueldo: "+ sueldo[i]);
break;
}
}
LE.mostrarInformacion( " Error...Codigo no Encontrado " );
}
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];
codigo[i] = codigo[j];
sueldo[i] = sueldo[j];
nombre[j]=aux1;
codigo[j]=aux2;
sueldo[j]=aux3;
}
}
public void mostrar ( ) {
String total = " " ;
for ( int i=0; i<numEmp; i++ ) {
total += "\n" + codigo[i] + "/" + nombre[i] + "/" + sueldo[i] ;
}
LE.mostrarResultado ( " Los datos de los alumnos son: " + "
}
}

Pg. 167

" + total ) ;

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

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

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

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
Donde numAlu permite almacenar el nmero de alumnos.

Pg. 169

(int)

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

Datos reemplazados:

Nuevo nombre = Carmen

Nueva nota
= 17

Pg. 171

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

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
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
LEER codigos[i]
LEER nombres[i]
LEER notas[i]
FINDESDE

Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.
Conjunto de
instrucciones que
constituyen la parte
central del algoritmo.

COMENTARIO Ingreso del cdigo a buscar


LEER codigo
COMENTARIO Bsqueda secuencial o lineal. Bsqueda de un valor en el
vector codigos[ ]
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de programacin Java


del algoritmo anterior.
PrgModificarDatos main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgModificarDatos {
public static void main ( String [ ] args ) {
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] ;
nombres = new String[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

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

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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)

Donde numAlu permite almacenar el nmero de alumnos.

Pg. 175

(boolean)

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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)

Donde numAlu permite almacenar el nmero de alumnos.

Pg. 179

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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

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

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
constituyen la parte
central del algoritmo.

COMENTARIO Ingresar datos a los vectores


DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
LEER codigos[i]
LEER nombres[i]
LEER notas[i]
FINDESDE
COMENTARIO Ingreso del cdigo a buscar
LEER codigo
COMENTARIO Bsqueda secuencial o lineal. Bsqueda de un valor en el
vector codigos[ ]
DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
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

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

A continuacin se muestra el desarrollo de la codificacin en lenguaje de programacin Java


del algoritmo anterior.
PrgEliminarDatos main ( )
package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgEliminarDatos {
public static void main ( String [ ] args ) {
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] ;
nombres = new String[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

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

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

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

Problema 020
Etapa 01 - Descripcin del problema.
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.

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:
nombre

codigo

nota

:
:

:
:

:
:

(String)

(long)

(double)

estado

0
1
2
3

9999

numAlu = 0
(boolean)

(int)

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

Disee el algoritmo de la solucin en Pseudocdigo.

Pg. 184

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgAlumnos
package dominioDeLaAplicacion;
import biblioteca.LE ;
public class PrgAlumnos {
String nombre[ ] ;
long codigo[ ] ;
double nota[ ] ;
boolean estado[ ] ;
int numAlu ;
public PrgAlumnos ( ) {
numAlu = 0 ;
nombre = new String [9999] ;
codigo = new long [9999] ;
nota = new double [9999] ;
estado = 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) Modificar Datos \n "
+" 4) Eliminacin Lgica de Datos\n "
+" 5) Mostrar Datos \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. 185

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

Clase PrgAlumnos
case 3:
if ( sw )
modificar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 4:
if ( sw )
eliminar ();
else
LE.mostrarError ( " Error...Ingrese los datos ");
break ;
case 5:
if ( sw )
mostrar ( ) ;
else
LE.mostrarError ( " Error...Ingrese los datos " ) ;
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++ ;
estado[numAlu] =true;
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] ;

Pg. 186

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

Clase PrgAlumnos
}
prom = suma / numAlu ;
prom = Math.round ( prom*100 ) / 100.0 ;

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


}
public void modificar ( ) {
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){
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 ) {
LE.mostrarError ( " Error...Notas ingresada Errnea " ) ;
}
} while ( nota[i] < 0 || nota[i] > 20 ) ;
break;
}
}
LE.mostrarInformacion( " Error...Codigo no Encontrado " );
}
public void eliminar ( ){
long aux = 0 ;
aux = LE.leerLong( " Ingrese el codigo del alumno que desea eliminar: " ) ;
for( int i=0; i<numAlu; i++ ) {
if (codigo[i] == aux){
estado = false;
}
break;
}
LE.mostrarInformacion( " Error...Codigo no Encontrado " );
}
public void mostrar ( ) {
String total = " " ;
for ( int i=0; i<numAlu; i++ ) {
if (estado[i] ==true){
total += "\n" + codigo[i] + "/" + nombre[i] + "/" + nota[i] ;
}
}
LE.mostrarResultado ( " Los datos de los alumnos son: " + "
}
}

Pg. 187

" + total ) ;

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

Problema 021
Etapa 01 - Descripcin del problema.
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.
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:
nombre

cantidad

precio

:
:

:
:

:
:

(String)

(long)

(double)

0
1
2
3

9999

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

Disee el algoritmo de la solucin en Pseudocdigo.

Pg. 188

(int)

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgArticulos
package dominioDeLaAplicacion ;
import biblioteca.LE ;
public class PrgArticulos {
String nombre [ ] ;
long cantidad [ ] ;
double precio [ ] ;
int numArt ;

public PrgArticulos ( ) {
nombre = new String [9999] ;
cantidad = new long [9999] ;
precio = new double [9999] ;
numArt = 0 ;
}
public static void main ( String[ ] args ) {
PrgArticulos obj = new PrgArticulos ( ) ;
obj.menu ( ) ;
}
public void 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;
boolean sw = false ;
do {
opc = LE.leerInt ( menu ) ;
switch ( opc ) {
case 1:
ingresar ( ) ;
sw = true ;
break ;
case 2:
if ( sw )
mostrar ( ) ;
else
LE.mostrarError ( " Error...Ingrese los datos " ) ;
break ;
case 3:

Pg. 189

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

Clase PrgArticulos
if ( sw )
calcularGanancia ( ) ;
else
LE.mostrarError ( " Error...Ingrese los datos " ) ;
break ;
case 4:
if ( sw )
modificar ( ) ;
else
LE.mostrarError ( " Error...Ingrese los datos " ) ;
break ;
case 5:
if ( sw )
eliminar ( ) ;
else
LE.mostrarError ( " Error...Ingrese los datos " ) ;
break ;
case 6:
finalizar ( ) ;
break ;
default:
LE.mostrarError ( " Opcin no vlida Reintente! " ) ;
}
} 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++ ;
rpta = LE.mostrarPreguntaOpcion2 ( " Desea continuar ? " ) ;
} while ( rpta == 0 ) ;
}

public void mostrar ( ) {


String total = " " ;
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

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

Clase PrgArticulos
prod = cantidad[i] * precio[i] ;
suma += prod ;
}
LE.mostrarResultado ( " La ganancia total al vender todos los productos
es:
" + suma ) ;
}
public void modificar ( ) {
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;
}
}
LE.mostrarInformacion( " Error...Codigo no Encontrado " );
}
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;
}
LE.mostrarInformacion( " Error...Codigo no Encontrado " );
}
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

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

PROCESAMIENTO DE DATOS UTILIZANDO ARREGLOS

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)

Donde numAlu permite almacenar el nmero de alumnos.

Pg. 192

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

El mtodo que desarrollamos fue el siguiente:


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

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:

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( );
}
// Ingreso del cdigo.
codigos[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
// Ingreso del Nombre
nombres[numAlu]=LE.leerString ( Ingrese el nombre del alumno: + (i+1) );
// Ingreso de las notas.
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);
}// Fin del mtodo IngresarDatos

Pg. 193

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

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( );
}
// Ingreso del cdigo.
codigos[numAlu]=LE.leerLong ( Ingrese el cdigo del alumno: + (i+1) );
// Ingreso del Nombre
nombres[numAlu]=LE.leerString ( Ingrese el nombre del alumno: + (i+1) );
E

// Ingreso de las notas.


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);
}// Fin del mtodo IngresarDatos

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

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

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

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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

nombres

notas

25

LUIS

14

Pg. 196

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

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)

Donde numAlu permite almacenar el nmero de alumnos.

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)

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

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

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

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

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

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 ) ;
for ( int i = 0; i < numAlu; i++ ) {
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

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

Problema 022
Etapa 01 - Descripcin del problema.
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
Donde numAlu permite almacenar el nmero de alumnos.

Etapa 04 Desarrollo de la codificacin.


Clase PrgAlumnos
..

package dominioDeLaAplicacion ;
import biblioteca.LE ;
public class PrgAlumnos {
String nombre[ ];
long codigo[ ];
double promedio[ ];
int numAlu;
public static void main (String[ ] args) {
PrgAlumnos x = new PrgAlumnos ( );
x.menu ( );
}

public PrgAlumnos ( ) {
nombre = new String[9999];
codigo = new long[9999];

Pg. 201

(int)

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

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

public void menu ( ) {


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);
}

public void ingresar ( ) {


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

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

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

public void mostrar ( ) {


String datos = "Los datos de los alumnos son los siguientes:\n" +
""
"nombre/codigo/promedio\n\n";
for (int i = 0; i < numAlu; i++) {
datos += (i+1) + " "
+ nombre[i]
+ "/"
+ codigo[i]
+ "/"
+ promedio[i]
+ "\n";
}
LE.mostrarInformacion (datos + "\n");
}

public void porcentajeAprobados ( ) {


double porApro = 0;
int cont=0;
for (int i = 0; i < numAlu; i++) {
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;
for (int i = 0; i < numAlu; i++) {
if (promedio[i] <= 10.5) {
cont++;
}
}

Pg. 203

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

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") ;
}

public void finalizar ( ) {


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

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

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";
for(int i=0;i<numAlu;i++){
if(promedios[i]==mayor){
texto += codigos[i]+ "/" + nombres[i] + "\n";
}
}
LE.mostrarInformacion (texto + "...\n");
}

public double mayorNota ( ) {


double mayor = mayorNota ( );
for(int i=0;i<numAlu;i++){
if(promedios[i]>=mayor){
mayor=promedios[i];
}
}
return mayor;
}

Pg. 205

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

Problema 023
Etapa 01 - Descripcin del problema.
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.
Utilice la Grfica de Estructuras de Datos mostrada.
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.


PV = Precio de venta.
PC = Precio de compra.

Etapa 04 Desarrollo de la codificacin.


Clase PrgLibreria
..

package dominioDeLaAplicacion ;
import biblioteca.LE ;
public class PrgLibreria {
String nombres[ ];
int cantidad[ ], numArt;
double precios[ ][ ];
public static void main(String[] args) {
PrgLibreria x = new PrgLibreria ( );
x.menu ( );
}

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

Pg. 206

(int)

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

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 {
opc = LE.leerInt(menu);
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

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

Clase PrgLibreria
..

public void ingresar ( ) {


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

public void utilidadObtenida ( ) {


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

public void ordenar ( ) {


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

Pg. 208

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

Clase PrgLibreria
..

}
}
}
}

public void mostrar ( ) {


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");
}

public void finalizar ( ) {


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 artculos. Aunque resulta
improbable que se necesiten almacenar tal cantidad de datos y si fuera el caso, se
utilizara otra estrategia de solucin.

No se ha incluido una validacin, de tal forma que no se permita el ingreso de un


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

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

Problema 024
Etapa 01 - Descripcin del problema.
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.

Etapa 04 Desarrollo de la codificacin.

Clase PrgPosada
..

package dominioDeLaAplicacion ;
import biblioteca.LE ;
public class PrgPosada {
int datosPosada[ ][ ], numHab ;
public PrgPosada ( ) {
datosPosada = new int[9999][4] ;
numHab = 0 ;

Pg. 210

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

Clase PrgPosada
..

public static void main ( String[ ] args ) {


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){
LE.mostrarError ("Ingrese los datos");
break;
}
do{

""

numCuarto = LE.leerInt ("Ingrese el nmero de habitacin que desea


buscar");
pos = buscar (numCuarto);

Pg. 211

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

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){
LE.mostrarError ("Ingrese los datos");
break;
}
numCuarto = LE.leerInt("Ingrese el nmero de habitacin que desea
alquilar");
pos = buscar (numCuarto);
alquilar(pos);
break;
case 5:
if(sw ==1){
LE.mostrarError ("Ingrese los datos");
break;
}
numCuarto = LE.leerInt ("Ingrese el nmero de habitacin que desea
desocupar");
pos = buscar (numCuarto);
desocupar(pos);
break;
case 6:
if(sw ==1){
LE.mostrarError ("Ingrese los datos");
break;
}
calcularGanancia ( );
break;
case 7 :
if(sw ==1){
LE.mostrarError ("Ingrese los datos");
break;
}
ordenar ( );
break;
case 8 :
if(sw ==1){
LE.mostrarError ("Ingrese los datos");
break;
}
numCuarto = LE.leerInt ("Ingrese el nmero de la habitacin");
pos = buscar (numCuarto);
modificar(pos);
break;
case 9 :
if(sw ==1){

Pg. 212

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

Clase PrgPosada
..

LE.mostrarError ("Ingrese los datos");


break;
}
numCuarto =LE.leerInt ("Ingrese el nmero de la habitacin");
pos = buscar (numCuarto);
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?" );
} while (rpta == 0);
}

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

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

Clase PrgPosada
..

public void alquilar ( int p ){


if(datosPosada[p][2]==2){
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 ){


if(datosPosada[p][2]==1){
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;
LE.mostrarInformacion (texto);
}

public void ordenar ( ) {


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[i][1] = datosPosada[j][1];
datosPosada[j][1] = temp1;
temp2 = datosPosada[i][2];
datosPosada[i][2] = datosPosada[j][2];
datosPosada[j][2] = temp2;

Pg. 214

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

Clase PrgPosada
..

temp3 = datosPosada[i][3];
datosPosada[i][3] = datosPosada[j][3];
datosPosada[j][3] = temp3;
}
}
}
}

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];
datosPosada[i][1] = datosPosada[i + 1][1];
datosPosada[i][2] = datosPosada[i + 1][2];
datosPosada[i][3] = datosPosada[i + 1][3];
}
numHab--;
}
} else {
LE.mostrarError ( "Habitacin no encontrada" );
}
}

public void finalizar ( ) {


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

Pg. 215

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

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 habitaciones. Aunque
resulta improbable que en una posada existen tal cantidad de habitaciones. Esta
situacin se resuelve en la solucin del siguiente problema.

No se ha incluido una validacin, de tal forma que no se permita el ingreso de un


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

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

Problema 025
Etapa 01 - Descripcin del problema.
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.

Etapa 04 Desarrollo de la codificacin.


Clase PrgVideos
..

package dominioDeLaAplicacion ;
import biblioteca.LE ;
public class PrgVideos {
String peliculas[ ][ ] ;

Pg. 217

numPel = 0

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

Clase PrgVideos
..

int alquileres[ ][ ] ;
int numPel ;

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

public static void main(String[] args) {


PrgVideos x = new PrgVideos ( );
x.menu ( );
}
public void 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 {
opc = LE.leerInt(menu);
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) {
LE.mostrarError ( "Error... Ingrese primero los datos" ) ;
}else{
alquiler ( );
}
break;
case 4:
if (sw == 1) {
LE.mostrarError ( "Error... Ingrese primero los datos" ) ;
}else{
devolucion ( );
}
break;
case 5:
if (sw == 1) {
LE.mostrarError ("Error... Ingrese primero los datos");

Pg. 218

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

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);
}
public void ingresar ( ) {
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?" ) ;
} while (rpta == 0);
}

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];
alq[i][1] = alquileres[i][1];
alq[i][2] = alquileres[i][2];
alq[i][3] = alquileres[i][3];
}
peliculas = pel;
alquileres = alq;
}

Pg. 219

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

Clase PrgVideos
..

public void mostrar ( ) {


String datos = "Datos de Pelculas\n";
datos += "Nombre / Cdigo / Precio / Stock / Alquiladas\n\n";
for (int i = 0; i < numPel; i++) {
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";;
LE.mostrarInformacion (texto);
}
}
}
} else {
LE.mostrarError ("Cdigo de la pelcula no existe!!!");
}
}

public int buscarCodigo ( String cod ) {


for (int i = 0; i < numPel; i++) {
if (peliculas[i][1].equalsIgnoreCase(cod)) {
return i;

Pg. 220

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

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;
LE.mostrarInformacion (texto);
}
} 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

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

Comentarios con relacin a la solucin planteada

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


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

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

Problema 026
Etapa 01 - Descripcin del problema.
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.

Etapa 04 Desarrollo de la codificacin.


Clase Futbol
..

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgFutbol {
int tabla[ ][ ], fechas ;
String equipos[ ] ;

Pg. 223

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

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 ( ) ;
}

public void 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:
if (equipos.length == 0) {
System.out.println ("No existen datos..." );
} else {
eliminar ( );
}
break;
case 4:
if (equipos.length == 0) {

Pg. 224

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

Clase Futbol
..

System.out.println ( "No existen datos..." );


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

public void ingresar ( ) {


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(""));
}

public void modificar ( ) {


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

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

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;
}
}

public void eliminar ( ) {


String tmpEquipos[];
int tmpDatos[][], numEquipo, aux;
char opc;
System.out.println ("\n\nEliminar un Equipo");
System.out.println ("---------------");
for (int i = 0; i < equipos.length; i++)
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;
for (int i = 0; i < equipos.length; i++) {
if (i != numEquipo) {
tmpEquipos[aux] = equipos[i];
tmpDatos[aux++] = tabla[i];
}
}
equipos = tmpEquipos;
tabla = tmpDatos;
}

Pg. 226

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

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);
for (int i = 0; i < equipos.length; i++)
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

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

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

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

Clase Futbol
..

String texto = ("Equipo" + espacios).substring(0, tamao + 2);


System.out.println(texto + "\tPJ\tPG\tPE\tGF\tGC\tP");
for (int i = 0; i < equipos.length; i++) {
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;
for (int i = 0; i < equipos.length; i++) {
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;
}
}

Comentarios con relacin a la solucin planteada

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


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

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

Problema 027

Etapa 01 - Descripcin del problema.


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

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

Etapa 04 Desarrollo de la codificacin.

Clase PrgAlumnos
..

package dominioDeLaAplicacion ;
import biblioteca.LE ;
import javax.swing.* ;
public class PrgAlumnos {
double notas[ ] ;
String datos[ ][ ] ;
int numAlu ;

public PrgAlumnos ( ) {
notas = new double[10] ;
datos = new String[10][3] ;
numAlu = 0 ;
}

public static void main(String[] args) {


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

public void 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 {
opc = LE.leerInt(menu) ;
switch (opc) {
case 1:
ingresar ( ) ;
sw = 1 ;
break ;
case 2:
if (sw == 1) {
visualizar ( ) ;
} else {
LE.mostrarError ("Error...Ingrese la primera opcin") ;

Pg. 231

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

Clase PrgAlumnos
..

}
break ;
case 3:
if (sw == 1) {
ordenar ( ) ;
} else {
LE.mostrarError ("Error...Ingrese la primera opcin") ;
}
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 {
LE.mostrarError ("Error...Ingrese la primera opcin") ;
}
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 {
LE.mostrarError ("Error...Ingrese la primera opcin") ;
}
break ;
case 6:
if (sw == 1) {
calcularNotas ( ) ;
} else {

Pg. 232

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

Clase PrgAlumnos
..

LE.mostrarError ("Error...Ingrese la primera opcin") ;


}
break ;
case 7:
if (sw == 1) {
calcularPromedio ( ) ;
} else {
LE.mostrarError ("Error...Ingrese la primera opcin") ;
}
break ;
case 8:
finalizar ( ) ;
break ;
default :
LE.mostrarError ("Error...Opcin no conocida") ;
}
} while (opc != 8) ;
}

public void ingresar ( ) {


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

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

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) ;
}

public void visualizar ( ) {


String informacion = " CODIGO"+ "\t" + " NOMBRES " + "\t" + " APELLIDOS" + "\t"
""
+ "NOTAS" + "\n" ;
informacion += " --------------------------------------------------------------------------------------""
-------------\n" ;
JTextArea muestraInformacion = new JTextArea( 10, 30 ) ;
JScrollPane desplazaInformacion = new JScrollPane( muestraInformacion ) ;
for ( int i = 0; i < numAlu; i++ ) {
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 ) ;

""

""
}

public void ordenar ( ) {


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[i][1] ;
datos[i][1] = datos[j][1] ;
temp2 = datos[j][1] ;
temp3 = datos[i][2] ;
datos[i][2] = datos[j][2] ;
datos[j][2] = temp3 ;
temp4 = notas[i] ;
notas[i] = notas[j] ;
notas[j] = temp4 ;
}
if (datos[i][0].equalsIgnoreCase(datos[j][0])) {
if (datos[i][1].compareToIgnoreCase(datos[j][1]) > 0) {
temp1 = datos[i][0] ;

Pg. 234

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

Clase PrgAlumnos
..

datos[i][0] = datos[j][0] ;
datos[j][0] = temp1 ;
temp2 = datos[i][1] ;
datos[i][1] = datos[j][1] ;
datos[j][1] = temp2 ;
temp3 = datos[i][2] ;
datos[i][2] = datos[j][2] ;
datos[j][2] = temp3 ;
temp4 = notas[i] ;
notas[i] = notas[j] ;
notas[j] = temp4 ;
}
}
}
}
}

public int buscar (String cod) {


int pos = -1 ;
for (int i = 0; i < numAlu; i++) {
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] ;
for (int i = 1; i < numAlu; i++) {
mayor = Math.max(notas[i], mayor) ;
menor = Math.min(notas[i], menor) ;
}

Pg. 235

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

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 ;
for (int i = 0; i < numAlu; i++) {
suma += notas[i] ;
}
prom = (suma / numAlu) ;
prom = Math.round(prom * 100) / 100.0 ;
String mensaje = "El promedio general es: " + prom ;
LE.mostrarInformacion (mensaje) ;
}

public void finalizar ( ) {


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] ;
for (int i = 0; i < numAlu; i++) {
dat[i][0] = datos[i][0] ;
dat[i][1] = datos[i][1] ;
dat[i][2] = datos[i][2] ;
not[i] = notas[i] ;
}
datos = dat ;
notas = not ;
}
}

Pg. 236

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

Comentarios con relacin a la solucin planteada


Ahora deber mejorar la solucin en base a los temas tratados en los problemas
anteriores.
Ahora, observe el mtodo visualizar:

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 ) ;
for ( int i = 0; i < numAlu; i++ ) {
informacion +=datos[i][2] + "\t" + datos[i][0] + "\t" + datos[i][1] + "\t" + notas[i] + "\n" ;
}
muestraInformacion.append ( informacion ) ;
JOptionPane.showMessageDialog( null, desplazaInformacion, "LISTA DEL SALN",
iii
JOptionPane.INFORMATION_MESSAGE ) ;
}

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

Pg. 237

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

Problema 028
Etapa 01 - Descripcin del problema.
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

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgCharlas
..

package dominioDeLaAplicacion ;
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 ;
}

public void menu ( ) {


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"
+ "Elija opcin deseada:\n" ;
boolean acceso = false ;
String opciones = opciones1;
do {
opc = LE.leerInt(opciones) ;
switch (opc) {
case 1:
ingresarDatos ( ) ;
acceso = true;

Pg. 239

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

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 {
LE.mostrarError ("La opcin ingresada es incorrecta");
}
break;
case 5:
if (acceso) {
ordenarDatos ( );
} else {
LE.mostrarError ("La opcin ingresada es incorrecta");
}
break;
case 6:

Pg. 240

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

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 {
LE.mostrarError ("El nombre de la charla ingresada no es vlido");
}
} else {
LE.mostrarError ("La opcin ingresada es incorrecta");
}
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{
LE.mostrarError ("El nombre de la charla ingresada no es vlido");
}
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

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

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

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

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)
+ completarConBlancosXDer ("" + asistentes[i][3], 30)
+ completarConBlancosXDer ("" + asistentes[i][4], 33)
+ "\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

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

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 ;
temp = asistentes[i][1] ;
asistentes[i][1] = asistentes[j][1] ;
asistentes[j][1] = temp ;
temp = asistentes[i][2] ;
asistentes[i][2] = asistentes[j][2] ;
asistentes[j][2] = temp ;
temp = asistentes[i][3] ;
asistentes[i][3] = asistentes[j][3] ;
asistentes[j][3] = temp ;
temp = asistentes[i][4] ;
asistentes[i][4] = asistentes[j][4] ;
asistentes[j][4] = temp ;

Pg. 244

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

Clase PrgCharlas
..

}
}
}
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
}

public void modificarDatos ( int pos ) {


if ( numChar == charlas.length ) {
aumentarTamaoArreglo ( ) ;
}
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 ;
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
}

public void eliminarDatos ( int pos ) {

Pg. 245

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

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-- ;
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
}

public int buscar ( String c ) {


int pos = -1 ;
for ( int i = 0; i < numChar; i++ ) {
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] ;
for ( int i = 0; i < numChar; i++ ) {
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

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

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

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

Comentarios con relacin a la solucin planteada


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

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

Problema 029
Etapa 01 - Descripcin del problema.
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.

Etapa 04 Desarrollo de la codificacin.


Clase PrgRestaurante
..

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgRestaurante {
String clientes[ ] ;
String datos[ ][ ] ;
int numMesa ;

Pg. 249

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

Clase PrgRestaurante
..

public static void main ( String[] args ) {


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

public PrgRestaurante ( ) {
clientes = new String[10000] ;
datos = new String[10000][3] ;
numMesa = 0 ;
} // Fin PrgRestaurante

public void menu ( ) {


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"
+ "Elija opcin deseada:\n" ;
boolean acceso = false ;
String menu = menu1, mesa ;
int opc, pos, rpta ;
do {
opc = LE.leerInt ( menu ) ;
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

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

Clase PrgRestaurante
..

""

""

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: " ) ;
pos = buscarMesa ( mesa ) ;
if ( pos != -1 ) {
utilizarMesa ( 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 5: // Calcular ganancias
if ( acceso ) {
menuCalculos ( ) ;
} else {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
break ;
case 6: // Ordenar datos
if ( acceso ) {
menuOrdenar ( ) ;
} else {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
break ;

""

case 7: // Modificar datos


if ( acceso ) {
mesa = LE.leerString ("Ingrese el Nro de mesa que desea modificar") ;
pos = buscarMesa ( mesa ) ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2 ( "Desea modificar los datos de la
mesa: " + datos[pos][0] ) ;
if ( rpta == 0 ) {

Pg. 251

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

Clase PrgRestaurante
..

menuModificar ( pos ) ;
} else {
LE.mostrarAdvertencia ( "La operacin fue cancelada" ) ;
}
} else {
LE.mostrarError ( "Error, el Nro de la mesa es incorrecto; reintente") ;
}
} else {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
break ;

""

case 8: // Eliminar datos


if ( acceso ) {
mesa = LE.leerString ("Ingrese el Nro de mesa que desea eliminar" ) ;
pos = buscarMesa ( mesa ) ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2( "Desea eliminar los datos de la
mesa: " + datos[pos][0] ) ;
if ( rpta == 0 ) {
eliminarDatos ( pos ) ;
} else {
LE.mostrarAdvertencia ( "La operacin fue cancelada" ) ;
}
} else {
LE.mostrarError ( "Error, el Nro de la mesa es incorrecto; reintente") ;
}
} else {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
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

public void ingresarDatos ( ) {


int rpta ;
do {
if ( numMesa == clientes.length ) {
aumentarTamaoArreglo ( ) ;
}
clientes[numMesa] = "Vaco" ;
int mesa = 0 ;

Pg. 252

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

Clase PrgRestaurante
..

""

""

""

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 ) {
LE.mostrarError ( "Error, el Nro de mesa ingresado es incorrecto;
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] ;
for ( int i = 0; i < numMesa; i++ ) {
clien[i] = clientes[i] ;
for ( int j = 0; j < 3; j++ ) {
dat[i][j] = datos[i][j] ;
}
}

Pg. 253

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

Clase PrgRestaurante
..

clientes = clien ;
datos = dat ;
} // Fin aumentarTamaoArreglo

public void eliminarDatos ( int pos ) {


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-- ;
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
} // 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 ) ;
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
break ;
case 2 :
modificarDatosIndividuales ( pos ) ;
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
break ;
case 3 :
LE.mostrarAdvertencia ( "Regresando al men principal" ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente" ) ;

Pg. 254

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

Clase PrgRestaurante
..

}
} 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] ) ;
if ( !datos[pos][2].matches ( "[0-9]+" ) ) {
LE.mostrarError ( "Error, el tipo de dato ingresado es incorrecto; reintente" );
}
} while ( !datos[pos][2].matches ( "[0-9]+" ) ) ;
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 {
subOpc = LE.leerInt ( subMenu ) ;
switch ( subOpc ) {
case 1 :
ordenarPorNombre ( ) ;

Pg. 255

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

Clase PrgRestaurante
..

break ;
case 2 :
ordenarPorMesa ( ) ;
break ;
case 3 :
LE.mostrarAdvertencia ( "Regresando al men principal" ) ;
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 ;
}
}
}
}
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
mostrarDatosGenerales ( ) ;
} // 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++ ) {
dato = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dato ;
}
}

Pg. 256

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

Clase PrgRestaurante
..

}
}
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
mostrarDatosGenerales ( ) ;
} // 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" ;

""

for ( int i = 0; i < numMesa; i++ ) {


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" ;
}
listado = listado + "-----------------------------------------------------------------------------------------------------------------\n" ;
LE.mostrarInformacion ( listado ) ;
} // 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 + "\n" ;
listado = listado + completarConBlancosXDer ( clientes[pos], 45 )
+ completarConBlancosXDer ( datos[pos][0], 35 )
+ completarConBlancosXDer ( "S/." + datos[pos][1], 35 )
+ completarConBlancosXDer ( "S/." + datos[pos][2], 35 ) ;
listado = listado + "\n" ;
LE.mostrarInformacion ( listado ) ;
} // 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

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

Clase PrgRestaurante
..

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

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

Clase PrgRestaurante
..

public void menuMesa ( int pos ) {


String subMenu = "********-- Modificar Datos --********\n"
+ "------------------------------------------------------------------\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"
+ "Elija opcin deseada:\n" ;
int subOpc ;
do {
subOpc = LE.leerInt ( subMenu ) ;
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 {
subOpc = LE.leerInt ( subMenu ) ;
switch ( subOpc ) {
case 1 :

Pg. 259

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

Clase PrgRestaurante
..

mesa = LE.leerString ( "Ingrese el Nro de mesa " ) ;


pos = buscarMesa ( 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 :
LE.mostrarAdvertencia ( "Regresando al men principal" ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente" ) ;
}
} while ( subOpc != 5 ) ;
}

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 ;
for ( int i = 0; i < numMesa; i++ ) {
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 ;
for ( int i = 0; i < numMesa; i++ ) {
actual = Double.parseDouble ( datos[i][2] ) ;

Pg. 260

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

Clase PrgRestaurante
..

if ( mayor < actual ) {


mayor = actual ;
pos = i ;
}
}
mostrarDatosIndividuales ( pos ) ;
} // Fin cuentaMayor

public void cuentaMenor ( ) {


double menor = 999999999, actual ;
int pos = -1 ;
for ( int i = 0; i < numMesa; i++ ) {
actual = Double.parseDouble ( datos[i][2] ) ;
if ( menor > actual ) {
menor = actual ;
pos = i ;
}
}
mostrarDatosIndividuales ( pos ) ;
} // Fin cuentaMenor

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 ;
} // Fin completarConBlancosXDer
} // Fin de clase

Pg. 261

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

Problema 030
Etapa 01 - Descripcin del problema.
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.

Etapa 04 Desarrollo de la codificacin.


Clase PrgInventario
..

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgInventario {
int numEqu ;
String nombres[ ] ;
String datos[ ][ ] ;

Pg. 262

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

Clase PrgInventario
..

public static void main ( String[] args ) {


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

public PrgInventario ( ) {
numEqu = 0 ;
nombres = new String[10000] ;
datos = new String[10000][3] ;
} // Fin PrgInventario

public void menu ( ) {


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 ;
boolean acceso = false ;
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) {
mostrarDatosGenerales ( ) ;
} else {
LE.mostrarError ("Error, la opcin ingresada es incorrecta; reintente") ;
}
break ;

Pg. 263

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

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 ) {
mostrarDatosIndividuales ( pos ) ;
} else {
LE.mostrarError ( "Error, el nombre del equipo es incorrecto; reintente" ) ;
}
} else {
LE.mostrarError ("Error, la opcin ingresada es incorrecta; reintente") ;
}
break ;
case 4 : /* Obtener utilidad */
if ( acceso ) {
menuUtilidades ( ) ;
} else {
LE.mostrarError ("Error, la opcin ingresada es incorrecta; reintente") ;
}
break ;
case 5 : /* Ordenar Datos */
if ( acceso ) {
menuOrdenar ( ) ;
} else {
LE.mostrarError ("Error, la opcin ingresada es incorrecta; reintente") ;
}
break ;
case 6 : /* Modificar Datos */
if ( acceso ) {
nom = LE.leerString ( "Ingrese el nombre del equipo que desea modificar: "
""
);
nom = nom.trim ( ) ;
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 {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
break ;

Pg. 264

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

Clase PrgInventario
..

case 7 : /* Eliminar Datos */


if ( acceso ) {
nom = LE.leerString ( "Ingrese el nombre del equipo que desea eliminar " ) ;
nom = nom.trim ( ) ;
pos = buscar ( nom ) ;
if ( pos != -1 ) {
rpta = LE.mostrarPreguntaOpcion2 ( "Desea eliminar los datos de
""
equipos de: " + nombres[pos] ) ;
if ( rpta == 0 ) {
eliminarDatos ( pos ) ;
} else {
LE.mostrarAdvertencia ( "La operacin fue cancelada" ) ;
}
} else {
LE.mostrarError ( "Error, el nombre ingresado del equipo es incorrecto;
qqqqqqqqqq
qreintente" ) ;
}
} else {
LE.mostrarError ("Error, La opcin ingresada es incorrecta; reintente");
}
if ( numEqu == 0 ) {
acceso = false ;
menu = menu1 ;
}
break ;
case 0 : /* Finalizar operacin */
LE.mostrarAdvertencia ( "La operacin ha finalizado" ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente" ) ;
}
} 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++ ) {
dat[i][j] = datos[i][j] ;
}
}
nombres = nom ;
datos = dat ;
}

public int buscar ( String nom ) {


int pos = -1 ;
for ( int i = 0; i < numEqu; i++ ) {
if ( nom.equalsIgnoreCase ( nombres[i] ) ) {
pos = i ;

Pg. 265

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

Clase PrgInventario
..

break ;
}
}
return pos ;
} // Fin buscar

public void mostrarDatosGenerales ( ) {


String lista = " " ;
lista = "Nombre de Equipo
|| Cantidad || Precio de Compra || Precio de
qqqqqqqqqVenta\n" + "-------------------------------------------------------------------------------------""
----------------------\n" ;
lista = lista + "\n" ;
for ( int i = 0; i < numEqu; i++ ) {
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" ;
}
lista = lista + "-------------------------------------------------------------------------------------------""
-----------------\n" ;
LE.mostrarInformacion ( lista ) ;
} // Fin mostrarDatosGenerales

public void mostrarDatosIndividuales ( int pos ) {


String lista = "" ;
lista = "Nombre de Equipo
|| Cantidad || Precio de Compra || Precio de
qqqqqqqqqVenta\n" + "---------------------------------------------------------------------------------\n" ;
lista = lista + "\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" ;
lista = lista + "---------------------------------------------------------------------------------------\n" ;
LE.mostrarInformacion ( lista ) ;
} // Fin mostrarDatosIndividuales

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 ) {
nombre = nombres[i] ;
nombres[i] = nombres[j] ;
nombres[j] = nombre ;
for ( int k = 0; k < 3; k++ ) {

Pg. 266

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

Clase PrgInventario
..

dato = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dato ;
}
}
}
}
LE.mostrarAdvertencia ( "La operacin fue realizada con xito" ) ;
} // Fin ordenarPorNombre

public void ordenarPorCantidad ( ) {


String nombre ;
String dato ;
int cant1, cant2 ;
for ( int i = 0; i < numEqu - 1; i++ ) {
cant1 = Integer.parseInt ( datos[i][0] ) ;
for ( int j = i + 1; j < numEqu; j++ ) {
cant2 = Integer.parseInt ( datos[j][0] ) ;
if ( cant1 > cant2 ) {
nombre = nombres[i] ;
nombres[i] = nombres[j] ;
nombres[j] = nombre ;
for ( int k = 0; k < 3; k++ ) {
dato = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dato ;
}
}
}
}
LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;
} // Fin ordenarPorCantidad

public void ordenarPorPrecioCompra ( ) {


String nombre ;
String dato ;
int precioCom1, precioCom2 ;
for ( int i = 0; i < numEqu - 1; i++ ) {
precioCom1 = Integer.parseInt ( datos[i][1] ) ;
for ( int j = i + 1; j < numEqu; j++ ) {
precioCom2 = Integer.parseInt ( datos[j][1] ) ;
if ( precioCom1 > precioCom2 ) {
nombre = nombres[i] ;
nombres[i] = nombres[j] ;
nombres[j] = nombre ;
for ( int k = 0; k < 3; k++ ) {
dato = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dato ;
}
}
}
}

Pg. 267

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

Clase PrgInventario
..

LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;


} // Fin ordenarPorPrecioCompra

public void ordenarPorPrecioVenta ( ) {


String nombre ;
String dato ;
int precioVen1, precioVen2 ;
for ( int i = 0; i < numEqu - 1; i++ ) {
precioVen1 = Integer.parseInt ( datos[i][2] ) ;
for ( int j = i + 1; j < numEqu; j++ ) {
precioVen2 = Integer.parseInt ( datos[j][2] ) ;
if ( precioVen1 > precioVen2 ) {
nombre = nombres[i] ;
nombres[i] = nombres[j] ;
nombres[j] = nombre ;
for ( int k = 0; k < 3; k++ ) {
dato = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dato ;
}
}
}
}
LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;
} // Fin ordenarPorPrecioVenta

public void eliminarDatos ( int pos ) {


for ( int i = pos; i < numEqu; i++ ) {
nombres[i] = nombres[i + 1] ;
for ( int j = 0; j < 3; j++ ) {
datos[i][j] = datos[i + 1][j] ;
}
}
numEqu-- ;
LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;
} // Fin eliminarDatos

public void menuOrdenar ( ) {


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"
+ "[5] Regresar al men principal\n"
+ "----------------------------------------\n"
+ "Elija opcin deseada:\n" ;
int subOpc ;
do {
subOpc = LE.leerInt ( subMenu ) ;
switch ( subOpc ) {
case 1 :

Pg. 268

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

Clase PrgInventario
..

ordenarPorNombre ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 2 :
ordenarPorCantidad ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 3 :
ordenarPorPrecioCompra ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 4 :
ordenarPorPrecioVenta ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 5 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta, reintente" ) ;
}
} while ( subOpc != 5 ) ;
} // 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"
+ "Elija opcin deseada:\n" ;
String nombre ;
int subOpc, pos ;
do {
subOpc = LE.leerInt ( subMenu ) ;
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

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

Clase PrgInventario
..

case 2 :
utilidadTotal ( ) ;
break ;
case 3 :
utilidadAlta ( ) ;
break ;
case 4 :
utilidadBaja ( ) ;
break ;
case 5 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente" ) ;
}
} while ( subOpc != 5 ) ;
} // Fin menuUtilidades

public void menuModificar ( int pos ) {


String subMenu = "********-- Modificar Datos --********\n"
+ "-----------------------------------------------------------\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 {
subOpc = LE.leerInt ( subMenu ) ;
switch ( subOpc ) {
case 1 :
modificarDatosGenerales ( pos ) ;
break ;

Pg. 270

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

Clase PrgInventario
..

case 2 :
modificarDatosComplementarios ( pos ) ;
break ;
case 3 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
break ;
default :
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente" ) ;
}
} while ( subOpc != 3 && subOpc != 2 && subOpc != 1 ) ;
} // Fin menuMmodificar

public void modificarDatosGenerales ( int pos ) {


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] ) ;
modificarDatosComplementarios ( pos ) ;
} // Fin modificarDatosGenerales

public void modificarDatosComplementarios ( int pos ) {


do {
datos[pos][0] = LE.leerString ( "Ingrese la nueva cantidad de equipos de: " +
qqqqqnombres[pos] ) ;
if ( !datos[pos][0].matches ( "[0-9]+" ) ) {
LE.mostrarError ( "Error, La cantidad ingresada es incorrecta; reintente " ) ;
}
} while ( !datos[pos][0].matches ( "[0-9]+" ) ) ;
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

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

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 ) ;
LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;
} // Fin modificarDatosComplementarios

public void ingresarDatos ( ) {


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] ) ;
if ( !datos[numEqu][1].matches ( "[0-9]+" ) ) {
LE.mostrarError ( " Error, el tipo de dato ingresado es incorrecto;

Pg. 272

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

Clase PrgInventario
..

""

""

""

""

""

reintente " ) ;
}
} while ( !datos[numEqu][1].matches ( "[0-9]+" ) ) ;
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]);
if ( !datos[numEqu][2].matches ( "[0-9]+" ) ) {
LE.mostrarError ( " Error, el tipo de dato ingresado es incorrecto;
reintente " ) ;
}
} while ( !datos[numEqu][2].matches ( "[0-9]+" ) ) ;
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 ;
for ( int i = 0; i < numEqu; i++ ) {
cantidad = Double.parseDouble ( datos[i][0] ) ;
precioCompra = Double.parseDouble ( datos[i][1] ) ;
precioVenta = Double.parseDouble ( datos[i][2] ) ;
precioCompraTotal = precioCompraTotal + ( cantidad * precioCompra ) ;

Pg. 273

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

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 ;
for ( int i = 0; i < numEqu; i++ ) {
precioCompra = Double.parseDouble ( datos[i][1] ) ;
precioVenta = Double.parseDouble ( datos[i][2] ) ;
utilidad[i] = precioVenta - precioCompra ;
}
int pos = -1 ;
for ( int j = 0; j < numEqu; j++ ) {
if ( mayor < utilidad[j] ) {
mayor = utilidad[j] ;
pos = j ;
}
}
mostrarDatosIndividuales ( pos ) ;
} // Fin utilidadAlta

public void utilidadBaja ( ) {


double utilidad[] = new double[numEqu] ;
double menor = 999999999, precioCompra = 0, precioVenta = 0 ;
for ( int i = 0; i < numEqu; i++ ) {
precioCompra = Double.parseDouble ( datos[i][1] ) ;
precioVenta = Double.parseDouble ( datos[i][2] ) ;
utilidad[i] = precioVenta - precioCompra ;
}
int pos = -1 ;
for ( int j = 0; j < numEqu; j++ ) {
if ( menor > utilidad[j] ) {
menor = utilidad[j] ;
pos = j ;
}
}
mostrarDatosIndividuales ( pos ) ;
} // Fin utilidadBaja

public String context ( String nom ) {


String letra, resto ;
letra = nom.substring ( 0, 1 ) ;
letra = letra.toUpperCase ( ) ;
resto = nom.substring(1) ;
resto = resto.toLowerCase ( ) ;
nom = letra + resto ;
return nom ;
} // Fin context

Pg. 274

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

Clase PrgInventario
..

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 ;
} // Fin completarConBlancosXDer
} // Fin de clase

Pg. 275

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

Problema 031
Etapa 01 - Descripcin del problema.
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.

Etapa 04 Desarrollo de la codificacin.


Clase PrgEmpresa
..

package dominioDeLaAplicacion ;
import javax.swing.* ;
import biblioteca.* ;
public class PrgEmpresa

int numEmp ;
String datos[ ][ ] ;
long dni[ ] ;
double sueldos[ ] ;

public static void main ( String[ ] args ) {


PrgEmpresa obj = new PrgEmpresa ( ) ;
obj.menu ( ) ;

Pg. 276

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

Clase PrgEmpresa
..

public PrgEmpresa ( ) {
numEmp = 0 ;
dni = new long[10000] ;
sueldos = new double[10000] ;
datos = new String[10000][3] ;
}

public void menu ( ) {


String menu = "************--: EMPRESA S.A :--************\n"
+ "-----------------------------------------------------------\n"
+ "[1] Ingreso de usuario \n"
+ "[2] Ingreso de administrador \n"
+ "[3] Finalizar \n"
+ "-----------------------------------------------------------\n"
+ "Elija opcin deseada: \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:
LE.mostrarError ( " Error, la opcin ingresada es incorrecta; reintente " ) ;
}
} 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"
+ "Elija opcin deseada: \n" ;

Pg. 277

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

Clase PrgEmpresa
..

String menu2 = "************--: MENU PRINCIPAL :--************\n"


+ "--------------------------------------------------------------\n"
+ "Bienvenido usuario \n"
+ " [1] Ingresar datos \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"
+ "Elija opcin deseada: \n" ;
int opc ;
boolean acceso = false ;
String menu ;
if (numEmp > 0) {
menu = menu2 ;
acceso = true ;
} else {
menu = menu1;
acceso = false ;
}
do {
opc = LE.leerInt ( menu ) ;
switch ( opc ) {
case 1 : /* Ingresar datos */
ingresoDeDatos ( ) ;
acceso = true ;
menu = menu2 ;
break ;
case 2 : /* Mostrar datos generales */
if ( acceso ) {
mostrarDatosGenerales ( ) ;
} 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 {
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente " ) ;
}

Pg. 278

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

Clase PrgEmpresa
..

break ;
case 4 : /* Clculos generales */
if (acceso) {
menuCalculosGenerales ( ) ;
} else {
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente " ) ;
}
break ;
case 5 : /* Ordenar Datos */
if ( acceso ) {
menuOrdenar ( ) ;
} else {
LE.mostrarError ( "Error, la opcin ingresada es incorrecta; reintente " ) ;
}
break ;
case 0 : /* Finalizar operacin */
LE.mostrarAdvertencia ( " La operacin ha finalizado " ) ;
break ;
default :
LE.mostrarError ( " Error, la opcin ingresada es incorrecta; reintente " ) ;
}
} 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"
+ " [1] Ingresar datos \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"
+ "Elija opcin deseada: \n" ;
int opc ;
do {
opc = LE.leerInt ( menuadmin ) ;
switch ( opc ) {

Pg. 279

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

Clase PrgEmpresa
..

case 1 : /* Ingreso de datos */


ingresoDeDatos ( ) ;
break ;
case 2 : /* Mostrar datos generales */
mostrarDatosGenerales ( ) ;
break ;

""

""

case 3 : /* Buscar Datos */


String nom1 = LE.leerString ( "Ingrese el nombre del empleado que
desea buscar: " ) ;
nom1 = nom1.trim ( ) ;
int pos1 = buscar ( nom1 ) ;
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:
");
nom2 = nom2.trim ( ) ;
int pos2 = buscar ( nom2 ) ;
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 {
LE.mostrarError ( "Error, el nombre del empleado es incorrecto;
reintente " ) ;
}
break ;
case 6 : /* Eliminar datos */
String nom3 = LE.leerString ( " Ingrese el nombre del empleado que
desea eliminar " ) ;
nom3 = nom3.trim ( ) ;
int pos3 = buscar ( nom3 ) ;
if ( pos3 != -1 ) {
int rpta3 = LE.mostrarPreguntaOpcion2 ( "Desea eliminar los datos del
empleado: " +
datos[pos3][0] ) ;

Pg. 280

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

Clase PrgEmpresa
..

""

""

if ( rpta3 == 0 ) {
eliminarDatos ( pos3 ) ;
} else {
LE.mostrarAdvertencia ( " La operacin fue cancelada " ) ;
}
} else {
LE.mostrarError ( "Error, el nombre del empleado es incorrecto;
reintente " ) ;
}
if ( numEmp == 0 ) {
opc = 0 ;
}
break ;
case 0 : /* Regresar men principal */
LE.mostrarAdvertencia ( " Regresando al 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]+ " ) ) {
LE.mostrarError ( " Error, el tipo de dato ingresado es incorrecto;
""
reintente " ) ;
}
} while ( !datos[numEmp][0].matches ( "[A-Z]+" ) ) ;
if ( buscar (datos[numEmp][0]) != -1 || (datos[numEmp][0].length ( ) < 3 ) ){

Pg. 281

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

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] ) ;
datos[numEmp][1] = datos[numEmp][1].trim ( ) ;
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]) ;
datos[numEmp][2] = datos[numEmp][2].trim ( ) ;
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

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

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 ;
for ( int i = 0; i < numEmp; i++ ) {
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 i = 0; i < numEmp; i++ ) {
for ( int j = 0; j < 3; j++ ) {
dat[i][j] = datos[i][j] ;
}
dnitemp[i] = dni[i] ;
suel[i] = sueldos[i] ;
}
datos = dat ;
dni = dnitemp ;
sueldos = suel ;
}

public void menuOrdenar ( ) {


String submenu = "********--Ordenar Datos--********\n"
+ "----------------------------------------------------------\n"
+ "[1] Ordenar por nombres \n"
+ "[2] Ordenar por distrito \n"
+ "[3] Ordenar por escala de sueldos\n"
+ "[4] Regresar al men principal\n"

Pg. 283

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

Clase PrgEmpresa
..

+ "----------------------------------------------------------\n"
+ "Elija opcin deseada:\n" ;
int subopc ;
do {
subopc = LE.leerInt (submenu) ;
switch (subopc) {
case 1 :
ordenarporNombre ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 2 :
ordenarporDistrito ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 3 :
ordenarporSueldos ( ) ;
mostrarDatosGenerales ( ) ;
break ;
case 4 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
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[i][k] = datos[j][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

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

Clase PrgEmpresa
..

} // Fin ordenarporNombre

public void ordenarporDistrito ( ) {


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][2].compareToIgnoreCase( datos[j][2] ) > 0 ) {
for ( int k = 0; k < 3; k++ ) {
dat = datos[i][k] ;
datos[i][k] = datos[j][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 " ) ;
}

// Fin ordenarporDistrito

public void ordenarporSueldos ( ) {


long dnitemp ;
double suel ;
String dat ;
for ( int i = 0; i < numEmp - 1; i++ ) {
for ( int j = i + 1; j < numEmp; j++ ) {
if ( sueldos[i] > sueldos[j] ) {
dnitemp = dni[i] ;
dni[i] = dni[j] ;
dni[j] = dnitemp ;
suel = sueldos[i] ;
sueldos[i] = sueldos[j] ;
sueldos[j] = suel ;
for ( int k = 0; k < 3; k++ ) {
dat = datos[i][k] ;
datos[i][k] = datos[j][k] ;
datos[j][k] = dat ;
}
}
}
}
LE.mostrarAdvertencia ( " Los datos fueron ordenados con xito " ) ;

Pg. 285

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

Clase PrgEmpresa
..

} // Fin ordenarporSueldos

public void eliminarDatos ( int pos ) {


for ( int i = pos; i < numEmp; i++ ) {
for ( int j = 0; j < 3; j++ ) {
datos[i][j] = datos[i + 1][j] ;
}
dni[i] = dni[i + 1] ;
sueldos[i] = sueldos[i + 1] ;
}
numEmp-- ;
LE.mostrarAdvertencia ( " La operacin fue realizada con xito " ) ;
} // Fin eliminarDatos

public void menuModificar ( int pos ) {


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"
+ "[3] Regresar al men principal\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

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

Clase PrgEmpresa
..

modificarDatosComplementarios(pos) ;
break ;
case 3 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
break ;
default :
LE.mostrarError ( " Error, la opcin ingresada es incorrecta; reintente " ) ;
}
} 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]) ;
datos[pos][2] = datos[pos][2].trim ( ) ;
if ( datos[pos][2].length ( ) < 3 ) {
LE.mostrarError ( " Error, el distrito ingresado es incorrecto; reintente " ) ;
}
} while ( datos[pos][2].length ( ) < 3 ) ;
datos[pos][2] = contexto( datos[pos][2] ) ;
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

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

Clase PrgEmpresa
..

LE.mostrarAdvertencia ( " Los datos fueron modificados con xito " ) ;


} // Fin modificarDatosComplementarios

public void modificarDatosGenerales ( int pos ) {


do {
do {
datos[pos][0] = LE.leerString ( " Ingrese el nuevo nombre del empleado " ) ;
datos[pos][0] = datos[pos][0].trim ( ) ;
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]+" ) ) ;
if ( datos[pos][0].length ( ) < 3 ) {
LE.mostrarError ( " Error, el nombre ingresado es incorrecto; reintente " ) ;
}
} while ( datos[pos][0].length ( ) < 3 ) ;
datos[pos][0] = contexto( datos[pos][0] ) ;
modificarDatosComplementarios ( pos ) ;
} // Fin modificarDatosGenerales

public void mostrarDatosGenerales ( ) {


JTextArea muestraInformacion = new JTextArea (20, 48) ;
JScrollPane desplazaInformacion = new JScrollPane(muestraInformacion) ;

""
""

""

""
""

String listado ;
listado = "Nombres
||
Direccin
||
Distrito
||
DNI
||
Sueldo\n + ----------------------------------------------------------------------------------------------------------------------\n" ;
listado = listado + "\n" ;
for ( int i = 0; i < numEmp; i++ ) {
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" ;
}
listado = listado + "\n" + "----------------------------------------------------------------------------------------------------------------------\n" + "\n" + " || El total de empleados
registrados son " + (numEmp) ;

muestraInformacion.append( listado ) ;
JOptionPane.showMessageDialog (null, desplazaInformacion, "LISTA DE
""
EMPLEADOS",
""
JOptionPane.INFORMATION_MESSAGE ) ;
} // Fin mostrarDatosGenerales

Pg. 288

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

Clase PrgEmpresa
..

public void mostrarDatosIndividuales ( int pos ) {


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) ;
} // Fin mostrarDatosIndividuales

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"
+ "[4] Regresar al men principal\n"
+ "-------------------------------------------------------------\n"
+ "Elija opcin deseada:\n" ;
int subopc ;
do {
subopc = LE.leerInt ( submenu ) ;
switch (subopc) {
case 1 :
sueldoMayor ( ) ;
break ;
case 2 :
sueldoMenor ( ) ;
break ;
case 3 :
totalSueldos ( ) ;
break ;

Pg. 289

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

Clase PrgEmpresa
..

case 4 :
LE.mostrarAdvertencia ( " Regresando al men principal " ) ;
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 ;
for ( int i = 0; i < numEmp; i++ ) {
if ( mayor < sueldos[i] ) {
mayor = sueldos[i] ;
pos = i ;
}
}
mostrarDatosIndividuales(pos) ;
} // Fin sueldoMayor

public void sueldoMenor ( ) {


double menor = 999999999 ;
int pos = -1 ;
for ( int i = 0; i < numEmp; i++ ) {
if ( menor > sueldos[i] ) {
menor = sueldos[i] ;
pos = i ;
}
}
mostrarDatosIndividuales( pos ) ;
} // Fin sueldoMenor
public void totalSueldos ( ) {
double total = 0 ;
for ( int i = 0; i < numEmp; i++ ) {
total = total + sueldos[i] ;
}
LE.mostrarInformacion ( " El total a pagar a los empleados es: S/. " + total ) ;
} // Fin totalSueldos

public String contexto ( String nom ) {


String letra, resto ;
letra = nom.substring(0, 1) ;
letra = letra.toUpperCase ( ) ;
resto = nom.substring(1) ;
resto = resto.toLowerCase ( ) ;
nom = letra + resto ;
return nom ;
} // Fin contexto

Pg. 290

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

Clase PrgEmpresa
..

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 ;
} // Fin completarConBlancosXDer
} // Fin de clase

Pg. 291

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

Problema 032

Etapa 01 - Descripcin del problema.


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

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

Etapa 04 Desarrollo de la codificacin.

Clase PrgPostulantes
package dominioDeLaAplicacion;
import biblioteca.LE;
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;
}

public static void main(String[] args) {


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

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

Clase PrgPostulantes
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

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

Clase PrgPostulantes
""
""
""

""

""
""

""

""

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

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

Clase PrgPostulantes
}else{
LE.mostrarInformacion ("Lo sentimos, el cdigo ingresado no existe!");
}
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

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

Clase PrgPostulantes
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[i] = codigo[j];
codigo[j] = aux;

Pg. 297

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

Clase PrgPostulantes
String aux2 = datos[i][0];
datos[i][0] = datos[j][0];
datos[j][0] = aux2;
String aux3 = datos[i][1];
datos[i][1] = datos[j][1];
datos[j][1] = aux3;
String aux4 = datos[i][2];
datos[i][2] = datos[j][2];
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){
String aux2 = datos[i][0];
datos[i][0] = datos[j][0];
datos[j][0] = aux2;
String aux3 = datos[i][1];
datos[i][1] = datos[j][1];
datos[j][1] = aux3;
String aux4 = datos[i][2];
datos[i][2] = datos[j][2];
datos[j][2] = aux4;
int aux = codigo[i];
codigo[i] = codigo[j];
codigo[j] = aux;
int aux5 = puntaje[i];
puntaje[i]=puntaje[j];
puntaje[j]=aux5;

Pg. 298

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

Clase PrgPostulantes
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 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";
for(int i=0;i<conta;i++){
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";
menu += "Seleccione la opcin deseada:";
do{
opc = Character.toUpperCase(LE.leerChar(menu));
switch(opc){
case '1':OrdenarCodigos ( );break;
case '2': OrdenarNombres ( );break;
}
}while(opc!='R' && fin!='F');
}
public void Eliminar ( ){
char opc;
char fin = ' ';
String menu = "Menu Eliminar\n";

Pg. 299

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

Clase PrgPostulantes
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";
menu += "Seleccione la opcin deseada:";
do{
opc = Character.toUpperCase(LE.leerChar(menu));
switch(opc){
case '1':EliminarCodigo ( );
break;
case '2':EliminarNombre ( );
break;
case '3':ElminarNoingresantes ( );
break;
}
}while(opc!='R' && fin!='F');
}

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{
LE.mostrarInformacion ("Lo sentimos, el cdigo ingresado no existe!");
}
}

public void EliminarCodigo ( ){


int cod;
do{
cod = LE.leerInt ("Ingrese el cdigo del postulante que desea eliminar :");
if((cod<1000 || cod>9999)){

Pg. 300

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

Clase PrgPostulantes
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];
datos[i][1] = datos[i+1][1];
datos[i][2] = datos[i+1][2];
situacion[i]=situacion[i+1];
puntaje[i]=puntaje[i+1];
}
conta--;
}
public void ElminarNoingresantes ( ){
for(int i=0;i<conta;i++){
if(situacion[i].equalsIgnoreCase("No ingreso")){
eliminarGen(i);
}
}
mostrarListado ( );
}

public void mostrarListado ( ){


String lis = "Listado de alumnos\n"+
"--------------------------\n"+
"Cdigo:\t\t Nombres y Apellidos:\t\t Sexo:\t\t Edad:\t\t Puntaje\t\t
""
Situacion: \n";
for (int i =0;i<conta;i++){
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";
}
LE.mostrarResultado(lis);
}

Pg. 301

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

Clase PrgPostulantes
public void MayorMenor ( ){
int may=0,men=1000;
String resultados="";
for(int i=0;i<conta;i++){
may=Math.max(may,puntaje[i]);
men=Math.min(men,puntaje[i]);
}
String lis = "El puntaje ms alto es:\n"+
"--------------------------\n"+
"Cdigo:\t\t Nombres y Apellidos:\t\t Sexo:\t\t Edad:\t\t Puntaje\t\t
""
Situacion: \n";
String lis2 = "El puntaje ms bajo es:\n"+
"--------------------------\n"+
"Cdigo:\t\t Nombres y Apellidos:\t\t Sexo:\t\t Edad:\t\t Puntaje\t\t
""
Situacion: \n";
for(int i=0;i<conta;i++){
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

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

Problema 033

Etapa 01 - Descripcin del problema.


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

Utilice la Grfica de Estructuras de Datos mostrada.


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)

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

Etapa 04 Desarrollo de la codificacin.


Clase PrgNorteito
package dominioDeLaAplicacion;
import biblioteca.LE;
public class PrgNorteito {
String datos[][];
int ruta[];
int numPas;
int contaMen;
public static void main(String[] args) {
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
public void menu ( ) {
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

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

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 {
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada.");
}
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 {
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada.");
}
break;
case 6:
if (sw) {
calcularPasajeroPorRuta ( );
} else {
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada.");
}
break;
case 7:
if (sw) {
calcularGananciaPorRuta ( );
} else {
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada.");
}
break;

Pg. 305

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

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

public void ingresar ( ) {


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

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

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?");
} while (rpta == 0);
}// 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
public void modificar ( ) {

""

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

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

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
datos del pasajero :" + datos[pos][1]
+ "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 {
opc = LE.leerInt (menu);
switch (opc) {
case 1:
do {
datos[pos][0] = LE.leerString ("Ingrese el nuevo nmero de DNI");
if (!datos[pos][0].matches("[0-9]{8}")) {
LE.mostrarError ("Lo sentimos, el nmero de DNI debe contener 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

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

Clase PrgNorteito

""

if (datos[pos][1].length ( ) < 2) {
LE.mostrarError ("Lo sentimos, el nombre tiene que contener ms de 2
caracteres");
}
} while (datos[pos][1].length ( ) < 2);
LE.mostrarAdvertencia ("La operacin fu realizada con xito");
break;
case 3:
do {
ruta[pos] = LE.leerInt ("BARRANQUITA 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[pos] || ruta[pos] > 6) {
LE.mostrarError ("Lo sentimos, la ruta que eligi no existe");
}
} while (1 > ruta[pos] || ruta[pos] > 6); // Fin de Ingreso de
// Ruta
LE.mostrarAdvertencia ("La operacin fu realizada con xito");
break;
case 4:
LE.mostrarAdvertencia ("Regresando al men anterior");
break;
default:
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada");
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 {
opc = LE.leerInt (menu);
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) {
LE.mostrarError ("Lo sentimos, el nombre tiene que contener ms de 2
caracteres");

Pg. 309

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

Clase PrgNorteito
}
} while (datos[pos][1].length ( ) < 2);
LE.mostrarAdvertencia ("La operacin fu realizada con xito");
break;
case 2:
do {
ruta[pos] = 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"
+ "----------------------------"
+ "Seleccione su Ruta");
if (1 > ruta[pos] || ruta[pos] > 6) {
LE.mostrarError ("Lo sentimos, la ruta que eligi no existe");
}
} while (1 > ruta[pos] || ruta[pos] > 6);
LE.mostrarAdvertencia ("La operacin fu realizada con xito");
break;
case 3:
LE.mostrarAdvertencia ("Regresando al men anterior");
break;
default:
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada");
break;
}
} while (opc != 3);
}// Fin mtodo menuModificar2
public void mostrar ( ) {
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

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

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;
for (int i = 0; i < numPas; i++) {
if (cod.equalsIgnoreCase(datos[i][0])) {
estado = i;
break;
}
}
return estado;
}// Fin mtodo buscar
public int buscarNombre(String nombre) {
int estado = -1;
for (int i = 0; i < numPas; i++) {
if ((nombre.trim ( )).equalsIgnoreCase(datos[i][1])) {
estado = i;
break;
}
}
return estado;
}// Fin mtodo buscar
public void eliminar ( ) {

""

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

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

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];
datos[i][1] = datos[i + 1][1];
ruta[i] = ruta[i + 1];
}
numPas--;
LE.mostrarInformacion ("Los datos fueron eliminados de forma exitosa");
} else {
LE.mostrarAdvertencia ("Usted ha cancelado la operacin");
}
} else {
LE.mostrarAdvertencia ("Lo sentimos, el pasajero que usted ha ingresado no
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
datos del pasajero :" + datos[pos][1]
+ "Cuyo cdigo asignado es: " +
datos[pos][0]);
if (rpta == 0) {
for (int i = 0; i < numPas - 1; i++) {
datos[i][0] = datos[i + 1][0];
datos[i][1] = 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 modificacin");
}
} else {
LE.mostrarAdvertencia ("Lo sentimos, el pasajero que usted ha ingresado no
existe");
}
}
}// Fin mtodo eliminar
public void calcularGananciaPorRuta ( ) {
double rut, r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0;
for (int i = 0; i < numPas; i++) {

Pg. 312

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

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;
for (int i = 0; i < numPas; i++) {
switch (ruta[i]) {
case 1:
r1++;
break;
case 2:
r2++;
break;
case 3:
r3++;
break;

Pg. 313

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

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
public void 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"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n" + "Seleccione su opcin";
int opc;
do {
opc = LE.leerInt (menu);
switch (opc) {
case 1:
OrdenarPorSeleccion ( );
mostrar ( );
break;
case 2:
OrdenarEnBurbuja ( );
mostrar ( );
break;
case 3:
OrdenarEnQuickSort(0, numPas - 1);
mostrar ( );
break;
case 4:
LE.mostrarAdvertencia ("Regresando al men anterior");
break;

Pg. 314

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

Clase PrgNorteito
default:
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada");
break;
}
} while (opc != 4);
}// Fin mtodo ordenar
public void OrdenarEnBurbuja ( ) {
int tempRuta;
String tempDatos;
for (int i = 0; i < numPas - 1; i++) {
for (int j = i + 1; j < numPas; j++) {
if (datos[i][1].compareToIgnoreCase(datos[j][1]) > 0) {
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;
int i = primero, j = ultimo;
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++) {
tempDatos = datos[i][k];
datos[i][k] = datos[j][k];
datos[j][k] = tempDatos;

Pg. 315

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

Clase PrgNorteito
}
i++;
j--;
}
} while (i <= j);
if (primero < j) {
OrdenarEnQuickSort(primero, j);
}
if (ultimo > i) {
OrdenarEnQuickSort(i, ultimo);
}
}// 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;
}
}
public void finalizar ( ) {
LE.mostrarAdvertencia ("Usted ha finalizado el programa");
}
}// Fin PrgNorteito

Comentarios con relacin a la solucin planteada


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

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

que escoje un pasajero, como se puede observar a continuacin:

Mtodo ordenar
..

public void 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"
+ "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*\n" + "Seleccione su opcin";
int opc;
do {
opc = LE.leerInt (menu);
switch (opc) {
case 1:
OrdenarPorSeleccion ( );
mostrar ( );
break;
case 2:
OrdenarEnBurbuja ( );
mostrar ( );
break;
case 3:
OrdenarEnQuickSort(0, numPas - 1);
mostrar ( );
break;
case 4:
LE.mostrarAdvertencia ("Regresando al men anterior");
break;
default:
LE.mostrarError ("Lo sentimos, su solicitud no puede ser procesada");
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

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

Mtodo OrdenarEnQuickSort
..

public void OrdenarEnQuickSort(int primero, int ultimo) {


int pivote, tempRuta;
int i = primero, j = ultimo;
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++) {
tempDatos = datos[i][k];
datos[i][k] = datos[j][k];
datos[j][k] = tempDatos;
}
i++;
j--;

Llamada recursiva al
mtodo
OrdenarEnQuickSort ( );

}
} while (i <= j);
if (primero < j) {
OrdenarEnQuickSort(primero, j);
}
if (ultimo > i) {
OrdenarEnQuickSort(i, ultimo);
}
}// 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

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

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}")) {
LE.mostrarError ("Lo sentimos, el nmero de DNI debe contener 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

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

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
Donde numAlu permite almacenar el nmero de alumnos.

Pg. 320

(int)

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

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.


PV = Precio de venta.
PC = Precio de compra.

Pg. 321

(int)

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

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

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

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

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

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

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

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.
PC = Precio de compra.
PV = Precio de venta.

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

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

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.

2. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar el prstamo y devolucin de libros en una biblioteca.

3. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar el tiempo de uso de las computadoras en una cabina de
internet.

4. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar la asistencia de todos los empleados en una empresa.

5. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar la agenda de una persona.

6. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar todas las computadoras instaladas en una universidad.

7. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar el abastecimiento de productos en una bodega.

8. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar la disponibilidad de habitaciones en un hotel.

9. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que


permita manejar y controlar el consumo de las mesas de un restaurante.

10. Desarrollar una aplicacin utilizando mtodos, arreglos y un men de opciones que
permita manejar y controlar la venta de productos en una farmacia.

Pg. 326

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

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

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

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)

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

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)

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

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

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

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

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

[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

También podría gustarte