Sie sind auf Seite 1von 23

TEMA 6: Datos Estructurados

Fundamentos de Informática
(Grados en Ingenierías Industriales)

Índice
1. Arrays.
1.1 Arrays Unidimensionales.
1.1.1. Declaración y acceso. 1.1.3. Inicialización de arrays.
1.1.2. Nombres de arrays. 1.1.4. Arrays como argumentos.
1.2. Arrays Multidimensionales.
1.2.1. Concepto. Declaración. 1.2.3. Inicialización de arrays.
1.2.2. Acceso a los elementos. 1.2.4. Arrays como argumentos.
1.3. Cadenas de Caracteres.
2. Estructuras.
2.1. Declaración y acceso. 2.3. Estructuras como argumentos.
2.2. Inicialización. 2.4. Arrays de estructuras.
3. Búsqueda y Ordenación.

1
Arrays Unidimensionales:
Declaración y Acceso
• Un array es una colección finita (num_elementos) de
elementos del mismo tipo de datos (tipo_elemento).
• tipo_elemento:
- Simple (int, bool, char, float,…)
- Estructurado (array, estructura)
• Declaración de un tipo array
typedef array<tipo_elemento,num_elementos> nombre_tipo;

Configurar el compilador
#include <iostream>
para poder utilizar la #include <array>
biblioteca estándar de C++
using namespace std;
//--constantes-------------------------------
El número de elementos
debe ser una constante const unsigned NELMS = 5;
conocida en tiempo de
compilación (cuando se
//--tipos de datos nuevos-----------------
programa) typedef array<int, NELMS> Vector;
//--subalgoritmos------------- 3

Arrays Unidimensionales:
Declaración y Acceso
• Declaración de una cte/vble de un tipo array
PRIMOS 2 3 5 7 11


//--constantes-------------------------------
const Vector PRIMOS = {2, 3, 5, 7, 11};
//--principal---------------------------------
int main()
{
Vector v;

}

V ? ? ? ? ?
4

2
Arrays Unidimensionales:
Declaración y Acceso
• Inicialización de un array => {..,..,..}
─ const Vector PRIMOS = {2,3,5,7} INCOMPLETA
─ const Vector PRIMOS = {2,3,5,7,11,13} ERROR!!

• Acceso a cada elemento => [índice]


- Los índices van de 0 hasta el tamaño del array menos uno
0…………………………………..NELMS -1 = 4
PRIMOS 2 3 5 7 11

PRIMOS[0] PRIMOS[1] PRIMOS[2] PRIMOS[3] PRIMOS[4] PRIMOS[5]

#include <array>
...
¡¡¡Error!!!
//--constantes-------------------------------
Acceso fuera de rango
const unsigned NELMS = 5;
//--tipos de datos nuevos-----------------
typedef array<int,NELMS> Vector;
5

Arrays Unidimensionales:
Declaración y Acceso

• VENTAJAS de su uso frente a variables aisladas:


- Podemos referirnos a todos los elementos a la vez (al declararlos,
al pasarlos a una función, etc.).
- Permite resolver problemas de forma sencilla y compacta.

• ¿Cómo se ALMACENAN los arrays en MEMORIA?


- Los elementos se almacenan CONTIGUOS en memoria.
typedef array <char,5> c; typedef array <int,5> a;
Elemento 0 1 2 3 4 0 1 2 3 4
Dirección 1000 1001 1002 1003 1004 1000 1002 1004 1006 1008

Suponemos :
- que ambos arrays comienzan en la posición 1000
- que un entero ocupa 2 bytes
- que un char ocupa 1 byte (cada número de posición indica 1 byte).
6

3
Arrays Unidimensionales:
Operadores Predefinidos
• Asignación (=)
─ De valores de un tipo array a una variable del mismo
tipo array.
int main()
• Comparación de igualdad (==) {
─ Devuelve TRUE o FALSE Vector v1, v2;
─ Compara elementos en la misma posición v1 = v2;
if (v1==v2)
• Comparación de desigualdad (!=) ...
─ Devuelve TRUE si algún elemento del }
primer array no coincide con el que ocupa la misma
posición en el segundo
• Paso de array como parámetro a subprograma
─ Por referencia => parámetros de S, o E/S
void leerVector (Vector &v);
─ Por valor => parámetros de E
void escribirVector (Vector v);
─ Por referencia constante => parámetros de E (más eficiente)
void escribirVector (const Vector &v): 7

