Tema 8: Tipos de Datos Estructurados I Programación de Computadores (IWI-131) Tema 8: Tipos de Datos Estructurados I Luis Pizarro Q. Luis.Pizarro@inf.utfsm.cl www.labmc.inf.utfsm.cl/~lpizarro/IWI-131

Arreglos Unidimensionales Un arreglo es una estructura de datos en la que se almacena una colección de datos del mismo tipo. Ejemplo, el arreglo A contiene números enteros: 34 56 12 5 28 44 9 67 19 21 54 85 A 1 2 3 4 5 6 7 8 9 10 11 12 posición A[1] := 34 A[2] := 56 A[3] := 12 ....... A[12]: = 85 Primer elemento del arreglo A. Segundo elemento del arreglo A. Doceavo elemento del arreglo A. Tercer elemento del arreglo A. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Declaración TYPE nombre = ARRAY[1..n] OF TIPO_DATO Ejemplo: TYPE vector = ARRAY[1..100] OF INTEGER; semaforo = (rojo, amarillo, verde); trafico = ARRAY[1..30] OF semaforo; VAR X: vector; Asignación X[i] := dato; Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ejemplo PROGRAM arreglos; CONST N = 10; TYPE vector = ARRAY[1..N] OF CHAR; VAR A: vector; i: INTEGER; BEGIN FOR i := 1 TO N DO WRITELN(‘Ingrese caracter ’,i, ‘ : ’); READLN(A[i]) END END. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ejercicio Escriba un programa que permita encontrar la primera posición de un carácter en una frase contenida en un arreglo. 1 2 3 4 5 6 7 8 9 10 11 12 A c o m p u t a d o r Si queremos obtener la posición de la letra ‘t’, el programa debe entregar el número 6. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Solución PROGRAM buscar_caracter; CONST Largo = 20; TYPE vector = ARRAY[1..Largo] OF CHAR; VAR X: vector; ch: CHAR; i, pos: INTEGER; FUNCTION buscar(A: vector; dato: CHAR): INTEGER; i: INTEGER; {variable local} BEGIN i := 1; WHILE (i <= Largo) AND (A[i] <> dato) DO i := i + 1; buscar := i END; WRITELN(‘Ingrese frase: ’); FOR i := 1 TO Largo DO READ(X[i]); WRITELN(‘Ingrese caracter a buscar: ’); READ(ch); pos := buscar(X, ch); IF pos > Largo THEN WRITELN(‘No se encuentra el caracter’) ELSE WRITELN(‘El caracter ’,ch,’ está en la posición ’, pos) END. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ejercicio: Buscar el mínimo valor y su posición en un arreglo de enteros de largo 10. PROGRAM minimo; CONST Largo = 10; TYPE arreglo = ARRAY[1..Largo] OF INTEGER; VAR A: arreglo; i,pos,min: INTEGER; BEGIN WRITELN(‘Ingrese ’, Largo, ’ números: ’); FOR i := 1 TO Largo DO READLN(A[i]); min := A[1]; {el primer valor ingresado} pos := 1; {se guarda la posición del menor valor} FOR i := 2 TO Largo DO IF A[i] < min THEN min := A[i]; pos := i END; WRITELN(‘El mínimo es ’, min, ‘ y está en la posición ’, pos) END. Luis Pizarro Q. ©2003

