ESPOO - Presentacion Sesion01

Estructura de Datos con POO - ESPOO 05/08/2020
AGENDA:
 Arreglos Unidimensionales
 Vectores
Ing. CIP Loncán Salazar, Pierre Paul

 Módulos con trabajo de vectores
CURSO:
ESTRUCTURA DE DATOS CON POO
Docente: Ing. CIP Loncán Salazar, Pierre Paul
2
SESIÓN Nº 01
(ARRAY) ARREGLOS ARRAYS UNIDIMENSIONALES (VECTORES):

DEFINICIÓN
del mismo tipo almacenados en la memoria del ordenador (vectores) son una estructura de datos simples
en posiciones. que almacenan un conjunto de valores del mismo tipo similar a una lista,
manteniéndolos organizados.
o componentes de un arreglo se distinguen entre si por el

nombre del arreglo seguido de uno o varios índices.
 Tipos primitivos (int, double, etc.)
de un arreglo se procesan (cuando sólo se indica el  Objetos (Estudiantes, Fechas, etc.)
nombre del arreglo) o (cuando además del nombre se
especifica la posición del elemento).
del arreglo se específica cuando se crea el arreglo,
definiendo además el número de dimensiones.
 Según sea el número de dimensiones, se ditinguen:
 Unidimensionales (vectores)  Arreglo de 1 Dimensión
 Bidimensionales (Matrices)  Arreglo de 2 Dimensiones
 Multidimensionales (Matrices)  Arreglo de mas de 2 dimensiones Organizar
3 4
ARRAYS UNIDIMENSIONALES (VECTORES): ARRAYS UNIDIMENSIONALES (VECTORES):

SINTAXIS DE DECLARACIÓN SINTAXIS DE DECLARACIÓN (EJEMPLO)
un arreglo unidimensional hay que:  Ejm: (Array vacío)
 Utilizar sólo un par de corchetes int[] intArray = new int[20];
Indicar el tipo de dato que almacenará el arreglo

intArray
 Indicar el tamaño o cantidad de elementos que almacenará.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 Existen 2 sintaxis para declarar arreglos unidimensionales:
 Sintaxis 1: (Array vacío)
Tipo_Dato[] Nombre_Array = new Tipo_Dato[Tamaño];  Ejm: (Array con datos inicializados)
int[] intArray = {20,14,9,8,31,15,26,11,7,24,13,
 Sintaxis 2: (Array con datos inicializados)
28,9,4,27,19,14,2,6,1};
Tipo_Dato[] Nombre_Array = {dato1, dato2, ..etc};
intArray
 Nota sobre la sintaxis 2:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 El tamaño del arreglo dependerá del número de datos.
 Todos los datos declarados deben de ser del mismo tipo. 5 20 14 9 8 31 15 26 11 7 24 13 28 9 4 27 19 14 2 6 1 6
 No se emplea la instrucción new.
Ing. CIP Loncán Salazar, Pierre Paul 1


ÍNDICES EN UN ARRAY ASIGNACIÓN DE VALORES
datos al arreglo se debe de hacer a través de sus índices.
de los arrays comienzan en [0], no en [1], por lo cual un array con [N]
 Ejm:
espacios posee un índice que va de [0] a [N-1].

intArray[0] = 20;
intArray[5] = 15;
 Por ello, intArray posee posiciones que van desde intArray [0] a intArray
intArray[9] = 24;
[19].
 El resultado tras la asignación es el siguiente
intArray intArray
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
20 15 24
7 8

LECTURA DE DATOS Y OPERACIONES ELIMINACIÓN DE DATOS
 Se utiliza el siguiente método en donde:
intArray
 Pos  Es la posición del elemento a eliminar.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 NumElementos  Total de elementos ingresados en el array
