Computing">
Separata Unidad 2 Aed Arreglos Unidimensionales I Arreglos Unidimensional II Arreglos Unidimensional
Separata Unidad 2 Aed Arreglos Unidimensionales I Arreglos Unidimensional II Arreglos Unidimensional
Separata Unidad 2 Aed Arreglos Unidimensionales I Arreglos Unidimensional II Arreglos Unidimensional
Semestre: 2015-II
INDICE
SEGUNDA UNIDAD TEMATICA
OPERACIONES CON ARREGLOS UNIDIMENSIONALES
QUINTA SEMANA
MARCO TEORICO
OPERACIONES CON ARREGLOS UNIDIMENSIONALES I
Sumar, promediar, hallar máximo, y mínimo de los valores cargados en el
arreglo………. ………………………………………………………………………….. 2
MARCO PRÁCTICO
Actividades…………………………………………………….…………………………
SEXTA SEMANA
MARCO TEORICO
OPERACIONES CON ARREGLOS UNIDIMENSIONALES II
Insertar los datos en un arreglo unidimensional…………..….………………….… 12
Modificar los datos en un arreglo unidimensional………..….………………….… 12
Eliminar los datos en un arreglo unidimensional………..….………………….… 13
Buscar datos en un arreglo unidimensional………..………………………….… 14
MARCO PRÁCTICO
Actividades……………………………………………………………………………… 16
SÉPTIMA SEMANA
MARCO TEORICO
OPERACIONES CON ARREGLOS UNIDIMENSIONAL III
Mostrar los elementos comunes entre dos arreglos unidimensionales………… 18
Unir los datos de dos arreglos en un tercer arreglo……….…….………………… 19
MARCO PRÁCTICO
Actividades…………………………..………………………………………………… 20
CUARTA SEMANA
MARCO TEORICO
Métodos de la Burbuja…….………………….……………………………….……… 21
Método del ordenamiento por inserción………………………….………….……… 24
Método del ordenamiento por inserción………………………….………….……… 24
MARCO PRÁCTICO
Actividades………………………………………………………………………… 28
Logro
El alumno aprenderá a operacionalizar los datos contenidos en el arreglo.
Resumen
Las operaciones básicas con los datos numéricos de un arreglo
unidimensional es: Sumar, Promediar, hallar máximo, hallar mínimo.
Caso Práctico: Realizar una aplicación Java que utilice POO, Estructura de
Datos Estáticas (Arreglos) que realice las siguientes operaciones básicas con los
arreglos, tales como: Sumar, Promediar, hallar máximo, hallar mínimo.
Logica de Negocios
Para desarrollar este caso utilizaremos la clase Arreglos, dentro de la cual
implementaremos los métodos que se detallan en esta unidad. Hasta el momento
nuestra clase Arreglos contiene lo siguiente:
package Semana6;
Lógica de Presentación
Para desarrollar este caso utilizaremos el formulario frmArreglos, cuyo diseño se
presenta en el siguiente gráfico.
Para esta unidad hemos mejorado algunas cosas con relación a la semana
anterior.
Carga de datos
Ahora la carga de datos se realiza automáticamente, Ud. ingresará el dato en la
caja y luego al hacer un ENTER el dato quedará registrado y se mostrará en la
caja txtlista, para este fin se programado el siguiente código en el evento
actionperformaced de la caja txtdato.
Método mostrardatos()
Este método se encuentra dentro del formulario y sirve para visualizar los datos
del arreglo, en la caja txtlista.
//recorre el arreglo
for(i=0;i<=n-1;i++){
acu=acu+ventas[i]; //Acumulador
}
return acu;
}
txttotal.setText(String.valueOf(obj.sumar(n)));
txtpro.setText(String.valueOf(obj.promedio(n)));
txtmax.setText(String.valueOf(obj.maximo(n)));
txtmin.setText(String.valueOf(obj.minimo(n)));
TRABAJO PRÁCTICO 1
Logro
El alumno aprenderá a realizar las operaciones de edición con los
datos de un arreglo unidimensional.
Resumen
Las operaciones de edición son: Insertar, Modificar, Eliminar, Buscar,
etc.
Lógica de Presentación
Para desarrollar este caso utilizaremos el formulario frmArreglos, cuyo diseño se
presenta en el siguiente gráfico.
if(pos<=n-1){
double dato=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el nuevo dato"));
obj.cargardatos(dato,pos);
mostrardatos();}
else{
JOptionPane.showMessageDialog(null,"No existe esa posición");
}
txtmax.setText(String.valueOf(obj.maximo(n)));
txtpro.setText(String.valueOf(obj.promedio(n)));
txtmin.setText(String.valueOf(obj.minimo(n)));
txttotal.setText(String.valueOf(obj.sumar(n)));
txtmax.setText(String.valueOf(obj.maximo(n)));
txtpro.setText(String.valueOf(obj.promedio(n)));
txtmin.setText(String.valueOf(obj.minimo(n)));
txttotal.setText(String.valueOf(obj.sumar(n)));
txtlista2.setText(obj.buscar(n));
TRABAJO PRÁCTICO 2
Logro
El alumno aprenderá a realizar operaciones con los datos de 2
arreglos unidimensionales.
Resumen
Las operaciones elementales que desarrollaremos son: mostrar
elementos comunes entre ambos, unir dos arreglos en un tercer
arreglo.
Lógica de Presentación
Para desarrollar este caso utilizaremos el formulario frmArreglos, cuyo diseño se
presenta en el siguiente gráfico.
Nota: Se debe tener en cuenta que se deben mostrar los datos comunes, sin que
algunos de estos se repita.
eliminarRepetidosC();
return mostrarTodoslosDatosC();
}
txtlistaC.setText(obj.mostrarComunesUnicos(n, nb));
txtlistaC.setText(obj.unirArreglos(n, nb));
TRABAJO PRÁCTICO 3
Nota:
Esfuérzate por hacer tu mismo este trabajo, es importante que lo COMPRUEBES
en Java. No olvidar que se entrega el informe de este trabajo en un folder y
también el disquete o CD. (Leer forma de presentación según aparece en la
Diapositiva de la Semana 1).
Si alguno de sus compañeros no tiene esta guía de práctica, reenvíenlo a su correo.
Logro
Que el alumno comprenda y aplique los diferentes metodos de
ordenamiento que existen.
Resumen
Durante esta semana aprenderemos en que consisten los métodos
de ordenamiento de la burbuja y el método de ordenamiento por
inserción.
Métodos de Ordenamiento I
MÉTODO DE LA BURBUJA
Ventajas:
Es el método de ordenamiento más utilizado, porque es el más sencillo de
comprender.
Desventajas:
Este algoritmo es muy deficiente ya que al ir comparando las casillas para buscar
el siguiente más grande, éste vuelve a comparar las ya ordenadas.
Caso Práctico: Realizar una aplicación Java que utilice POO, Estructura de
Datos Estáticas (Arreglos) que aplique el método de ordenamiento por burbuja.
Lógica de Presentación
Para desarrollar este caso utilizaremos el formulario frmArreglos, cuyo diseño se
presenta en el siguiente gráfico.
for(i=0;i<=n-2;i++){
for(j=0;j<=n-2;j++){
if(ventas[j]>ventas[j+1]){
aux=ventas[j];
ventas[j]=ventas[j+1];
ventas[j+1]=aux;
}
}
}
return mostrarTodoslosDatos(n);
}
txtlista.setText(obj.burbuja1(n));
for(i=0;i<=n-2;i++){
for(j=0;j<=n-i-2;j++){
if(ventas[j]>ventas[j+1]){
aux=ventas[j];
ventas[j]=ventas[j+1];
ventas[j+1]=aux;
}
}
}
return mostrarTodoslosDatos(n);
}
txtlista.setText(obj.burbuja2(n));
int k;
while (bandera==false) {
bandera=true;
for(k=0; k<=n-2;k++){
if(ventas[k]>ventas[k+1]){
aux=ventas[k];
ventas[k]=ventas[k+1];
ventas[k+1]=aux;
bandera=false;
}
}
return mostrarTodoslosDatos(n);
}
txtlista.setText(obj.burbuja3(n));
Ventajas:
- Fácil implementación.
- Requerimientos mínimos de memoria.
Desventajas:
- Lento.
- Realiza numerosas comparaciones
Caso Práctico: Realizar una aplicación Java que utilice POO, Estructura de
Datos Estáticas (Arreglos) que aplique el método de ordenamiento por inserción.
Lógica de Presentación
Para desarrollar este caso utilizaremos el formulario frmArreglos, cuyo diseño se
presenta en el siguiente gráfico.
txtlista.setText(obj.insercion1(n));
double aux;
for (i = 1;i<=n-1;i++ ){
aux=ventas[i];
u=i-1;
while (p <= u) {
c = (p + u) / 2;
if (aux < ventas[c]) {
u = c - 1;
} else {
p = c + 1;
}
}
for (k = i - 1; k >= p; k--) {
ventas[k + 1] = ventas[k];
}
ventas[p] = aux;
}
return mostrarTodoslosDatos(n);
}
txtlista.setText(obj.insercion2(n));
BIBLIOGRAFIA
for(i=0;i<=n-1;i++){
dato=Double.parseDouble(JOptionPane.showInputDialog("Introduzca dato para ventas["+i+"]"));
obj.cargardatos(dato, i);
}
}
//recorre el arreglo
for(i=0;i<=n-1;i++){
acu=acu+ventas[i]; //Acumulador
}
return acu;
}
return pro;
}
5. Explique el algoritmo que permite promediar los datos de un arreglo
10. Cuál es el código que nos permite modificar datos dentro de un arreglo
int pos=Integer.parseInt(JOptionPane.showInputDialog("¿Qué posición desea modificar?"));
if(pos<=n-1){
double dato=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el nuevo dato"));
obj.cargardatos(dato,pos);
mostrardatos();}
else{
JOptionPane.showMessageDialog(null,"No existe esa posición");
}
txtmax.setText(String.valueOf(obj.maximo(n)));
txtpro.setText(String.valueOf(obj.promedio(n)));
txtmin.setText(String.valueOf(obj.minimo(n)));
txttotal.setText(String.valueOf(obj.sumar(n)));
11. Cuál es el código que nos permite eliminar un dato dentro de un arreglo
public void eliminar(int pos,int n){
int i;
for (i=pos;i<=n-2;i++){
ventas[i]=ventas[i+1];
}
12. Cuál es el código que nos permite buscar un dato dentro de un arreglo
public String buscar(int n){
int i,a;
a=0;
String acu="";
String b="";
double numer=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el numero: "));
for(i=0;i<=n-1;i++){
if(ventas[i]==numer){
acu=acu+"El dato se encuentra en la Posición "+i+"\n";
a++;
}
}
if(a>0){
return acu;
}
else {
return "Lo sentimos, el dato no ha sido encontrado...";
}
}
13. Cuál es el código que nos permite visualizar los datos comunes entre dos
arreglos.
eliminarRepetidosC();
return mostrarTodoslosDatosC();
}
14. Cuál es el código que nos permite unir los datos de dos arreglos.
public String unirArreglos(int n,int nb){
int i,j;
nc=n+nb; //La nueva longitud del 3er arreglo
for(i=0;i<=n-1;i++){
ventasc[i]=ventas[i];
}
for(j=0;j<=nb-1;j++){
ventasc[j+n]=ventasb[j];
}
return mostrarTodoslosDatosC();
}
for(i=0;i<=n-2;i++){
for(j=0;j<=n-2;j++){
if(ventas[j]>ventas[j+1]){
aux=ventas[j];
ventas[j]=ventas[j+1];
ventas[j+1]=aux;
}
}
}
return mostrarTodoslosDatos(n);
}
for(i=0;i<=n-2;i++){
for(j=0;j<=n-i-2;j++){
if(ventas[j]>ventas[j+1]){
aux=ventas[j];
ventas[j]=ventas[j+1];
ventas[j+1]=aux;
}
}
}
return mostrarTodoslosDatos(n);
}
return mostrarTodoslosDatos(n);
}
boolean sw = false;
while (!(sw) && (k >= 0)) {
if (aux < ventas[k]) {
ventas[k + 1] = ventas[k];
k = k - 1;
} else {
sw = true;
}
}
ventas[k + 1] = aux;
}
return mostrarTodoslosDatos(n);
}
ventas[p] = aux;
}
return mostrarTodoslosDatos(n);
}