Arreglos

Unidimensionales
Temario
 Definición
 Declaración e Inicialización
 Elementos de un Arreglo
 Lectura y Escritura de Arreglos
 Búsqueda Secuencial
 Ordenamiento
Problema:

Elaborar un programa en Lenguaje C++ que lea 5 notas de un

Alumno y luego las imprima en orden inverso al ingresado
Solución – Sin Arreglos
int main()
{ int Nota1,Nota2,Nota3,Nota4,Nota5; // Variables para almacenar las 5 notas
//Ingreso de Datos
cout<< “Ingrese Nota 1 ” ; cin>>Nota1;
cout<< “Ingrese Nota 2 ” ; cin>>Nota2;
cout<< “Ingrese Nota 3 ” ; cin>>Nota3;
cout<< “Ingrese Nota 4 ” ; cin>>Nota4;
cout<< “Ingrese Nota 5 ” ; cin>>Nota5;
//Mostrar las notas
cout<< “Nota 5 : ” << Nota5;
cout<< “Nota 4 : ” << Nota4;
cout<< “Nota 3 : ” << Nota3;
cout<< “Nota 2 : ” << Nota2;
cout<< “Nota 1 : ” << Nota1;
return 0;
}
Solución – Con Arreglos

int main()
{ int *VNotas; // Arreglo para almacenar las 5 notas
VNotas= new int[5];
//Ingreso de Datos
for(int i=0;i<5;i++)
{ cout<<“Ingrese Nota “ << i+1<< “: “;
cin>>VNotas[i];
}

//Mostrar las notas

for(int i=4;i>=0;i--)
cout<< “Nota “ << i+1 << “ es : ” << VNotas[i];
return 0;
}
Definición de Arreglo

 Un arreglo es una estructura de datos que permite

almacenar datos del mismo tipo (int, double, char,
etc.).

 El tipo más simple de un arreglo es el arreglo

unidimensional.

 Para poder utilizar un arreglo es necesario:

declararlo e inicializarlo.
Declaración de un arreglo unidimensional

En C, para poder utilizar un arreglo primero hay

que declararlo.

Al declarar un arreglo unidimensional se reserva,

en la memoria RAM, el espacio suficiente para
almacenar todos los valores.

La cantidad de memoria que se reserva esta dada

por el tamaño del tipo de dato y la cantidad de
elementos del arreglo.
Declaración de Arreglos como punteros

Supongamos que tenemos la siguiente

variable:
Tipodato *Nombrepuntero;

Para crear un arreglo debemos hacer uso de

New y sería de la siguiente forma:

Nombrepuntero=new Tipodato[cantidad];
Declaración y creación de un arreglo unidimensional63

Veamos el siguiente ejemplo:

Sea Vec un arreglo de enteros con 7 posiciones:
int *Vec = new int[7];
Si suponemos que un dato entero ocupa 2 bytes.
Tendríamos lo siguiente:
Declaración de un arreglo unidimensional

Dirección Índice del Arreglo de

en Memoria Arreglo 7 valores
Primer valor del índice

Valor en Vec[0]
AB001 0 20

AB003 1
La dirección donde se
AB005 inicia Vec es : AB001
2
AB007 3 Vec La dirección de &Vec[0]
es AB001
AB009 15
4
AB00A
Vec <-> &Vec[0]
5
Valor en Vec[4]
AB00C 6

Último valor del índice (N-1)

Arreglos como punteros

Imaginemos que la memoria se encuentra de esta

forma:

Analizaremos únicamente la Zona

Estática y el HEAP…

El color blanco representa

espacios de memoria libre y el
color rojo espacios de memoria
ocupado.
Arreglos como punteros
Y queremos realizar lo
siguiente:

1. Definir un puntero a float

llamado ptrfloat

float * ptrfloat;

2. Asignar dinámicamente
los espacio de memoria
donde se almacenarán los
10 datos float.

ptrfloat=new float[10];
Como funciona New
1. Definir un puntero a float llamado ptrfloat

float * ptrfloat;

En este caso la variable ptrfloat es una

variable estática, por lo tanto ocupará
una posición de memoria dentro de la
zona estática.
Arreglos como punteros
float * ptrfloat;
Mediante un algoritmo de
selección se busca un
espacio de memoria para
alojar al puntero

Imaginemos que el espacio

de color azul es el asignado
para alojar a la variable
ptrfloat
Arreglos como punteros

2. Asignar dinámicamente los

espacio de memoria donde se
almacenarán los 10 datos float.

ptrfloat=new float[10];

Al ser una asignación dinámica se