Arrays Unidimensionales:
Argumentos en Funciones
• Operaciones de lectura/escritura de un array
─ No se disponen de operaciones predefinidas en C++ para
efectuar la entrada/salida de datos de un tipo array.
─ El usuario debe programar la lectura y/o escritura de
cada componente según el tipo de que se trate.

void leerVector (Vector &v) int sumaElementos (Vector v)


{ {
for (unsigned i=0;i<NELMS;i++) int suma=0;
{ for (unsigned i=0; i<NELMS; i++)
cout << "Introd. valor ="; suma+=v[i];
cin >> v[i]; return suma;
} }
int main()
} {
int mayorElemento (Vector v) Vector v1,v2;
{ leerVector(v1);
int mayor = v[0]; leerVector(v2);
cout << "El mayor elemento es = "
for (unsigned i=1; i<NELMS; i++) << mayorElemento(v1)<< endl;
if (mayor<v[i]) if (sumaElementos(v1)==sumaElementos(v2))
mayor = v[i]; cout << "Los dos vectores suman igual";
return mayor; return 0;
} }
8

4
Arrays Unidimensionales:
Argumentos en Funciones
• Ejemplo_1: Agentes de ventas
─ Lee las ventas de cada “agente” e imprime su sueldo.
─ Sueldo = Cantidad fija (1000 euros) + incentivo.
─ Incentivo = 10% de las ventas que ha realizado.
─ Incentivo es sólo aplicable a agentes cuyas ventas
superen los 2/3 de la media de ventas del total de los
agentes.

VentasAgentes

ventas[i]= Ventas del agente i


//--constantes---------------------------
const unsigned NAGENTES = 20;
const double SUELDO_FIJO = 1000.0;
const double INCENTIVO = 10.0;
const double PROMEDIO = 2.0/3.0;

//--tipos-------------------------------
typedef array<double, NAGENTES> VentasAgentes;

Arrays Unidimensionales:
Argumentos en Funciones
//--subalgoritmos----------------------- // Imprimir sueldos de los agentes
void imprimirSueldos(const VentasAgentes &v)
// Devuelve el p% de valor {
double porcentaje (double p, double valor) double umbral = PROMEDIO*calMedias(v);
{ double sueldo;
return (p*valor)/100.0;
} for (unsigned i=0;i<NAGENTES;i++)
{
// Devuelve la media de las ventas total sueldo=SUELDO_FIJO;
double calMedias (const VentasAgentes &v) if (v[i]>=umbral){
{ sueldo+=porcentaje(INCENTIVO,v[i]);
double suma = 0.0; }
for (unsigned i=0;i<NAGENTES;i++){ cout << "El sueldo del agente " << i
suma+=v[i]; << " es = "<< sueldo << endl;
} }
return suma/double(NAGENTES); }
}
//--programa principal-----------------------
// Lee las ventas de cada agente int main()
void leerVentas(VentasAgentes &v) {
{ VentasAgentes ventas;
for (unsigned i=0;i<NAGENTES;i++){ leerVentas(ventas);
cout << "Int. Ventas agente "<<i<<" = "; imprimirSueldos(ventas);
cin >> v[i]; }
}
}

10

5
Arrays Unidimensionales:
Argumentos en Funciones
• Arrays incompletos
─ Situaciones en las que NO se conoce num. elementos que
se desea almacenar.

─ En tiempo de compilación se define el array con un


tamaño mayor que el núm. elementos contendrá en tiempo
de ejecución. Opciones:
Gestionar el array con huecos (usando una marca).
Mantener los elementos actuales válidos consecutivos
al comienzo del array:
─ Marcar separación elementos válidos de elementos
vacíos.
─ Definir una variable que contenga el número de
elementos válidos consecutivos.

─ Si se necesita el tamaño del array en una función, éste


debe pasarse como un argumento explícito.

11