Arreglos Unidimensionales STRING Es una sucesión de 1 ó más caracteres. Declaración VAR nombre: STRING[tamaño]; El tamaño máximo es de 255 caracteres. Uso READLN(nombre); o también nombre := ‘Programación de Computadores’; Si se ubiera definido como ARRAY habría que leer caracter a caracter. Pero al ser del tipo STRING esto es posible. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Largo de un STRING largo := LENGTH(nombre_del_string); Asignación str1 := str2 , si tienen el mismo tamaño no hay problema. si str1 > str2 , se almacena str2 en str1 y toma el largo de str2. si str1 < str2 , str2 es truncado hasta el tamaño de str1. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ejercicio: Escriba un programa que guarde una frase en un STRING de largo máximo y convierta las minúsculas en mayúsculas. PROGRAM minusculas_en_mayusculas; CONST Largo = 255; VAR S: STRING[Largo]; L,i: INTEGER; BEGIN WRITE('Ingrese frase: '); READLN(S); L:=LENGTH(S); FOR i:=1 TO L DO IF (S[i] >= 'a') AND (S[i] <= 'z') THEN S[i] := CHR(ORD(S[i])-32); WRITELN(S) END. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ejercicio: Calcular el promedio en un arreglo de largo 100, el cual puede no estar lleno completamente. PROGRAM Calcular_Promedio; CONST L = 255; TYPE vector = ARRAY[1..L] OF INTEGER; VAR A: vector; n: INTEGER; respuesta: CHAR; BEGIN n := 0; REPEAT n := n + 1; WRITE(‘Ingrese número: ’); READLN(A[n]); WRITE(‘Desea ingresar otro número (s/n): ’); READLN(respuesta); UNTIL (respuesta = ‘n’) OR (n = L); WRITELN(‘El promedio es ’, Promedio(A,n)) END. FUNCTION Promedio(X: vector, k: INTEGER): REAL; VAR suma,i: INTEGER; prom: REAL; BEGIN suma := 0; FOR i := 1 TO k DO suma := suma + X[i]; prom := suma / k; Promedio := prom END; Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ordenamiento Burbuja Consiste en ir comparando los casilleros con el de abajo, de manera de ir dejando los menores o más livianos arriba y los mayores o más pesados abajo. Aquí se encontró el número mayor. 15 8 4 50 3 8 15 4 50 3 8 4 15 50 3 8 4 15 50 3 8 4 15 3 50 Aquí se encontró el segundo número mayor. 8 4 15 3 50 4 8 15 3 50 4 8 15 3 50 4 8 3 15 50 Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ordenamiento Burbuja (continuación) Aquí se encontró el tercer número mayor. 4 8 3 15 50 4 8 3 15 50 4 3 8 15 50 Aquí se tiene el arreglo ordenado. 4 3 8 15 50 3 4 8 15 50 Luis Pizarro Q. ©2003

Arreglos Unidimensionales Ordenamiento Burbuja Algoritmo PROGRAM Ordenamiento_Burbuja; CONST Largo = 5; VAR A: ARRAY[1..Largo] OF INTEGER; i,j: INTEGER; BEGIN FOR i:=1 TO Largo DO WRITE(‘Ingrese elemento ’,i,‘ : ’); READLN(A[i]) END; FOR i:=Largo DOWNTO 2 DO FOR j:=1 TO i-1 DO IF A[j] > A[j+1] THEN Intercambiar(A[j],A[j+1]); WRITELNA(A[i]) END. i: indica la cantidad de casillas a comparar en cada vuelta. j: indica la cantidad de compa- raciones que se hacen por vuelta. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Búsqueda Existen numerosos métodos para buscar un dato entre los elementos de un arreglo, algunos más rápidos que otros. Por ejemplo, el método “carretero” consiste en comparar uno a uno el dato buscado con cada elemento del arreglo. Escriba un programa que busque la posición en la que se encuentra el entero 15, dentro de un arreglo que contiene (ordenadamente) los números: 3,6,7,10,15,17,18 (7 en total) (solución en diapositiva siguiente) Luis Pizarro Q. ©2003

Arreglos Unidimensionales Búsqueda ...solución PROGRAM busqueda_carretera; CONST Largo = 15; TYPE vector = ARRAY[1..Largo] OF INTEGER; VAR X: vector; i, pos, num: INTEGER; FUNCTION buscar(A: vector; dato: INTEGER): INTEGER; VAR j: INTEGER; BEGIN j := 1; WHILE (j <= Largo) AND (A[j] <> dato) DO j := j + 1; buscar := j END; FOR i := 1 TO Largo DO WRITE(‘Ingrese número: ’); READLN(X[i]) END WRITE(‘Ingrese número a buscar: ’); READLN(num); pos := buscar(X, num); IF pos > Largo THEN WRITELN(‘No se encuentra el número’) ELSE WRITELN(‘El número ’,num,’ está en la posición ’, pos) END. Función que implementa la búsqueda carretera. Luis Pizarro Q. ©2003