20 14 9 8 31 15 26 11 7 24 13 28 9 4 27 19 14 2 6 1

 Este método:
 Copia los datos de derecha a izquierda sobrescribiendo la posición eliminada.
 Los valores se leen a través de sus índices para usarse en diversas operaciones.  Anula el último elemento
 Ejm:  Disminuye en 1 el valor que representa al número de elementos ingresados.
int R01 = intArray[4] - intArray[7]; // R01 = 20 public void Eliminar(int Pos)
intArray[8] = intArray[12] + intArray[19]; {
for(int x=Pos ; x<NumElementos – 1 ; x++)
 Tras la operación anterior la posición 8 se actualizó {
Nombre_Array[x] = Nombre_Array[x+1];
intArray
}
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Nombre_Array[NumElementos - 1] = null;
20 14 9 8 31 15 26 11 10 24 13 28 9 4 27 19 14 2 6 1 9 NumElementos--; 10
}

ELIMINACIÓN DE DATOS (EJEMPLO) TAMAÑO DE UN ARRAY
intArray
intArray
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
20 14 9 8 31 15 26 11 10 24 13 28 9 4 27
20 14 9 8 31 15 26 11 10 24 13
 Eliminación del número 24 que esta en la posición 9.

intArray  Un objeto array posee un miembro de datos entero (length), que proporciona el
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 número de posiciones o tamaño del array (estén vacías o contengan datos):
20 14 9 8 31 15 26 11 10 13 13 28 9 4 27 int aSize = intArray.length; // aSize = 20
20 14 9 8 31 15 26 11 10 13 28 28 9 4 27
20 14 9 8 31 15 26 11 10 13 28 9 9 4 27
 La longitud de un array no puede modificarse una vez que se haya declarado.
20 14 9 8 31 15 26 11 10 13 28 9 4 4 27
20 14 9 8 31 15 26 11 10 13 28 9 4 27 27 11 12
20 14 9 8 31 15 26 11 10 13 28 9 4 27


COPIAR DATOS DE UN ARRAY COPIAR DATOS DE UN ARRAY (EJEMPLO)
 Es posible copiar un array utilizando arraycopy a través de la siguiente sintaxis: Ejm:
 Declaramos un arreglo int[] newArray = new int[18];
System.arraycopy( ArrayOrigen, IndiceOrigen,

 Copiamos 6 elementos desde intArray empezando por la posición 7 hacia
ArrayDestino, IndiceDestino,
newArray empezando por la posición 3
NumeroElementos )
System.arraycopy(intArray, 7, newArray, 3, 6);

 ArrayOrigen Es el array desde donde se quiere copiar
 IndiceOrigen Es el índice desde donde se empezará a copiar intArray
 ArrayDestino Es el array hacia donde se enviarán los datos copiados 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 IndiceDestino Es el índice en el array destino a partir del cual se empezarán a colocar los
20 14 9 8 31 15 26 11 20 24 13 28 9 4 27 19 14 2 6 1
datos copiados
 NumeroElementos Es el total de elementos que serán copiados desde el array origen hacia
newArray
el array destino
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
13 14
11 20 24 13 28 9
AGENDA: (ARRAY) ARREGLOS
 Arreglos Multidimensionales del mismo tipo almacenados en la memoria del ordenador

 Matrices
en posiciones.
o componentes de un arreglo se distinguen entre si por el

 Módulos con trabajo de matrices
nombre del arreglo seguido de uno o varios índices.
de un arreglo se procesan (cuando sólo se indica el
nombre del arreglo) o (cuando además del nombre se
especifica la posición del elemento).
del arreglo se específica cuando se crea el arreglo,
definiendo además el número de dimensiones.
 Según sea el número de dimensiones, se ditinguen:
 Unidimensionales (vectores)  Arreglo de 1 Dimensión
 Bidimensionales (Matrices)  Arreglo de 2 Dimensiones
 Multidimensionales (Matrices)  Arreglo de mas de 2 dimensiones
15 16
ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES) :