le asignará un espacio dentro del
HEAP
Arreglos como punteros

Mediante un algoritmo de selección

se busca 10 espacios contínuos de
78A1
78B1 memoria para alojar los 10 datos
según el tipo al que apunta el
puntero

En este caso se ha definido que a

partir del espacio 78A1 existen los
espacios de memoria requeridos
Elementos de un Arreglo
Sea Vec un arreglo de 10 valores enteros
V
e 89 36 15 64 37 29 18 59 75 91
ci 0 1 2 3 4 5 6 7 8 9

■ Para acceder a un elemento del arreglo

Primer elemento Vec[0] → 89

Segundo elemento Vec[1] → 36

Último elemento Vec[9] → 91

Elementos de un Arreglo
V
e 89 36 15 64 . . . . . .
N
ci 0 1 2 3 . . . . . -
1

De manera general:

i-ésimo elemento

Vec[i]
Para un valor de i entre 0 y N-1
Inicializar un arreglo unidimensional

Por defecto, cuando declaramos un arreglo el

valor inicial de cada celda es el que tiene en
ese momento la posición de memoria
asignada.
Si deseamos que cada celda tenga un valor
inicial debemos de inicializar el arreglo.
Inicializar un arreglo unidimensional

Sea el Vec un arreglo de enteros de Índice del

Arreglo
Vec
7 posiciones
0 14
int *Vec = new int[7]; 1 5

2 19

Que luego de declararlo tiene lo 3 20

siguientes valores: 4 11

5 10

6 16
Inicializar un arreglo unidimensional

Índice del Vec Si deseamos inicializar con 0, por ejemplo,

Arreglo
cada celda del arreglo debemos hacer lo
0 0
14 siguiente:
1 0
5

2 0
19 for(int i=0; i<7; i++)
3 0
20 {
4 0
11
Vec[i]=0;
0
10
}
5

6 0
16
Arreglos como punteros

Ejemplo
Asignarle memoria dinámica a un puntero a un dato
del int de 100 posiciones.

int main()
{int *Arreglo;
Arreglo= new int[100];
for (int i=0;i<100;i++)
Arreglo[i]=i;

for (int i=0;i<100;i++)

cout<< Arreglo[i] <<“\n”;

…..
}
Arreglos como punteros

Si se le asignó dinámicamente la
memoria a un arreglo, cómo se
libera????
Arreglos como punteros

Si hemos utilizado new para asignar

debemos utilizar delete para liberar.

delete [ ] Nombrepuntero;

Debemos anteponer los corchetes al

nombre de la variable del tipo puntero.
Tareas básicas para trabajar con Arreglos
Unidimensionales
o Vectores
Ingresar datos a un Arreglo

Por ejemplo, si deseamos almacenar las edades de los alumnos de

un salón de ingles en un arreglo.

int main()
{ int nele; //numero de elementos del arreglo
int *Vec = new int[10]; // Arreglo que almacenara las edades
//Lectura y Validación del Numero de elementos
do{
cout<<“Ingrese el numero de alumnos: ”;
cin>>nele;
}while(nele<=0 || nele>10);
//Lectura de edades en el arreglo
for(int i=0;i<nele;i++) //el índice empieza en 0
{ cout<<“Ingrese Edad “ << i+1 <<“ : “;
cin>>Vec[i]; //ingreso de datos
}
_getch();
return 0;
}
Mostrar datos de un Arreglo

Siguiendo con el ejemplo anterior, si deseamos mostrar las

edades almacenadas en el arreglo.

int main()
{ int nele; //numero de elementos del arreglo
int *Vec = new int[10]; // Arreglo que almacenara las edades
//Lectura y Validación del Numero de elementos
…
//Lectura de edades en el arreglo
…
//Mostrar las edades almacenadas en el arreglo
cout<<“El arreglo tiene los siguientes datos :\n”;
for(int i=0;i<nele;i++)
cout<<“Edad “ << i+1 << “ = “ << Vec[i] << “\n ”;
_getch();
return 0;
}
Generar Aleatoriamente datos a un Arreglo

Opción 1:
Por ejemplo, si deseamos generar números al azar en un
arreglo usando el método srand y rand.

int main()
{ int nele; //numero de elementos del arreglo
int *X = new int[10]; // Arreglo que almacenara los datos
//Lectura y Validación del Numero de elementos
…
//Generar aleatoriamente los datos del arreglo
srand(time_t(0));
for (int i=0;i< nele;i++)
X[i]=rand() ;
_getch();
return 0;
}
Generar Aleatoriamente datos a un Arreglo

