Académique Documents
Professionnel Documents
Culture Documents
Material de Estudio
Tema: ESTRUCTURAS DE DATOS ESTATICAS: VECTORES
Profesor : Braulio Barrios - Marzo de 2009
Normalmente, utilizamos VARIABLES para almacenar (en memoria RAM) la información que un programa
procesa. Por ejemplo: El CODIGO de un alumno, el NOMBRE, etc. y de acuerdo con esto podemos escribir un
algoritmo que LEA y muestre el código y nombre de un alumno, así:
ALUMNOS
ESCRIBA (“ ***** Captura de datos del Estudiante ***** ”)
Observe bien el anterior algoritmo, fíjese que UNICAMENTE podemos introducir y mostrar la información de UN alumno a la vez.
Pero la realidad es otra, es decir, se requiere procesar la información de VARIOS alumnos, por ejemplo, en el
curso de estructuras de datos hay matriculados aproximadamente 15 estudiantes en cada grupo. Que pasaría si
quisiéramos introducir los CODIGOS y NOMBRES de TODOS los alumnos?. Podríamos pensar en re-escribir el
anterior algoritmo utilizando entonces un CICLO REPETITIVO (Remítase a la lección: “FUNDAMENTOS DE
ALGORITMOS Y PROGRAMACIÓN ESTRUCTURADA” ), por ejemplo, un ciclo PARA (Hacer Hasta) así:
ALUMNOS_VERSION2.0
FPARA
Este algoritmo evidentemente procesa la información de los 15 alumnos pero tiene una falla, y es que al final del
proceso ( por fuera del ciclo PARA) no podríamos hacer un informe que incluya los CODIGOS y NOMBRES de
TODOS los alumnos cuya información se procesó, ya que cuando digitemos el CODIGO y el NOMBRE del segundo
alumno entonces esta nueva información SOBREESCRIBE a la primera, y al escribir la del tercer alumno se
SOBREESCRIBE la del segundo y así sucesivamente, es decir, se BORRA el CODIGO y el NOMBRE del anterior
estudiante; La razón: Dos datos NO pueden convivir simultáneamente en la misma posición de memoria, es decir,
NO podemos resolver el problema con el enfoque que hemos planteado. Entonces, la solución es: NO UTILIZAR
VARIABLES SIMPLES, sino una ESTRUCTURA DE DATOS para cada dato del alumno, esa ESTRUCTURA DE DATOS es un
VECTOR
Una estructura de datos es una organización de información dispuestos de manera lógica y coherente, de tal
manera que se facilite el acceso a los datos que contiene.
Según el dispositivo de almacenamiento, las Estructuras de Datos se clasifican en: ESTRUCTURAS EN MEMORIA
PRINCIPAL y ESTRUCTURAS EN DISCO DURO. Por su parte, las Estructuras en Memoria RAM pueden clasificarse
en dos grupos: ESTATICAS y DINAMICAS.
El término ESTATICA hace referencia a que una vez se halla definido el tamaño de la estructura de datos este NO
puede ser cambiado mientras se está ejecutando el programa (No se puede Ampliar Ni tampoco Reducir ).
VECTOR DE DATOS: Es una estructura estática que consiste en un conjunto de elementos que satisfacen lo
siguiente:
QUE ES DIMENSIONAR UN VECTOR ? es una acción que consiste en RESERVAR el tamaño que el vector ocupará
en memoria, es decir, cual es la cantidad MAXIMA de elementos que tendrá el vector. Esta cantidad MAXIMA de
elementos la deducimos según el problema que estemos resolviendo; por ejemplo: Si deseo almacenar los
CODIGOS de todos los alumnos de la clase y son aproximadamente 15 alumnos entonces lo aconsejable
es reservar en memoria (Dimensionar) espacio para un poco mas de esos elementos, digamos 20, es
decir, un poco por encima de la cantidad de alumnos que hay pero sin exceso. Para ello, simplemente
escribiremos en los algoritmos la siguiente sentencia:
TODOS LOS ELEMENTOS SON DE IGUAL TIPO: Es algo obvio, puesto que cada TIPO de datos ocupa, como
hemos dicho en clase, cierto numero de bytes, entonces, NO ES POSIBLE mezclar distintos tipos de datos en un
vector: O todos son enteros cortos ó todos son caracteres, ó todos son enteros largos, ó todos son decimales, etc.
LOS ELEMENTOS SE ALMACENAN EN POSICIONES CONSECUTIVAS DE RAM: Puesto que el sistema hace la
reserva de memoria para el vector o la matriz como un solo bloque de bytes, entonces los elementos se guardan
en el vector o matriz uno a continuación de otro.
Var
Vector : Array [1 .. Max] OF Tipo_dato ;
Donde Tipo_dato corresponde a uno de los definidos en PASCAL ( integer, char, string, double),
MAX es la cantidad máxima de datos que se almacenaran en el vector (Obligatoriamente debe ser EL
NOMBRE DE UNA CONSTANTE o en su defecto un VALOR).
Observe que el vector NOMBRES se está declarando de tamaño 20 (máximo almacenará 20 nombres)
y va acompañado de un corchete y un tamaño de 80; esto significa que, a su vez, cada nombre tendrá
Máximo 80 caracteres.
CODIGOS NOMBRES
1 2000015 1 MATEO BARRIOS
2000
2
2000020 2 ANA LUISA GONZALEZ
3 2000032 3
LINA PAOLA OÑATE.
. .
. .
20 20
3
LLENAR_DATOS
FIN LLENAR_DATOS
Podemos también utilizar otra estructura repetitiva y otro estilo de captura de información que NO
implique conocer de antemano cuantos elementos se introducirán al vector sino que vamos validando
uno a uno la cantidad de datos que se van introduciendo, con lo cual tendremos otra VERSION del
mismo algoritmo, como se ilustra a continuación.
LLENAR_DATOS(2.0)
NEL 0 ; Mas ’S’
MQ (Mas = ‘S’ ) and (NEL <= 20)
ESCRIBA (“ **** Captura de datos del Estudiante **** ” )
NEL NEL + 1
ESCRIBA (“ Digite Código del Alumno “); Lea ( CODIGO [NEL] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL] )
ESCRIBA (“ Desea seguir Introduciendo Información de Alumnos ? “ ); Lea(MAS)
FIN MQ
SI (NEL > 20) Ent
ESCRIBA (“ ERROR, Ya los vectores están llenos, no caben mas elementos …… “)
SINO
ESCRIBA (“ OK. Se capturaron los datos de los alumnos correctamente …. “ )
FIN SI
FIN LLENAR_DATOS2.0
LLENAR_DATOS(3.0)
NEL 1 ;
REPITA (Mas = ‘S’ ) and (NEL <= 20)
ESCRIBA ( “ **** Captura de datos del Estudiante ***** ” )
ESCRIBA (“ Digite Código del Alumno “); Lea( CODIGO [NEL] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL] )
NEL NEL + 1
FIN LLENAR_DATOS3.0
4
Ahora bien, como hemos notado, por lo general las tareas sobre un vector requieren de un ciclo
repetitivo que vaya desde 1 hasta NEL para ir procesando los datos del vector. Así, por ejemplo, si nos
piden un INFORME de alumnos que incluya CODIGO y NOMBRE de estos, podemos recorrer los dos
vectores e ir escribiendo en pantalla los datos de cada posición de cada vector, así:
INFORME_DE_ALUMNOS
FIN LLENAR_DATOS
Para AGREGAR un nuevo alumno a estos vectores se deben seguir normalmente estos pasos:
1. VERIFICAR SI HAY AUN ESPACIO EN EL VECTOR (QUE NEL NO SEA MAYOR QUE 20)
2. SI HAY ESPACIO ENTONCES LEER LOS DATOS DEL ALUMNO (CODIGO, NOMBRE, ETC)
Y ALMACENARLOS EN LA POSICIÓN NEL+1 DE CADA VECTOR Y LUEGO SUMAR 1 A NEL
PARA INDICAR QUE YA HAY UN ELEMENTO MAS EN LOS VECTORES
3. SI NO HAY ESPACIO ENTONCES MOSTRAR UN MENSAJE INDICANDO ESTO
AGREGAR_DATOS
Mas ’S’
MQ (Mas = ‘S’ ) AND (NEL < 20)
ESCRIBA (“ **** Agrega datos del Estudiante **** ” )
SI NEL < 20 ENT
ESCRIBA (“ Digite Código del Alumno “); Lea ( CODIGO [NEL+1] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL+1] )
NEL NEL + 1
SINO
ESCRIBA (“ Los vectores están llenos, No se admiten mas alumnos …. “ );
FSI
FIN AGREGAR_DATOS
REPITA
Para CONSULTAR la información de un alumno de estos vectores se deben seguir normalmente estos
pasos:
CONSULTAR_DATOS
REPITA
SI CC = CODIGOS [ I ] ENT
SI Encontro = ‘ N ’ Ent
FIN CONSULTAR_DATOS
Ahora, si NO deseamos recorrer completamente el vector sino que estamos interesados en que una vez
que lo encuentre lo muestre y termine la búsqueda (Por ejemplo, si estamos seguros de que el dato NO
se repite en el vector), entonces podemos escribir otra versión de este algoritmo que INTERRUMPA el
ciclo repetitivo en cuanto encuentre el elemento que se busca en el vector.
REPITA
Encontro ‘ N ’ ; I 1
SI CC = CODIGOS [ I ] ENT
SINO
I I +1
FSI
FIN MQ
SI Encontro = ‘ N ’ Ent
Para BORRAR un alumno de estos vectores se deben seguir normalmente estos pasos:
Mas ‘S’
MQ (Mas = ‘ S ’ ) Haga
SI CB = CODIGOS [ I ] Entonces
Pos I ; Encontro ‘ S ’
ESCRIBA ( “ Está seguro de Retirar este Alumno de la Clase ?? [ S/N ] ……..” ); LEA ( seguro)
SI Seguro = ‘ S ’ Entonces
CODIGOS [ I -1 ] CODIGOS [ I ]
FPARA
FSI
FSI
SINO
I I +1
FSI
FIN MQ
SI Encontro = ‘ N ’ Ent
¿Acepta usted el reto de codificar ambas versiones, ejecutarlas y comparar los resultados en
cuanto a eficiencia de ambos algoritmos?
Nota: Para comparar los programas resultantes de la codificación de ambos algoritmos debe
basarse en un mismo conjunto de datos, de lo contrario no sería correcto el análisis.
8
Mas ‘S’
MQ (Mas = ‘ S ’ ) Haga
SI CB = CODIGOS [ I ] Entonces
Pos I ; Encontro ‘ S ’
SINO
II+1
FSI
FIN MQ
SI Encontro = ‘ N ’ Ent
SI Seguro = ‘ S ’ Entonces
CODIGOS [ I -1 ] CODIGOS [ I ]
FPARA
FSI
FSI
FSI
Para Actualizar (MODIFICAR) los datos de un alumno de estos vectores se deben seguir normalmente
estos pasos:
POR SUPUESTO QUE HAY MUCHAS MAS TAREAS QUE PODEMOS DESARROLLAR SOBRE
ESTE PAR DE VECTORES, pero vamos a dejarlo hasta aquí.
9
Ahora REPASEMOS como es que se puede integrar e un solo programa varias
subrutinas y enlazarlas mediante un programa principal.
SUBRUTINA LLENAR_DATOS
FIN LLENAR_DATOS
SUBRUTINA INFORME
FIN INFORME
SUBRUTINA CONSULTA_ALUMNO
FIN CONSULTA
SUBRUTINA AGREGAR_ALUMNO
FIN AGREGAR_ALUMNO
SUBRUTINA ACTUALIZAR_DATOS
FIN ACTUALIZAR
SUBRUTINA BORRAR_DATOS
FIN BORRAR_DATOS
PROGRAMA PRINCIPAL
REPITA
ESCRIBA(“ #### GESTION INFORMACION DE ALUMNOS #### “)
ESCRIBA(“ MENU PRINCIPAL “)
ESCRIBA(“ 1.- CAPTURA DATOS DE ALUMNOS “)
ESCRIBA(“ 2.- INFORME DE ALUMNOS “)
ESCRIBA(“ 3.- AGREGAR DATOS DE ALUMNOS “)
ESCRIBA(“ 4.- CONSULTAR INFO. DE ALUMNOS “)
ESCRIBA(“ 5.- ACTUALIZAR DATOS DE ALUMNOS “)
ESCRIBA(“ 6.- BORRAR DATOS DE ALUMNOS “)
ESCRIBA(“ 7.- TERMINAR “)
PROGRAM xxxxx;
USES
Wincrt;
CONST
VAR
BEGIN (* Inicio del Programa Principal *)
⇒ PROCEDIMIENTOS : Son módulos del programa que pueden tener su propio conjunto
de variables (e denominan variables LOCALES) y que tienen la particularidad de NO devolver
ningún resultado a quien los invoca. Para escribir esta clase de subrutinas utilizamos la
siguiente sintaxis:
PROCEDURE Nombre_de_procedimiento;
Var
Xxx;
Xxx;
Begin
Sentencia;
Sentencia;
.
.
End; (* fin del procedimiento *)
⇒ FUNCIONES : Son módulos del programa que pueden tener su propio conjunto de
variables (e denominan variables LOCALES) y que tienen la particularidad de devolver
resultados a quien los invoca. Para escribir esta clase de subrutinas utilizamos la siguiente
sintaxis:
Pues bien, según lo anterior, utilizando PROCEDURES, la codificación del programa fuente en
PASCAL para implementar la solución algorítmica de la página 9 de este documento sería la
siguiente:
11
PROGRAM xxxxx;
USES
Wincrt;
CONST
VAR
CODIGOS : ARRAY [1..20] OF Longint;
NOMBRES : ARRAY [1..20] OF String[60];
NEL : INTEGER;
PROCEDURE LLENAR_DATOS;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure LLENAR_DATOS *)
PROCEDURE INFORME;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del INFORME *)
PROCEDURE AGREGAR_ALUMNO;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure AGREGAR_ALUMNO *)
PROCEDURE CONSULTAR_ALUMNO;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure CONSULTAR_ALUMNO *)
PROCEDURE ACTUALIZAR_DATOS;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure ACTUALIZAR_DATOS *)
PROCEDURE BORRAR_DATOS;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure BORRAR_DATOS *)
.
END (* FIN DEL PROGRAMA PRINCIPAL *)
REPEAT
CLRSRC;
WRITELN(‘ #### GESTION INFORMACION DE ALUMNOS #### ‘)
WRITELN (‘ MENU PRINCIPAL ‘)
WRITELN (‘ 1.- CAPTURA DATOS DE ALUMNOS ‘)
WRITELN (‘ 2.- INFORME DE ALUMNOS ‘)
WRITELN (‘ 3.- AGREGAR DATOS DE ALUMNOS ‘)
WRITELN (‘ 4.- CONSULTAR INFO. DE ALUMNOS ‘)
WRITELN (‘ 5.- ACTUALIZAR DATOS DE ALUMNOS ‘)
WRITELN (‘ 6.- BORRAR DATOS DE ALUMNOS ‘)
WRITELN (‘ 7.- TERMINAR ‘)
WRITELN (‘ DIGITE OPCIÓN >>>>>> ‘); READLN (OP)
CASE OP OF
1 : LLENAR_DATOS;
2 : INFORME;
3 : AGREGAR_ALUMNO;
4 : CONSULTAR_ALUMNO;
5 : ACTUALIZAR_DATOS;
6 : BORRAR_DATOS
7 : BEGIN
CLRSCR; WRITELN (‘ fin del programa … Pulse ENTER ‘); READKEY;
END;
ELSE
BEGIN
CLRSCR; WRITELN (‘ ERROR en la opción, revise … Pulse ENTER ‘); READKEY;
END;
END; (* Fin del CASE, observe que el Case NO tiene BEGIN …. *)