DEFINICIÓN DIMENSIONES
(matrices de n dimensiones o  Lo más común es trabajar con sólo , sin embargo es posible trabajar con
también llamados arreglos de arreglos) son una estructura de datos usada para dependiendo de la forma en que se pretendan interpretar los datos.
almacenar un conjunto de valores del mismo tipo en forma organizada.
 Así podríamos tener:

 Tipos primitivos (int, double, etc.)
 Objetos (Estudiantes, Fechas, etc.)  Registrar 14 Nombres de Alumnos por cada Aula. Existe un total de 3 aulas.
 Matriz (14 x 3)
 Registrar 90 Recetas por cada restaurante. Existen 3 ciudades y en cada ciudad hay 8 restaurantes.
 Matriz (90 x 3 x 8)
 Registrar la cantidad de vehículos atendidos (según su clase) durante 1 semana por cada peaje. Existen 9
ciudades, en cada ciudad 4 peajes y cada peaje atiende 5 clases de vehículos.
 Matriz (7 x 9 x 4 x 5)
Organizar
17 18


DIMENSIONES DIMENSIONES
Semana Dia Semana Dia

0 1 2 3 4 5 6 0 1 2 3 4 5 6
Semana Semana
Mes Semana Mes Semana
0 1 2 3 0 1 2 3
Mes Mes
19 20

Mes Semana Dia Mes Semana Dia

0 0 1 2 3 4 5 6 0 0 1 2 3 4 5 6
Mes Mes 0 Mes Mes 0
1 1
1
2 0 1 2 3 4 5 6 2
1 2
3 3
3
0 1 2 3 4 5 6
2
0 1 2 3 4 5 6
3
21 22

23 24



25 26
ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES):

DIMENSIONES (EJEMPLO) SINTAXIS DE DECLARACIÓN
un arreglo se utilizan los corchetes, se indica el tipo de
dato que almacenará el arreglo y el tamaño o cantidad de elementos que
almacenará por cada dimensión.

 Sin embargo hay 2 sintaxis de declaración:
 Sintaxis 1: (Array vacío)
Tipo_Dato[][]…[] Nombre_Array = new Tipo_Dato[Dim 1][Dim 2]…[Dim N];
 Sintaxis 2: (Array con datos inicializados)

Tipo_Dato[][]…[] Nombre_Array = {{a1,a2,…an},{b1,b2,…bn},…{…}};
Vector_Altura  ( 16 ) Matriz_Pesos  ( 16 x 2 x 3 x 2 )
 Nota sobre la sintaxis 2:
 Dimensión  Altura  Dimensión 1  Peso  El tamaño de cada dimensión del array dependerá del número de datos.
 Dimensión 2  Sexo
27  Todos los datos declarados deben de ser del mismo tipo. 28
 Dimensión 3  Contextura
 No se emplea la instrucción new.
 Dimensión 4  Límites
ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

SINTAXIS DE DECLARACIÓN (EJEMPLO) SINTAXIS DE DECLARACIÓN (EJEMPLO)
 Ejm: (Array vacío)  Ejm: (Array con datos inicializados)
int[][][][] intBiArray = new int[16][2][3][2]; int[][][][] intBiArray2 = {{{{9,11},{12,5},{10,8}},{{47,16},{13,44},{23,22}}},

{{{1,19},{15,3},{14,6}},{{39,86},{24,75},{33,92}}},
{{{,},{,},{,}},{{,},{,},{,}}},
{{{,},{,},{,}},{{,},{,},{,}}}};
intBiArray intBiArray2
0 1 0 1
0 1 2 0 1 2 0 1 2 0 1 2
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 9 11 12 5 10 8 47 16 13 44 23 22
1 1 1 19 15 3 14 6 39 86 24 75 33 92
2 2
3 3
…
15 29 30


ÍNDICES EN UN ARREGLO ASIGNACIÓN DE VALORES (INDIVIDUALES)
 Se a través de sus índices. Ejm:
 Un con [N][M] espacios posee un índice que va de [0][0] a [N-1][M- intBiArray[0][0][1][0] = 12;
1]. intBiArray[0][1][1][1] = 44;

 intBiArray posee elementos que van desde intBiArray[1][1][1][0] = 24;