Arreglos Unidimensionales Búsqueda Binaria Este algoritmo permite buscar un dato entre los elementos de un arreglo considerablemente más rápido que la búsqueda carretera. Se basa en subdividir progresivamente el arreglo en 2 partes, buscando en aquella donde se encuentre el número. El arreglo donde se buscará debe estar ordenado. Ejemplo: Si A[Medio] = 15, entonces Encontrado = TRUE Si A[Medio] < 15, entonces Primero = Medio + 1 Si A[Medio] > 15, entonces Ultimo = Medio - 1 3 6 7 10 15 17 18 primero último A 3 6 7 10 15 17 18 primero último A 3 6 7 10 15 17 18 primero, ultimo, medio A medio Encontrado = TRUE medio Luis Pizarro Q. ©2003

Arreglos Unidimensionales Búsqueda Binaria ...solución Escribiremos sólo la función busqueda_binaria. FUNCTION busqueda_binaria(A: vector; dato: INTEGER): INTEGER; VAR primero, ultimo, medio: INTEGER; encontrado: BOOLEAN; BEGIN primero := 1; ultimo := Largo; encontrado := FALSE; WHILE (primero <= ultimo) AND NOT(encontrado) DO medio := (primero + ultimo) DIV 2; IF A[medio] = dato THEN encontrado := TRUE ELSE IF A[medio] < dato THEN primero := medio + 1 ELSE ultimo := medio - 1 END; IF encontrado THEN busqueda_binaria := medio ELSE busqueda_binaria = -1 Luis Pizarro Q. ©2003

Arreglos Bidimensionales Los arreglos bidimensionales se caracterizan por tener dos índices, representando una matriz. 1 2 N M Declaración: TYPE matriz = ARRAY[1..N,1..M] OF REAL; VAR A: matriz; Asignación: A[i,j] := valor; Luis Pizarro Q. ©2003

Arreglos Bidimensionales Recorrido: el recorrido se efectúa con 2 FOR anidados, y se puede hacer de dos maneras. 1) FOR i := 1 TO N FOR j := 1 TO M READLN(A[i,j]) x 1 2 N M i j Recorrido hacia el lado, se va llenando el arreglo por filas. 2) FOR j := 1 TO M FOR i := 1 TO N READLN(A[i,j]) x 1 2 N M i j Recorrido hacia abajo, se va llenando el arreglo por columnas. Luis Pizarro Q. ©2003

Tarea Nº 2 1. Modificar el algoritmo de ordenamiento burbuja para ordenar los elementos en forma descendente. 2. Se tienen 2 arreglos unidimensionales de tamaño N, en nombre[i] y promedio[i] se almacena el nombre y el promedio del alumno i, respectivamente. Realizar un programa que liste los 10 alumnos con menor promedio. Ayuda, considere la variable “nombre” del tipo: tipo_nombre = array[1..N] OF STRING[30] Luis Pizarro Q. ©2003

Tarea Nº 2 3. Se tienen dos arreglos A y B con números enteros, de largo N y M respectivamente, los cuales están ordenados ascendentemente. Realizar un procedimiento que mezcle los dos arreglos en uno nuevo, de manera que éste también se encuentre ordenado. 4. Usando recurrencia, calcular el i-ésimo elemento en la serie: Luis Pizarro Q. ©2003

Tarea Nº 2 5. Se desea controlar los resultados de los alumnos en las diferentes asignaturas. Escriba un programa que lea las notas obtenidas en las distintas asignaturas. Además se debe visualizar en pantalla el nombre, calificaciones, promedio por asignatura y general de cada estudiante. Asuma que en el curso hay 50 alumnos, y que cada uno de ellos tiene 6 asignaturas. ENTREGA: Miércoles 30 de Abril. Luis Pizarro Q. ©2003

Tema 8: Tipos de Datos Estructurados I Programación de Computadores (IWI-131) Tema 8: Tipos de Datos Estructurados I Luis Pizarro Q. Luis.Pizarro@inf.utfsm.cl www.labmc.inf.utfsm.cl/~lpizarro/IWI-131