ESTRUCTURA DE DATOS ARREGLOS (VECTORES Y MATRICES) (ARRAYS).
Un arreglo (array) es una
estructura de datos con una capacidad predefinida en la cual se pueden
almacenar datos del mismo tipo. Estos datos son almacenados en forma secuencial
en la memoria y ocupan una determinada cantidad de bytes según cual sea el tipo
de dato. La capacidad de un arreglo se declara desde el primer momento cuando
este es construido, y no puede cambiar en tiempo de ejecución. Cada dato
almacenado es considerado un elemento al cual se accede por un índice de
posición (un número entero no negativo)
Arreglos:
Los
arreglos se pueden definir como objetos en los que podemos guardar más de una
variable, es decir, al tener un único arreglo, este puede guardar múltiples
variables de acuerdo a su tamaño o capacidad, es importante recordar que las
variables guardadas deben ser del mismo tipo.
·
Los arreglos son entidades “estáticas” en cuanto
a que su tamaño no cambia una vez que han sido creadas.
·
Un arreglo es un grupo de posiciones de memoria
contiguas. Todas las cuales tienen el mismo nombre y el mismo tipo.
·
Los arrays pueden ser unidimensionales
(vectores) ó bidimensionales (matrices)
ARREGLOS
UNIDIMENSIONALES
Un arreglo unidimensional es un tipo
de datos estructurado que está formado por una colección finita y ordenada de
datos del mismo tipo. Es la estructura natural para modelar listas de elementos
iguales. Los datos que se guarden en los arreglos todos deben ser del mismo tipo.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, es
decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar
a elementos anteriores o posteriores, esto mediante el uso de un índice para
cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria.
Los arreglos nos permiten hacer un
conjunto de operaciones para manipular los datos guardados en ellos, estas
operaciones son: ordenar, buscar, insertar, eliminar, modificar entre otras.
Ejemplos
de arreglos unidimensionales.
Ejercicio 1:
Programa que lee
por teclado la nota de los alumnos de una clase y calcula la nota media del
grupo. También muestra los alumnos con notas superiores a la media. El número
de alumnos se lee por teclado.
Este programa crea
un array de elementos de tipo doublé que contendrá las notas de los alumnos. El
tamaño del array será el número de alumnos de la clase.
public class unidimensionales_ejercicio_1
{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int numAlum, i;
double suma = 0, media;
do {
System.out.print("Número de
alumnos de la clase: ");
numAlum = sc.nextInt();
} while (numAlum <= 0);
double[] notas = new double[numAlum]; //se crea el array
// Entrada de datos. Se asigna a cada elemento del array
// la nota introducida por teclado
for (i = 0; i < notas.length; i++) {
System.out.print("Alumno
" + (i + 1) + " Nota final: ");
notas[i] = sc.nextDouble();
}
// Sumar todas las notas
for (i = 0; i < notas.length; i++) {
suma = suma + notas[i];
}
// Calcular la media
media = suma / notas.length;
// Mostrar la media
System.out.printf("Nota media del curso: %.2f %n", media);
// Mostrar los valores superiores a la media
System.out.println("Listado de notas superiores a la media:
");
for (i = 0; i < notas.length; i++) {
if (notas[i] > media) {
System.out.println("Alumno
numero " + (i + 1)+ " Nota final: " + notas[i]);
}
}
}
}
Ejercicio 2:
Crea un array de 10
posiciones de números con valores pedidos por teclado. Muestra por consola el índice
y el valor al que corresponde. Haz dos métodos, uno para rellenar valores y
otro para mostrar.
public class ejercicio_2_unidimensionales {
public static void
main(String[] args) {
//Esto es
opcional
final int
TAMANIO=10;
int num[]=new
int[TAMANIO];
//Invocamos
las funciones
rellenarArray(num);
mostrarArray(num);
}
public static void
rellenarArray(int lista[]){
for(int
i=0;i<lista.length;i++){
String
texto=JOptionPane.showInputDialog("Introduce un número");
lista[i]=Integer.parseInt(texto);
}
}
public static void
mostrarArray(int lista[]){
for(int
i=0;i<lista.length;i++){
System.out.println("En el indice "+i+" esta el valor
"+lista[i]);
}
}
}
Ejercicio
3:
Ejercicio
que muestra la primera y la última edad de una lista:
public class ejercico_3_unidimensionales {
public static
void main(String[] args) {
int edades[] =
{10,15,20,25,30,35};
//Mostrar el primer elemento
System.out.println("la primera edad de la lista
es:");
System.out.println(edades[0]);
//Mostrar el último elemento
System.out.println("la ultima edad de la lista
es:");
System.out.println(edades[edades.length-1]);
//Mostrar todo el vector
System.out.println("todos los valores de las edades de
la lista:");
for(int i=0; i<edades.length; i++)
System.out.print(edades[i]+" ");
System.out.println();
//Mostrar todo el vector de otra forma
System.out.println("la lista de las edades:");
for(int edad:edades)
System.out.print(edad+" ");
System.out.println();
}
}
Ejercicio
4:
Ejercicio
que muestra el valor mas pequeño de la lista de números:
public class ejercicio_4_unidimensionales {
public static
void main(String[] args) {
int numeros[] = {1,2,3,4,5,6,7,8,9,10};
int min = numeros[0];
for(int i=1; i<numeros.length; i++) {
if(numeros[i] <
min)
min =
numeros[i];
}
System.out.println("El valor más pequeño es:
"+min);
}
}
EJERCICIOS DE ARREGLOS BIDIRECCIONALES:
Un
array en programación Java puede tener más de una dimensión. El caso más
general son los arrays bidimensionales también llamados matrices o tablas.
La
dimensión de un array la determina el número de índices necesarios para acceder
a sus elementos dentro del programa.
Una
matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos
representar una matriz como una tabla de n filas y m columnas cuyos elementos
son todos del mismo tipo.
La
siguiente figura representa un array M de 3 filas y 5
columnas:
Ejercicios
de arreglos bidimensionales:
Ejercicio
1:
Crear una tabla de 4x4 y mostrar la suma de
cada fila y de cada columna:
public class ejercico_bidireccional_1 {
public static void
main(String[] args) {
int[][] num =
new int[4][4];
Scanner numero
= new Scanner(System.in);
System.out.println("Ingrese los números.");
for (int i =
0; i < num.length; i++) {//Dimensión Uno.
for (int j
= 0; j < num.length; j++) {//Dimensión Dos.
num[i][j]=numero.nextInt();
}
}
System.out.println("Imprimiendo Tabla.");
for (int i =
0; i < num.length; i++) {
System.out.println();
for (int j
= 0; j < num.length; j++) {
System.out.print(num[i][j] + " ");
}
}
System.out.println("\nSuma Fila.");
int suma=0;
for (int i =
0; i < num.length; i++) {
for (int j
= 0; j < num.length; j++) {
suma
+= num[i][j];
}
System.out.println("Fila
" + i + " =" + suma);
suma=0;
}
System.out.println("\nSuma Columna");
for (int i =
0; i < num.length; i++) {
for (int j
= 0; j < num.length; j++) {
suma
+= num[j][i];
}
System.out.println("Columna " + i + " =" + suma);
suma=0;
}
}
}
Ejercicio
2: se pide un programa en el cual el ususario ingrese números para conformar
una tabla de 2 x 2
public class ejercicio_bidireccional_2 {
public static void
main(String args[])
{
Scanner EN=new
Scanner(System.in);
int M[][]=new
int[2][2];
System.out.println("ingrese los numeros a
mostrar en la tabla");
for(int
i=0;i<2;i++)
for(int
j=0;j<2;j++)
M[i][j]=EN.nextInt();
System.out.println("se muestra la tabla de los numeros
ingresados");
for(int
i=0;i<2;i++)
{
for(int
j=0;j<2;j++)
System.out.print(M[i][j]+" ");
System.out.println();
}
}
}
Ejercicio
3:
Se
pide un programa q muestre una matriz de 3 x 3
public class ejercicio_bidireccional_3 {
public static
void main(String[] args) {
int
matriz[][]=new int[3][3];
//i = filas y
j = columnas
System.out.println(" se muestra la tabla de 3 x 3 de los numeros
del 1 al 9");
for(int
i=0;i<matriz.length;i++){
for(int
j=0;j<matriz[0].length;j++){
matriz[i][j]=(i*matriz.length)+(j+1);
System.out.print(matriz[i][j]+" ");
}
System.out.println(" ");
}
}
}
Ejercicio
4:
Crear una matriz de 5 filas
y n columnas (se pide al usuario). Rellenarlo con números aleatorios entre 0 y
10.
public class ejercicio_bidireccionales_4 {
public static
void main(String[] args) {
Scanner sn=new
Scanner(System.in);
System.out.println("Escriba un numero de columnas");
int
columnas=sn.nextInt();
int
matriz[][]=new int[5][columnas];
System.out.println("se muestra la tabla con numeros del 0 al
9");
for(int
i=0;i<matriz.length;i++){
for(int
j=0;j<matriz[0].length;j++){
matriz[i][j]=generaNumAleatorio(0,9);
System.out.print(matriz[i][j]+" ");
}
System.out.println("");
}
}
public static int
generaNumAleatorio(int minimo,int maximo){
return
(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
}
}
No hay comentarios:
Publicar un comentario