Arrays Unidimensionales:
Argumentos en Funciones
// Devuelve la media de los num elementos de v // Devuelve el p% de valor
double calMedias (const VentasAgentes &v, double porcentaje (double p, double valor)
int num) { return (p*valor)/100.0;
{ double suma = 0.0; }
for (unsigned i=0;i<num;i++){
suma+=v[i]; // Imprimir sueldos de los agentes
} void imprimirSueldos(const VentasAgentes &v,
return suma/double(num); int num)
} {
double umbral = PROMEDIO*calMedias(v,num);
// Lee las ventas y las devuelve for (unsigned i=0;i<num;i++)
// Devuelve también el número de agentes {
void leerVentas(VentasAgentes &v, int &n) double sueldo=SUELDO_FIJO;
{ char respuesta; if (v[i]>=umbral){
bool parar=false; sueldo+=porcentaje(INCENTIVO,v[i]);
n = 0; }
do cout << "El sueldo del agente " << i
{ << " es = "<< sueldo << endl;
cout << "Desea intr. ventas del agente " }
<< n << " ? (S/N)"; }
cin >> respuesta; //--programa principal-----------------------
if (toupper(respuesta) =='S'){ int main()
cout << "Introduce sus ventas: "; {
cin >> v[n]; int numele;
n++; VentasAgentes ventas;
} leerVentas(ventas, numele);
else parar=true; imprimirSueldos(ventas, numele);
}while ((!parar) && (n<NAGENTES)); }
}
12

6
Arrays Multidimensionales:
Concepto y Declaración
• Un array es MULTIDIMENSIONAL si tiene más de una
dimensión.
• Una matriz es un array de 2 dimensiones, es decir un array
unidimensional donde cada elemento es, a su vez, un array
unidimensional.
• Declaración de un tipo Matriz
typedef array<tipo_elemento,NCOLUMNAS> Fila;
typedef array<Fila,NFILAS> Matriz;

• Declaración de una cte/vble de un tipo array