intBiArray [0][0][0][0] a intBiArray [15][1][2][1] .
intBiArray intBiArray
0 1 0 1
0 1 2 0 1 2 0 1 2 0 1 2
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 12 44
1 1 24
El resultado tras
2 2
la asignación es
3 3
el siguiente
… …
15 31 15 32

ASIGNACIÓN DE VALORES (REGISTROS) LECTURA DE DATOS Y OPERACIONES
Se a través del índice de una de las dimensiones. Ejm: intBiArray2

0 1 Los valores se leen
intBiArray[0][1][1] = new int[] {15,26};
0 1 2 0 1 2 a través de sus
intBiArray[1][0] = new int[][] {{65,38},{43,95},{11,74}}; 0 1 0 1 0 1 0 1 0 1 0 1 índices para usarse

intBiArray[3] = new int[][][]{{{1,3},{4,0},{7,5}},{{2,5},{2,8},{9,1}}}; 0 9 11 12 5 10 8 47 16 13 44 23 22 en diversas
1 1 19 15 3 14 6 39 86 24 75 33 92 operaciones
intBiArray  Ejm:
0 1 int R01 = intBiArray2[1][0][2][1] - 5; // R01 = 1
0 1 2 0 1 2 intBiArray2[0][1][0][0] = intBiArray2[1][0][2][1] * 2;
0 1 0 1 0 1 0 1 0 1 0 1
0 15 26 intBiArray2
1 65 38 43 95 11 74 0 1
El resultado tras Tras la operación
2 0 1 2 0 1 2
la asignación es anterior la posición
3 1 3 4 0 7 5 2 5 2 8 9 1 0 1 0 1 0 1 0 1 0 1 0 1
el siguiente [0][1][0][0] se
… 0 9 11 12 5 10 8 12 16 13 44 23 22
15 33 1 1 19 15 3 14 6 39 86 24 75 33 92
actualizó 34
LECTURA DE DATOS Y OPERACIONES ELIMINACIÓN DE DATOS

int[][][][] intBiArray = new int[16][2][3][2];  Se utiliza el siguiente en donde:
 Pos  Es la posición del elemento a eliminar en la dimensión.
 NumElemDimX  Total de elementos ingresados en la dimensión
 Este :
0
1  Copia los datos de derecha a izquierda sobrescribiendo la posición eliminada.
2
3  Anula el último elemento
4
5  Disminuye en 1 el valor que representa al número de elementos ingresados en la dimensión.
6
7
8 public void Eliminar_Dimension1(int Pos)
9
10 {
11
12 for(int x=Pos ; x<NumElemDim1 – 1 ; x++)
13 {
14
15 Nombre_Array[x] = Nombre_Array[x+1];
}
intBiArray[ 11][ 0 ][ 1 ][ 1 ] Nombre_Array[NumElemDim1 - 1] = null;
intBiArray[ 3 ][ 0 ][ 2 ][ 1 ] NumElemDim1--;
intBiArray[ 7 ][ 1 ][ 0 ][ 1 ] 35 } 36
intBiArray[ 13][ 1 ][ 2 ][ 1 ]