Opción 2:
Por ejemplo, si deseamos generar notas al azar en un arreglo
usando el método Random::Random().Next( , ). En Visual Studio
C++.

int main()
{ int nele; //numero de elementos del arreglo
int *Vec = new int[10]; // Arreglo que almacenara los datos
//Lectura y Validación del Numero de elementos
…
//Generar aleatoriamente los datos del arreglo
for(int i=0;i<nele;i++)
{ Vec[i]=Random::Random().Next(0,20);
Sleep(20);
}
_getch();
return 0;
}
Sumar los elementos de un arreglo

int main()
{ int nele; //numero de elementos del arreglo
int *Vec = new int[10]; // Arreglo que almacenara los datos
int suma;
//Lectura y Validación del Numero de elementos
…
//Lectura de los datos del arreglo
…
//Suma de los elementos
suma=0;
for(int i = 0; i< nele; i++)
suma + = Vec[i];

cout<<“la suma es : ”<<suma;

_getch();
return 0;
}
Hallar el mayor elemento

Sea Vec un arreglo de 5 valores enteros

V
e 29 18 59 75 91
ci 0 1 2 3 4

Cómo debemos hacer para hallar el mayor valor dentro del

arreglo?
Hallar el mayor elemento

Mayor
<
elemento
V
e 29 18 59 75 91
c
El mayor de un arreglo
int main()
{ int nele; //numero de elementos del arreglo
int *Vec = new int[10]; // Arreglo que almacenara los datos
int max;
//Lectura y Validación del Numero de elementos
…
//Lectura de los datos del arreglo
…
//Hallar el mayor de los elementos
int max = Vec[0];
for(int i = 1; i< nele; i++)
if (Vec[i] > max)
max = Vec[i];
cout<<“El mayor elemento es : ” << max;
_getch();
return 0;
}
Y el menor elemento?....
Buscar un elemento

num 6
4
Vec 89 36 15 64 37 19 28

0 1 2 3 4 5 6

//Lectura y Validación del Numero de elementos …

//Lectura de los datos del arreglo …
//Búsqueda de un dato
encontrado=0; //falso
for(int i = 0; i < nele; i++){
if(Vec[i] == num)
encontrado=1; //verdad
}
if (encontrado ==1) cout<<“Se encontró el
dato”;
else cout<<“No se encontró el dato”;
Ejercicios
Ejercicio 1 – Repetido

Elaborar un programa que busque un numero

dentro de un arreglo e imprima el numero de veces
que se encontró

Para ello el programa debe solicitar:

•El Numero de elementos nele del Arreglo
•Un Arreglo de enteros Vec
•Un Numero num a buscar
Ejercicio 2 - Aprobados

Elaborar un programa que imprima las notas aprobatorias

que hay dentro de un arreglo de Notas.

Para ello el programa debe solicitar:

•El Numero de elementos nele del Arreglo
•Un Arreglo de enteros Vnotas

Se considera aprobado con nota mayor o igual a 13.

Ejercicio 3 - Promedio

Elaborar un programa que devuelva el promedio

de notas de un alumno. Sabiendo que la menor
nota no debe ser considerada para el promedio.

Para ello el programa debe solicitar:

• El Numero de elementos nele del Arreglo
• Un Arreglo de notas del alumno Vnotas
Ejercicio 4 - Frecuencia

Elaborar un programa que dado un Arreglo de

Notas de un salón de 40 alumnos devuelva un
Arreglo de Frecuencia de Notas

Para ello el programa debe solicitar:

•Un Arreglo de notas del salón VSalon
Ordenamiento

Los arreglos son estructuras de datos cuya

información no está, necesariamente, ordenada.

Para ordenar un arreglo hay que seguir

algoritmos establecidos, siendo uno de los más
sencillos el de intercambio de valores
Ordenamiento

• Sea Vec un arreglo de 3 datos enteros que tiene la

siguiente información

89 36 15

• Para ordenarlo ascendentemente, en está ocasión,

vamos a hacer lo siguiente
Ordenamiento

V
e 89 36 15

i j c >
Vec
0 0 Vec[j
[i]
1 1 ]
2 2
 Ordenamiento

Dado un vector Vec[] de enteros y un numero de

elementos nele. El código de ordenamiento
ascendente sería.

int aux; //un temporal que ayuda al intercambio

for(int i=0;i<nele-1;i++)
{
for(int j=i+1;j<nele;j++)
if (Vec[i]>Vec[j])
{ aux=Vec[i];
Vec[i]=Vec[j];
Vec[j]=aux;
}
}