const Matriz m = {……};
int main()
{ …
Matriz Temperaturas;
13

Arrays Multidimensionales:
Inicialización/Acceso
• Inicialización de una matriz => {..,..,..}
─ Todos los valores seguidos (matriz de 2x3)
Matriz m = {1,1,1,2,2,2};
─ Por partes
Matriz m = {{1,1,1},{2,2,2}};
1. La organización: es más fácil de leer.
2. Son útiles para las inicializaciones incompletas.

• Acceso a fila,columna,elemento => [índice]


- Para identificar un elemento de un array multidimensional, se debe
dar un índice para cada dimensión, en el mismo orden que en la
declaración.
- Cada índice se encierra en sus propios corchetes.

14

7
Arrays Multidimensionales:
Inicialización/Acceso
• Acceso a fila,columna,elemento => [índice]
- Para identificar un elemento de un array multidimensional, se debe
dar un índice para cada dimensión, en el mismo orden que en la
declaración.
- Cada índice se encierra en sus propios corchetes.

typedef array<int,10> Fila;


typedef array<Fila,3> Matriz;
m[1][5]

Matriz m;
m[0][8]

m[0][1]
Columna m[1][1] m[2] Fila
m[2][1]
15

Arrays Multidimensionales:
Inicialización/Acceso
• ¿Cómo se ALMACENAN los elementos en MEMORIA?
- Los elementos se almacenan CONTIGUOS en memoria.
//--constantes---------------------------
const unsigned NELEMENTOS = 3;
const unsigned NFILAS = 3;
const unsigned NCOLUMNAS = 5;
//--tipos-------------------------------
typedef array<int,NELEMENTOS> ListaEnteros;
typedef array<int,NCOLUMNAS > Fila;
typedef array<Fila,NFILAS> Matriz;
//-------------------------
int main()
{
ListaEnteros le1;
Matriz mt1;

}

le1

Son 15 enteros
mt1
16

8
Arrays Multidimensionales:
Acceso a los Elementos (por Índices)
• Ejemplo_1: Cargar un array bidimensional con
los números del 1 al 12

#include <array>
const unsigned NFILAS = 3;
const unsigned NCOLUMNAS = 4;
typedef array<int,NCOLUMNAS> Fila;
0 1 2 3
typedef array<Fila,NFILAS> Matriz;
int main() 0 1 2 3 4
{ 1 5 6 7 8
Matriz m;
2 9 10 11 12
for(unsigned f=0;f<NFILAS;f++)
for(unsigned c=0;c<NCOLUMNAS;c++)
m[f][c]=(f*4)+c+1;
. . .
return 0;
}

17

Arrays Multidimensionales:
Acceso a los Elementos (por Índices)
• Ejemplo_2: Programa que muestra los valores
almacenados en un array bidimensional 2 por
3 SALIDA EN PANTALLA
#include <array>
const unsigned NFILAS = 2;
El valor de [0][0] es 1
const unsigned NCOLUMNAS = 3;
typedef array<int,NCOLUMNAS> Fila; El valor de [0][1] es 2
typedef array<Fila,NFILAS> Matriz; El valor de [0][2] es 3
int main() El valor de [1][0] es 4
{
El valor de [1][1] es 5
Matriz m = {{1,2,3},{4,5,6}};
for(unsigned f=0;f<NFILAS;f++) El valor de [1][2] es 6
for(unsigned c=0;c<NCOLUMNAS;c++)
cout << " Valor de [" << f << "]"
<< "[" << c << "] es "
<< m[f][c] << "\n";
return 0;
}
18

9
Arrays Multidimensionales:
Argumentos en Funciones
• Paso de array multidimensional como
parámetro a subprograma
─ Por referencia => parámetros de S o E/S
void leerMatriz (Matiz &m);
─ Por referencia constante => parámetros de E
void escribirMatrizPantalla (const Matriz &m):

• Ejemplo_3:
─ a => elementos de la matriz leída desde el teclado.
─ b => resultado de sumar todos los elementos de la fila.
─ C => resultado de sumar todos los elementos de la colum.

c c c c
b a a a a
b a a a a
b a a a a
19

Arrays Multidimensionales:
Argumentos en Funciones. Ejemplo
//--subalgoritmos----------------------- void escribirMatrizFormato (const Matriz &m)
int sumarFila (const Fila &f) {
{ for (unsigned f=0;f<NFILAS;f++){
int suma = 0; escribirFila(m[f]);
for (unsigned c=0;c<NCOLUMNAS;c++){ cout << "- " << sumarFila (m[f]);
suma+=f[c]; cout << endl;
} }
return suma; cout << "-------------" << endl;
} for (unsigned c=0;c<NCOLUMNAS;c++){
int sumarColumna(const Matriz &m,unsigned c) cout << sumarColumna(m,c)<<" ";
{ }
int suma = 0; cout << endl;
for (unsigned f=0;f<NFILAS;f++){ }
suma+=m[f][c]; void leerMatriz(Matriz &m)
} {
return suma; cout << "Escribe fila a fila "<<endl;
} for (unsigned f=0;f<NFILAS;f++)
void escribirFila (const Fila &fil) for (unsigned c=0;c<NCOLUMNAS;c++)
{ cin >> m[f][c];
for (unsigned c=0;c<NCOLUMNAS;c++){ }
cout << fil[c] << " "; //--programa principal-----------------------
} int main()
} {
Matriz m;
leerMatriz(m);
escribirMatrizFormato(m);
}
20

10
Cadenas de Caracteres: Entrada/Salida

• Una cadena de caracteres se almacena en el tipo de dato


string, que es similar a un array unidimensional de char.
• La librería string contiene funciones para realizar la mayor
parte de las operaciones básicas sobre cadenas.
• Entrada/salida de cadenas (tipo string):
• Salida:
• Se realiza de la misma forma que si fuera un tipo predefinido,
es decir, usando cout << cadena;
• Entrada: tenemos varias opciones
• Usar cin tiene el inconveniente de que se usa el espacio,
tabulador, y Enter como separadores de las cadenas, por lo
que si introducimos una frase, sólo leeríamos la primera
palabra: cin >> cadena;
• Para leer frases (con espacios) usar la función getline, que
nos permite leer una cadena de caracteres hasta un separador
que nosotros indiquemos: string frase;
getline(cin, frase, '\n');
21

Cadenas de Caracteres: Entrada/Salida

int main()
{
string cadena1, cadena2;

cout << "Introduzca la Cadena: Hola Pepe" << endl;


cin >> cadena1; // Sólo lee una palabra: Hola (Pepe queda sin leer)

cin.ignore(100,'\n'); // Por si queda algo en el buffer

cout << "Introduzca de nuevo la Cadena: Hola Pepe" << endl;


getline(cin, cadena2, '\n'); // Ahora lee las dos palabras

cout << "\n- La cadena leida con cin >> : " << cadena1 << endl;
cout << "\n- La cadena leida con getline: " << cadena2 << endl;

return 0;
} NOTA: cin.ignore(n, delim)
Elimina caracteres del canal (o buffer) de entrada.
La extracción acaba cuando se han eliminado ya n
caracteres, o bien nos encontramos con el caracter delim
(que también es eliminado), lo que ocurra primero.
22

11
Cadenas de Caracteres: Entrada/Salida

/* Calcula las veces que aparece el carácter ch en una cadena str */


int main()
{ string str;
char ch;
int veces = 0, i = 0, longitud;

cout << "Escribe el carácter para buscar: ";


cin >> ch; // No lee espacio en blanco -> Para ello ejecutar antes: cin >> noskipws;
cin.ignore(100,'\n'); // Quita el Intro introducido tras el carácter anterior
cout << "Escribe un texto: ";
getline(cin, str, '\n');

longitud = str.length(); // Número de caracteres de str


for(i=0; i<longitud; i++)
if(str[i] == ch) // Compara ch con el carácter en la posición i de str
veces++;

cout << "El número de veces que aparece es: " << veces;
return 0;
}
23

Cadenas de Caracteres

¿Qué hace el siguiente programa?


int main()
{
string nm = "pepe luis";
if (nm <= "lucas"){
nm += " lopez";
}
cout << "Imprimo en pantalla_1: "<< nm << endl;
nm = nm.substr(5,4) + "miguel";
cout << "Imprimo en pantalla_2: "<< nm << endl;
for (unsigned i=0; i<nm.size(); ++i)
{
nm[i]=char (nm[i]+1);
}
cout << "Imprimo en pantalla_3: "<< nm << endl;
cin >> nm;
getline (cin, nm);
cout << "Imprimo en pantalla_4: " <<nm << endl;
return 0;
}
24

12
Cadenas de Caracteres

¿Qué hace el siguiente programa?

cin >> nm; // Lee hasta el primer separador ("juanita")


getline (cin, nm); // Lee hasta el primer retorno carro
cout <<"Imprimo en pantalla_4: " <<nm << endl; (" banana")

25

Cadenas de Caracteres

• Tener en cuenta
• cin deja en el buffer el terminador o separador.
• getline no deja el terminador
• Si tras cin se usa getline, puede perderse la entrada

• ignore
• Elimina el separador => cin.ignore();
• Se le puede indicar un número máximo de caracteres a eliminar,
si antes no encuentra el terminador => cin.ignore(256, '\n');

26

13
Cadenas de Caracteres: Ejemplo

Mostrar cada carácter de una palabra


void escribir (string palabra)
{
unsigned longitud, i;
longitud = palabra.size();
for (i=0; i<longitud; i++){
cout << palabra[i] << ", ";
}
}
int main()
{
string palabra;
cin >> palabra;
escribir (palabra);
return 0;
}

27

Cadenas de Caracteres: Ejemplo

Leer una línea:


// Lee una línea, carácter a carácter
void leerLinea (string &lin)
{
char caracter;
lin.clear(); // Borra el contenido de la cadena dejándola en 0 caracteres
cin >> noskipws >> caracter; // Evita que salte los espacios y el terminador
while (caracter != '\n') // Sin noskipws este bucle sería infinito
{
lin += caracter;
cin >> caracter;
}
}
int main()
{
string linea;
leerLinea(linea);
cout << linea;
return 0;
}
28

14
Cadenas de Caracteres: Ejemplo

Convierte a mayúsculas los caracteres de una palabra


void mayuscula (char &letra)
{
if((letra>='a') && (letra<='z')){
letra = char (unsigned(letra)-unsigned('a')+unsigned('A'));
}
}
void mayusculas (string &palabra)
{
for (unsigned i=0; i<palabra.size(); i++){
mayuscula(palabra[i]);
}
}
int main()
{
string palabra;
cin >> palabra;
mayusculas (palabra);
cout << palabra << endl;
return 0;
} 29

Estructuras: Definición
Una estructura es un grupo de información relacionada que se usa
para almacenar datos acerca de un tema o actividad.
- Las estructuras están divididas en CAMPOS.
- Un campo es una variable de un tipo determinado.

typedef struct {
tipo1 campo1;
tipo2 campo2; Definición de un nuevo tipo
... estructura nombre_tipo
tipoN campoN;
} nombre_tipo;

nombre_tipo variable1, variable2;

Declaración de variables del


nuevo tipo estructura definido
antes: nombre_tipo
30

15
Estructuras: Acceso a los Campos
• Para acceder a cada campo se utiliza el operador punto (.)
• Se pone el nombre de una variable de tipo estructura seguida de un punto y
luego el nombre del campo.

typedef struct {
string titulo; /* título del libro */
string autor; /* autor del libro */
int num; /* número del libro */
} Tlibro;

Tlibro lib; /* variable de tipo struct libro */

lib.titulo /* accede al título */


lib.autor /* accede al autor */
lib.num /* accede al número del libro */
lib.titulo[i] /* i-ésimo carácter del título */
31

Estructuras: Ejemplo

typedef struct {
float coste;
int codigo;
string nombre;
} Tcomponente;
int main() {
Tcomponente c;
c.coste = 1.5;
c.codigo = 32201;
c.nombre = "resistencia";
. . . .
cout << "Nombre " << c.nombre
<< ", código " << c.codigo
<< ", coste " << c.coste;
return 0;
}
32

16
Estructuras: Inicialización y Asignación

• Los campos de una estructura se pueden inicializar a la vez que se


declara la variable (igual que los arrays):
Tlibro l ={"Rebeca", "D. du Maurier", 124};

• Se puede asignar una estructura a otra utilizando el operador de


asignación =
typedef struct {
string nombre;
string direc;
int edad;
float altura, peso;
} Tpersona;

Tpersona p1, p2;


//. . .
p1 = p2;
• La operación de comparación == no está permitida.
33

Estructuras: Ejemplo
Escribe cuántos números son mayores que un valor
typedef array<int, 20> Telementos;
typedef struct {
int n;
Telementos a;
} Tlista;

int main() { // Inicio main


int i, num=0; cout << "Valor mínimo para filtrar la lista: ";
float valor; cin >> valor;
Tlista lista;
cout << " ¿Cuántos elementos for (i=0;i<lista.n;i++)
tiene la lista? "; {
cin >> lista.n; if (lista.a[i] >= valor)
for (i=0;i<lista.n;i++) num++;
{ }
cout << "Valor " << i+1 << " : "; cout << "Hay " << num;
cin >> lista.a[i]; cout << " números mayores que " << valor;
} return 0;
} // Fin main