ELIMINACIÓN DE DATOS ELIMINACIÓN DE DATOS (EJEMPLO)
public void Eliminar_Dimension2(int Dim1, int Pos) intBiArray2 0 1
{ 0 1 2 0 1 2
for(int x=Pos ; x<NumElemDim2 – 1 ; x++) 0 1 0 1 0 1 0 1 0 1 0 1
{ 0 9 11 12 5 10 8 47 16 13 44 23 22

Nombre_Array[Dim1][x] = Nombre_Array[Dim1][x+1]; 1 1 19 15 3 14 6 39 86 24 75 33 92
}
Nombre_Array[Dim1][NumElemDim2 - 1] = null;  Eliminación del elemento {39,86} que esta en la posición 0 de la tercera dimensión.
NumElemDim2--;
}
intBiArray2 0 1
0 1 2 0 1 2
public void Eliminar_Dimension3(int Dim1, int Dim2, int Pos)
0 1 0 1 0 1 0 1 0 1 0 1
{
for(int x=Pos ; x<NumElemDim3 – 1 ; x++) 0 9 11 12 5 10 8 47 16 13 44 23 22
{ 1 1 19 15 3 14 6 24 75 24 75 33 92
Nombre_Array[Dim1][Dim2][x] = Nombre_Array[Dim1][Dim2][x+1];
0 9 11 12 5 10 8 47 16 13 44 23 22
}
Nombre_Array[Dim1][Dim2][NumElemDim3 - 1] = null; 1 1 19 15 3 14 6 24 75 33 92 33 92
NumElemDim3--; 37 38
0 9 11 12 5 10 8 47 16 13 44 23 22
}
1 1 19 15 3 14 6 24 75 33 92

TAMAÑO DE UN ARREGLO COPIAR DATOS DE UN ARRAY
intBiArray
0 1
(length) proporciona el  Es posible copiar un array utilizando arraycopy a través de la siguiente sintaxis:
0 1 2 0 1 2
número de posiciones o
0 1 0 1 0 1 0 1 0 1 0 1 tamaño de la dimensión System.arraycopy( ArrayOrigen, IndiceOrigen,

0 9 11 12 5 10 8 47 16 13 44 23 22 (estén vacías o contengan
ArrayDestino, IndiceDestino,
1 1 19 15 3 14 6 39 86 24 75 33 92 datos).
La longitud de un arreglo NumeroElementos )
…
15 no puede modificarse una
vez que se haya declarado  ArrayOrigen Es el array desde donde se quiere copiar
 IndiceOrigen Es el índice desde donde se empezará a copiar
 Ejm:
 ArrayDestino Es el array hacia donde se enviarán los datos copiados
int d1Size = intBiArray.length; // d1Size = 16  IndiceDestino Es el índice en el array destino a partir del cual se empezarán a colocar los
int d2Size = intBiArray[0].length; // d2Size = 2 datos copiados
int d3Size = intBiArray[0][0].length; // d2Size = 3  NumeroElementos Es el total de elementos que serán copiados desde el array origen hacia el
int d4Size = intBiArray[0][0][0].length; // d2Size = 2 array destino
39 40
ARRAYS MULTIDIMENSIONALES (MATRICES):

COPIAR DATOS DE UN ARRAY (EJEMPLO)
Ejm:
 Declaramos un arreglo int[][][][] newBiArray2 = new int[2][2][3][2];
Copiamos 2 elementos desde la segunda dimensión de intBiArray2

empezando por la posición 0 hacia newBiArray2 empezando por la
posición 1
System.arraycopy(intBiArray2[1][0], 0, newBiArray2[0][1], 1, 2);
intBiArray2 0 1
0 1 2 0 1 2
0 1 0 1 0 1 0 1 0 1 0 1
0 9 11 12 5 10 8 47 16 13 44 23 22
1 1 19 15 3 14 6 39 86 24 75 33 92
newBiArray2 0 1
0 1 2 0 1 2
0 1 0 1 0 1 0 1 0 1 0 1 41 42
0 1 19 15 3
1

Solución 3-a Solución 3-b

(Menú – Opción 2) (Menú – Opción 4)
Diseñe: un Método llamado (Registrar_2) que reciba 1 valor entero (Dato). El Diseñe: un Método llamado (Reemplazar) que reciba 2 valores enteros (Dato y
método colocará el Dato en la posición indicada por el contador i. Pos). Pos indicará en que lugar del arreglo se colocará Dato.
Restricción: El número total de datos que se pueden registrar no puede superar el
tamaño del arreglo. Se tendrá que mostrar un mensaje que indique cuando el arreglo Método
este lleno.
public static void Reemplazar(int Dato, int Pos)