34

17
Estructuras en Funciones:
Paso de Estructuras por Valor
• Funciona como el paso por valor de cualquier otra variable:
• A la función se le pasa una COPIA de la estructura.
• La función sólo puede modificar la copia y no la variable estructura original.
• Cuando acaba la función los cambios NO se reflejan en la estructura
original.

// Escribir los datos de una persona x


void VisualizarDatos(Tpersona x) {
cout << "- Nombre: " << x.nombre << endl;
cout << "- Dirección : " << x.direc << endl;
cout << "- La edad es: " << x.edad << endl;
cout << "- La altura es: " << x.altura << endl;
cout << "- El peso es: " << x.peso << endl;
}
int main() {
Tpersona p1;
...
VisualizarDatos(p1); // se pasa una copia de p1
}
35

Funciones que Devuelven Estructuras


// Leer los datos de una persona y devolverlos
Tpersona LeerPersona() {
Tpersona temp; // estructura local

cout << "Nombre? ";


getline(cin,temp.nombre,'\n');
cout << "Direccion? ";
getline(cin,temp.direc,'\n');
cout << "Edad? ";
int main() {
cin >> temp.edad;
Tpersona p1;
cout << "Altura? ";
// Guarda la estructura
cin >> temp.altura;
// devuelta por la función:
cout << "Peso? ";
p1=LeerPersona();
cin >> temp.peso;

// Devuelve una copia de temp // Visualiza el contenido


return temp; // de la estructura p1:
} VisualizarDatos(p1);
}
36