Método {
Arr_Prod[Pos] = Dato;
}
public static void Registrar_2(int Dato)
{
if( i < Arr_Prod.length ) Llamado del método
{ case 4:
Arr_Prod[i] = Dato; Dato = LeerEntero("Ingrese Número");
i++; Pos = LeerEntero("Ingrese Posición");
} Reemplazar(Dato,Pos);
else
{
Imprimir("Lista Llena");
}
}
Llamado del método

case 2: 43
43 44
44
Dato = LeerEntero("Ingrese Número");
Registrar_2(Dato);
Solución 3-c Solución 3-d

Diseñe: un Método llamado (Reemplazar_2) que reciba 2 valores enteros (Dato y Diseñe: un Método llamado (Reemplazar_3) que reciba 2 valores enteros (Dato y
Pos). Pos indicará en que lugar del arreglo se colocará Dato. El método devolverá el Pos). Pos indicará en que lugar del arreglo se colocará Dato.
valor que fue reemplazado en el arreglo. Restricción: No se puede reemplazar una posición que contenga un valor que sea
diferente de 0. Se mostrará un mensaje cuando no se pueda realizar el reemplazo.
Método
Método

public static int Reemplazar_2(int Dato, int Pos)
{ public static void Reemplazar_3(int Dato, int Pos)
int n = Arr_Prod[Pos]; {
Arr_Prod[Pos] = Dato; if( Arr_Prod[Pos] == 0 )
return n; {
} Arr_Prod[Pos] = Dato;
}
Llamado del método else
case 5: {
Dato = LeerEntero("Ingrese Número"); Imprimir("Posición Ocupada");
Pos = LeerEntero("Ingrese Posición"); }
r = Reemplazar_2(Dato,Pos);
Imprimir(r); }
Llamado del método

case 6:
45
45 Dato = LeerEntero("Ingrese Número"); 46
46
Pos = LeerEntero("Ingrese Posición");
Reemplazar_3(Dato,Pos);
Solución 3-e Solución 3-f

Diseñe: Diseñe: un Método llamado (Totalizar) que no reciba ningún valor. El Diseñe: un Método llamado (Mayor) que no reciba ningún valor. El método
método sumará todos los datos contenidos en el arreglo y devolverá el resultado a encontrará y devolverá el mayor de todos los datos contenidos en el arreglo. Se
través del mismo método. Se mostrará un mensaje con el resultado obtenido. mostrará un mensaje con el resultado obtenido.
Método Método
0 1 2 3 9
public static int13Totalizar() public static int 0

Mayor()1 2 3 9
{ 19 14 27 … 14 {
int Total = 0; 13 19
int Mayor = Arr_Prod[0]; 14 27 … 14
for( int13
x=0 Total
; x < =Arr_Prod.length
Total + Arr_Prod[0];
; x++) for( int x=0 ; x < Arr_Prod.length ; x++)
{ 32 Total = Total + Arr_Prod[1]; { 13 Mayor = Arr_Prod[0];
Total46
= Total
Total+ =Arr_Prod[x];
Total + Arr_Prod[2]; 19 Mayor
if( Arr_Prod[x] = Arr_Prod[1];
> Mayor)
} 73 Total = Total + Arr_Prod[3]; { 19 En Arr_Prod[2] no hay cambio
return Total; 27 = Arr_Prod[x];
Mayor Mayor = Arr_Prod[3];
} }
Total = Total + Arr_Prod[n]; }
return Mayor; Mayor = Arr_Prod[n];
Llamado del método }
case 7:
r = Totalizar();
Imprimir(r); Llamado del método
case 8:
r = Mayor();
Imprimir(r);
47
47 48
48

Solución 3-g Solución 3-h