18
Estructuras en Funciones: Paso de
Estructuras por Referencia (en C++)
• Se pone un ‘&’ detrás del nombre del tipo de la estructura en la
definición de la función.
• Si varía el valor de la variable en la función, también cambia la variable
que corresponda en la llamada.

// Leer los datos de una persona y devolverlos en p


void LeerPersona2(Tpersona& p) {
cout << "Datos? "; // Hay un paso de parámetros
getline(cin,p.nombre,'\n');// por referencia
getline(cin,p.direc,'\n');
cin >> p.edad;
cin >> p.altura;
cin >> p.peso;
}
void main() {
Tpersona p1;
LeerPersona2(p1); // La variable p1 CAMBIA
VisualizarDatos(p1);
} 37

Arrays de Estructuras

• Se pueden construir arrays en los que cada elemento sea una


estructura.
typedef struct {
double real, imag;
} Tcomplex;
typedef array<TComplex,10> TListaComplejos;
TListaComplejos x; /* Array unidimensional
de 10 elementos, cada uno de ellos es una
estructura complex */
Acceso a cada campo:
x[0].real = 2.5
x[5].imag = 3.2;
0 1 2 3 4 5 6 7 8 9
x 2.5
3.2
38

19
Arrays de Estructuras: Ejemplo
typedef struct {
char nombre[30];
float notaT,notaP;
} TAlumno;