Diseñe: un Método llamado (Contar) que reciba 1 valor entero (Dato). El método Diseñe: un Método llamado (Eliminar_Ultimo) que no reciba ningún valor y
contará la cantidad de elementos contenidos en el arreglo y devolverá el resultado del elimine únicamente el último elemento del arreglo.
conteo. Se mostrará un mensaje con el resultado obtenido. Restricción: No puede eliminar si ya no existen datos en el arreglo.
Restricción: Sólo serán contados los números mayores al entero Dato recibido.
Método
Método

public static void Eliminar_Ultimo()
0 1 2 3 9 {
public static int Contar(int Dato)
{ 13 19 14 27 … 14 if( i > 0)
int C= 0; {
for( int x=0 ; x Para
< Arr_Prod.length ; x++)
números mayores a 15 Arr_Prod[i-1] = 0;
{ i = i - 1;
if( Arr_Prod[x] > Dato) }
{ 0 En Arr_Prod[0] no hay cambio else
C = C1 + 1; C = C + 1; {
} 1 En Arr_Prod[2] no hay cambio Imprimir("Lista Vacia");
} 2 }
C = C + 1; }
return C;
}
Llamado del método
Llamado del método case 11:
case 9: Eliminar_Ultimo();
r = Contar(LeerEntero("Ingrese Número“)); 49
49 50
50
Imprimir(r);
51

ESPOO - Presentacion Sesion01

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

ESPOO - Presentacion Sesion01

Cargado por

Copyright:

Formatos disponibles

Estructura de Datos con POO - ESPOO 05/08/2020

Ing. CIP Loncán Salazar, Pierre Paul

(ARRAY) ARREGLOS ARRAYS UNIDIMENSIONALES (VECTORES):

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS UNIDIMENSIONALES (VECTORES): ARRAYS UNIDIMENSIONALES (VECTORES):

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul 1

ARRAYS UNIDIMENSIONALES (VECTORES): ARRAYS UNIDIMENSIONALES (VECTORES):

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS UNIDIMENSIONALES (VECTORES): ARRAYS UNIDIMENSIONALES (VECTORES):

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS UNIDIMENSIONALES (VECTORES): ARRAYS UNIDIMENSIONALES (VECTORES):

Ing. CIP Loncán Salazar, Pierre Paul

 Eliminación del número 24 que esta en la posición 9.

Ing. CIP Loncán Salazar, Pierre Paul 2

ARRAYS UNIDIMENSIONALES (VECTORES): ARRAYS UNIDIMENSIONALES (VECTORES):

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul

System.arraycopy(intArray, 7, newArray, 3, 6);

AGENDA: (ARRAY) ARREGLOS

 Arreglos Multidimensionales del mismo tipo almacenados en la memoria del ordenador

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES) :

Ing. CIP Loncán Salazar, Pierre Paul

 Así podríamos tener:

Ing. CIP Loncán Salazar, Pierre Paul 3

ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES) :

Semana Dia Semana Dia

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul

Mes Semana Mes Semana

ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES) :

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES) :

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul 4

ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES) :

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES) : ARRAYS MULTIDIMENSIONALES (MATRICES):

Ing. CIP Loncán Salazar, Pierre Paul

 Sintaxis 2: (Array con datos inicializados)

ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

int[][][][] intBiArray = new int[16][2][3][2]; int[][][][] intBiArray2 = {{{{9,11},{12,5},{10,8}},{{47,16},{13,44},{23,22}}},

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul 5

ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

LECTURA DE DATOS Y OPERACIONES ELIMINACIÓN DE DATOS

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul 6

ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

Ing. CIP Loncán Salazar, Pierre Paul

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES): ARRAYS MULTIDIMENSIONALES (MATRICES):

Ing. CIP Loncán Salazar, Pierre Paul

ARRAYS MULTIDIMENSIONALES (MATRICES):

Ing. CIP Loncán Salazar, Pierre Paul 7

Solución 3-a Solución 3-b