typedef array<TAlumno,50> TListaAlumnos;


int main() { // Listado de aprobados y suspensos
TListaAlumnos A; // Array de alumnos
int i, N;
cout<< "Cuántos alumnos? ";
cin >> N;
.......... // Dar valores al array
for (i=0; i<N; i++)
{
cout << A[i].nombre << "\t";
if ((0.6*A[i].notaT+0.4*A[i].notaP)<5.0)
cout << "Suspenso.\n";
else
cout << "Aprobado.\n";
}
} 39

Algoritmos Básicos de BÚSQUEDA


• Objetivo: Buscar un elemento determinado en una lista de
objetos.

• Características: Para cualquier tipo de datos.


– Para cada tipo de datos deberá usarse un comparador
adecuado.

• Supondremos:
– Número de Elementos: N
– Tipo de los Elementos: cualquiera
– Array (vector) con los N Elementos: V
Desde el Elemento V[0] hasta el V[N-1]
– Elemento a buscar: x
40

20
Búsqueda Secuencial o Lineal

• Se usa cuando no existe información adicional sobre los


datos.
• Se hace un recorrido secuencial a través del array hasta
que se encuentra el elemento, o bien hasta que se llega al
final (si el elemento no se ha encontrado):
ind=0;
while(ind<N && V[ind]!=x) {
ind++;
}
if (ind>=N)
puts("No encontrado.");
else
cout << "Encontrado en la posición: "
<< ind << endl;
41

Algoritmos Simples de ORDENACIÓN

• Objetivo: Ordenar una lista de objetos de acuerdo a un criterio


Debe existir una Relación de Orden “<” entre los objetos.
• Características: Para cualquier tipo de datos y tanto para
ordenación ascendente como descendente.
• Supondremos:
– Número de Elementos: N
– Tipo de los Elementos: int
– Array (vector) con los N Elementos: V
Desde el Elemento V[0] hasta el V[N-1]
– Función para Intercambiar Elementos: Swap()
void Swap (int& x, int& y){
int temp=x;
x=y;
y=temp;
} 42

21
Ordenación por “Selección”

• En la iteración de la posición i se supone que


están ordenados las posiciones hasta i—1.
• Para cada posición i: Seleccionar el elemento
más pequeño (en la posición PosMin) entre las
posiciones i y N—1, y se intercambia con el
elemento que está en la posición i.

0 ... i ... PosMin ... N-1

43

Ordenación por “Selección”


/* N-1 iteraciones: Desde i=0 hasta i=N-2 */
for (i=0; i<N-1; i++){
PosMin = i; /* Posición del elemento mínimo */

/* Buscar posición del elemento mínimo entre


las posiciones i+1 y N-1: PosMin */
for (j=i+1; j<N; j++)
if (V[j] < V[PosMin])
PosMin = j;

/* Intercambiar el elemento mínimo con el


situado en la posición i (pueden
coincidir) */
Swap(V[PosMin], V[i]);
}
44

22
Ordenación por
“Selección” N=6 Elementos
7 3 5 9 4 7
for (i=0; i<N-1; i++)
i=0 3 7 5 9 4 7
{
PosMin = i;
i=1 3 4 5 9 7 7
for (j=i+1; j<N; j++)
if (V[j]<V[PosMin])
i=2 3 4 5 9 7 7
PosMin = j;

Swap(V[PosMin],V[i]); i=3 3 4 5 7 9 7
}

i=4 3 4 5 7 7 9
45

23