Apunte

Introduccin a la Programacin
Aristides Dasso Ana Funes
otas de clase
para el curso
Programacin I
Licenciatura y Profesorado en Ciencias de la Computacin Tcnico Universitario en Web
rea de Programacin y Metodologas de Desarrollo del Software Departamento de Informtica Facultad de Ciencias Fsico-Matemticas y Naturales Universidad Nacional de San Luis Argentina 2011
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase
Tabla de Contenido
Tabla de Contenido
I TRODUCCI .........................................................................................................................1 Consideraciones generales ...........................................................................................................1 CAPTULO 1 LAS COMPUTADORAS ..................................................................................2 1.1 Introduccin .........................................................................................................................2 1.2 Las partes de una computadora ...........................................................................................3 Introduccin.............................................................................................................................3 Las partes internas ..................................................................................................................3 Las partes externas ..................................................................................................................6 1.3 La informacin dentro de la computadora .........................................................................11 1.4 El funcionamiento..............................................................................................................13 1.5 El sistema operativo...........................................................................................................14 CAPTULO 2 LGICA ...........................................................................................................16 2.1 Introduccin .......................................................................................................................16 2.2 Proposiciones .....................................................................................................................16 2.3 Operadores, conectivas o funtores .....................................................................................17 Conjuncin.............................................................................................................................18 Disyuncin .............................................................................................................................19 Condicional o implicacin.....................................................................................................20 Bicondicional o equivalencia ................................................................................................21 egacin ................................................................................................................................21 2.4 Equivalencias lgicas ........................................................................................................21 CAPTULO 3 PROGRAMAR ................................................................................................23 3.1 Introduccin .......................................................................................................................23 3.2 Programacin de computadoras.........................................................................................25 3.3 Programacin y resolucin de problemas ..........................................................................25 3.4 El proceso de resolucin de problemas .............................................................................26 Introduccin...........................................................................................................................26 Etapas de la resolucin de problemas ...................................................................................28 3.5 Los paradigmas de la programacin ..................................................................................29 CAPTULO 4 PROGRAMACI IMPERATIVA .............................................................30 4.1 Introduccin .......................................................................................................................30 Las etapas en la construccin de un programa .....................................................................30 4.2 Definicin de los lenguajes de programacin ....................................................................31 Metalenguaje B F .................................................................................................................31 4.3 La estructura general de un programa en Pascal ...............................................................33 4.4 Programacin y datos ........................................................................................................34 4.5 Tipos de datos ....................................................................................................................35 Tipo Pointer ...........................................................................................................................35 4.6 Estructuras de programacin .............................................................................................41 Asignacin .............................................................................................................................42 Secuencia ...............................................................................................................................43
U.N.S.L. Argentina
Departamento de Informtica
Tabla de Contenido
Condiciones ...........................................................................................................................43 Seleccin ................................................................................................................................43 Iteracin.................................................................................................................................45 CAPTULO 5 MODULARIDAD ............................................................................................49 5.1 Parmetros .........................................................................................................................51 Pasaje de parmetros ............................................................................................................51 5.2 mbitos de validez ............................................................................................................51 Ejemplo de uso de procedimientos, funciones, con sus parmetros .....................................51 Otro ejemplo de uso de procedimientos, funciones, con sus parmetros..............................54 CAPTULO 6 ESTRUCTURAS DE DATOS ........................................................................61 6.1 Introduccin .......................................................................................................................61 6.2 Capacidad ..........................................................................................................................62 Capacidad dinmica ..............................................................................................................62 Capacidad esttica ................................................................................................................62 6.3 Operaciones .......................................................................................................................62 6.4 Orden de los elementos......................................................................................................63 Cronolgico ...........................................................................................................................63 o cronolgico ......................................................................................................................63 6.5 Selector de los elementos ..................................................................................................64 6.6 Tipo base............................................................................................................................64 CAPTULO 7 ESTRUCTURAS DE DATOS: ARREGLOS Y REGISTROS ...................65 7.1 Arreglos .............................................................................................................................65 Orden cronolgico .................................................................................................................65 Capacidad ..............................................................................................................................65 Operaciones ...........................................................................................................................65 Representacin grfica ..........................................................................................................65 7.2 Registros ............................................................................................................................66 Orden cronolgico .................................................................................................................66 Capacidad ..............................................................................................................................66 Operaciones ...........................................................................................................................66 Representacin grfica ..........................................................................................................66 CAPTULO 8 ESTRUCTURAS DE DATOS: PILAS Y FILAS .........................................67 8.1 Pilas ...................................................................................................................................67 Orden cronolgico .................................................................................................................67 Capacidad ..............................................................................................................................67 Operaciones ...........................................................................................................................67 Representacin grfica ..........................................................................................................68 8.2 Filas o colas .......................................................................................................................68 Orden Cronolgico ................................................................................................................68 Capacidad ..............................................................................................................................68 Operaciones ...........................................................................................................................68 Representacin grfica ..........................................................................................................69 CAPTULO 9 ESTRUCTURAS DE DATOS: LISTAS U I Y BIDIRECCIO ALES ....70 9.1 Listas uni-direccionales .....................................................................................................70
U.N.S.L. Argentina
ii
Tabla de Contenido
Composicin de los elementos ...............................................................................................70 Orden cronolgico .................................................................................................................70 Capacidad ..............................................................................................................................70 Operaciones ...........................................................................................................................70 Representacin grfica ..........................................................................................................71 9.2 Listas bi-direccionales .......................................................................................................71 Composicin de los elementos ...............................................................................................71 Orden cronolgico .................................................................................................................72 Capacidad ..............................................................................................................................72 Operaciones ...........................................................................................................................72 Representacin grfica ..........................................................................................................72 9.3 Generalidad de las listas ....................................................................................................73 CAPTULO 10 ESTRUCTURAS DE DATOS: ESTRUCTURAS MULTI IVEL...........75 10.1 Particularidades de las estructuras de multinivel .............................................................76 10.2 Estructuras estticas y dinmicas ....................................................................................76 10.3 Operaciones .....................................................................................................................76 CAPTULO 11 IMPLEME TACI DE ESTRUCTURAS .............................................77 11.1 Introduccin .....................................................................................................................77 11.2 Administracin de los espacios libres .............................................................................78 Desborde y desfonde ..............................................................................................................78 Mtodos de administracin de los espacios libres ................................................................78 11.3 Implementacin de pilas ..................................................................................................79 Con desplazamiento ...............................................................................................................79 Sin desplazamiento ................................................................................................................81 11.4 Implementacin de filas o colas ......................................................................................82 Con desplazamiento ...............................................................................................................82 Sin desplazamiento ................................................................................................................85 11.5 Implementacin de listas .................................................................................................88 Con desplazamiento ...............................................................................................................88 Sin desplazamiento ................................................................................................................92 CAPTULO 12 RECURSIVIDAD ..........................................................................................98 12.1 Nociones generales ..........................................................................................................98 12.2 Profundidad .....................................................................................................................99 12.3 Recursividad. Ejemplos .................................................................................................100 Sucesin de Fibonacci .........................................................................................................100 Torres de Hanoi ..............................................................................................................102 12.4 Recursividad directa e indirecta ....................................................................................103 12.5 Ventajas e inconvenientes .............................................................................................104 12.6 Datos recursivos ............................................................................................................104 12.7 Implementacin de listas con datos recursivos..............................................................105 12.8 Casos particulares de recursin .....................................................................................106 Inicializacin de la recursin ..............................................................................................106 Actualizacin de valores entre llamadas .............................................................................107 Recursin anidada ...............................................................................................................108
U.N.S.L. Argentina
iii
Tabla de Contenido
AP DICE A TABLA ASCII (AMERICA STA DARD CODE FOR I FORMATIO I TERCHA GE) ......................................................................................................................110 AP DICE B EXTE SIO ES AL LE GUAJE PASCAL PARA EL MA EJO DE ESTRUCTURAS DE DATOS DI MICAS..........................................................................111 Introduccin .............................................................................................................................111 Como programar usando las extensiones ................................................................................111 DEFINICIONES de tipos y DECLARACIONES de variables ...............................................112 OPERACIONES sobre las estructuras ....................................................................................113 I SERCIO .........................................................................................................................113 SUPRESIO ........................................................................................................................113 COPIA (o inspeccin) ..........................................................................................................113 OPERACIONES sobre los cursores asociados a las ulist y blist ............................................114 E TRAR a la ESTRUCTURA ..............................................................................................114 RECORRER la ESTRUCTURA ...........................................................................................114 PREDICADOS de control sobre las estructuras......................................................................114 VACIA ..................................................................................................................................114 LLE A .................................................................................................................................115 FUERA de la estructura ......................................................................................................115
U.N.S.L. Argentina
iv
Introduccin
Introduccin
Antes de comenzar a usar estas Notas de Clase nos ha parecido una buena idea empezar con algunas consideraciones generales sobre la o las materias para las que estn dedicadas, y sobre todo para dar algunas aclaraciones e ideas para guiar al alumno en su tarea de aprendizaje. Cul es el objetivo? Introducir a la programacin de las computadoras. Para quienes hagan Ciencias de la Computacin esto es la introduccin a uno de los aspectos ms importantes de la carrera. Nos basaremos fundamentalmente en las presentes notas, en otros apuntes (de los sistemas operativos o utilitarios empleados) y en el Pascal, Manual del usuario e Informe. Sin embargo, los libros dados en la bibliografa de los programas de las materias, constituyen una buena (al menos eso creemos!) lectura complementaria para todos los temas de las respectivas materias. En la Gua de Trabajos Prcticos se encuentran los programas de las respectivas materias. Los contenidos de los mismos son los que se desarrollarn durante las clases tericas y prcticas, estas ltimas ya sea de aula o en mquina. El Plan de Trabajos Prcticos indica, justamente, qu temas y ejercicios se harn en una u otra. Algunas veces parece conveniente dar consejos sobre cmo encarar el estudio y la lectura de los textos empleados. En la parte de Consideraciones Generales se hace eso. Esto no es una regla a seguir obligatoriamente. Son solo algunas ideas que a algunos nos han resultado tiles. En ltima instancia el que pone el mayor esfuerzo en la tarea de enseanza y aprendizaje es quien aprende. De nada vale asistir a clases si se tiene la mente puesta en otra cosa. De nada vale llevar los apuntes y libros bajo el brazo de un lado a otro. No se aprende por smosis sobacal! De nada vale pedir que un compaero o un docente resuelva los ejercicios del prctico. Estos estn para reafirmar los conocimientos a travs de la prctica: haciendo tambin se aprende. Ms vale un ejercicio trabajado que diez resueltos por un compaero, aunque se haya estado al lado del mismo mientras lo haca.
Consideraciones generales
Los textos de temas formales, no reiterativos y sintticos, cuando se explican en trminos no formales resultan reiterativos y poco sintticos; y algunas veces hasta ambiguos y fcilmente pueden inducir a confusin. Generalmente su explicacin est en su formalidad: si se conoce el lenguaje todo est ah, no hay necesidad de exgesis. Su gradualidad (de menos complicado a ms complicado) hace necesario el conocimiento previo, donde muchos trminos, notaciones y conceptos han sido explicados y no se necesita volver a hacerlo (no hay reiteracin), hay que acordarse o sino volver atrs. Generalmente se entiende que estos textos no necesitan de una gua de lectura. El texto en s mismo debera (debera?) ser suficiente gua. Como ya dijimos, las siguientes son unas ideas indicativas de cmo leer un texto dado y no son obligatorios de ninguna manera. Cada uno tiene su forma de leer, de estudiar, un texto. As, con ese espritu, veamos algunas ideas al respecto: Lea todo el texto una primera vez. Si hay alguna palabra que no entendi, bsquela en el diccionario. El significado, que encontr en el diccionario, para las palabras que no entendi, tiene sentido en la frase del texto? Recuerde que existe una jerga en muchos temas, especialmente de computacin. Est seguro que alguna de las palabras que no saba su significado no es parte de la jerga de computacin? Si tiene dudas al respecto consulte a los docentes. Lo que no entendi no ser porque hay un tema anterior que no recuerda bien? Repase lo anterior si cree que es necesario. Repselo ante la menor duda, nunca est de ms. o crea que con leerlo una sola vez es suficiente. En realidad hay que estudiarlo. Estudiar el texto significa leerlo, trabajarlo tantas veces como sea necesario hasta comprender el tema.
U.N.S.L. Argentina
A. Dasso, A. Funes - Introduccin a la Programacin - Notas de Clase
Las Computadoras
CAPTULO 1 LAS COMPUTADORAS

1.1 Introduccin
Qu es una computadora? La respuesta ms obvia y directa a esta pregunta es: una computadora es una mquina; que es, por otro lado, correcta. Es cierto que las computadoras son mquinas, tal como las lavarropas, los automviles, los receptores de radio o televisin, etc. Son sin embargo, por el momento al menos, las mquinas ms verstiles y complejas en su funcionamiento potencial que ha construido la humanidad. Por qu hablamos de funcionamiento potencial? Porque como toda mquina, las computadoras necesitan que se las haga funcionar. Sin embargo las mquinas, en general, tienen una funcin definida que realizan, ejecutan, cuando se las pone en funcionamiento: un lavarropas lava ropa, un automvil se mueve, un receptor (ya sea de radio o televisin) recepciona. Las computadoras, por otro lado, cuando se las hace funcionar computan, pero esta accin, en las computadoras, es ms compleja, ms amplia, ms verstil que lo que puede pensarse inicialmente. Justamente por la capacidad de realizar un nmero muy grande y diverso de acciones (algunas de las cuales son muy complicadas en s mismas) es que las computadoras pueden llegar a ser tan complejas. Es que las acciones bsicas con que han sido diseadas las computadoras son mucho ms generales que las de cualquier otra mquina. En efecto, cualquier mquina tiene un conjunto de acciones bsicas, digamos las instrucciones que la mquina entiende, y que le permiten actuar. As un automvil puede frenar, acelerar, doblar, etc. Las acciones bsicas, de sta mquina tan difundida, estn orientadas hacia la tarea para la cual ha sido diseado el automvil: transportar algo o alguien de un punto a otro. En el caso de las computadoras las acciones bsicas son mucho ms generales y se eligen justamente para permitir que el conjunto de ellas sea lo suficientemente amplio, por lo menos en su alcance, para que la computadora pueda ser utilizada en actividades muy distintas unas de otras. El objetivo bsico fundamental de una computadora es ejecutar programas, que pretenden resolver problemas. Justamente por esta razn es ms importante la programacin de las computadoras que la de otras mquinas. Claro es que uno puede programar un viaje, un traslado de un punto a otro, en automvil: cundo acelerar, cundo frenar, cundo doblar, todo esto sin contar los imprevistos, por supuesto, para los que ser necesario programar tambin. Es decir, algunas mquinas pueden programarse. De hecho hay ms de una mquina que se pueden programar, como por ejemplo los hornos de micro onda, los lavarropas, los lavaplatos, los GPS, etc. Algunas de ellas tienen ya unos cuantos aos, como los telares del siglo XVII en los que se programaban los dibujos de las telas. Sin embargo, son estas nuevas mquinas, las computadoras, tan verstiles, y que se aplican a la solucin de tantos y diversos problemas, las que han llevado la programacin a constituir una destacada actividad por el volumen que la misma implica. Es que, ms que con ninguna otra mquina, la programacin es, de lejos, la actividad fundamental para el funcionamiento de ellas. El funcionamiento de las computadoras ms comunes, est basado, por lo menos por el momento, en componentes (transistores, resistencias, etc.) con los cuales se construyen circuitos electrnicos. Algunos de estos se encuentran dispuestos (o empaquetados si se quiere) en pastillas, que se conocen con el nombre familiar de chips, generalmente con forma de rectngulo o cuadrado, de un tamao que oscila en los 3 cm2 o an menor, achicndose ao a ao. Estos tienen un nmero variable (desde 4 a ms de 200) de conectores que permiten conectar los circuitos que estn dentro de la pastilla con otros circuitos y elementos electrnicos (otras pastillas, por ejemplo). A estas pastillas se las llama circuitos integrados (CI), o en ingls integrated circuits (IC). Estos circuitos integrados tambin aumentan, ao a ao, la densidad (cantidad) de componentes bsicos que se integran en ellos. Los CI se encuentran instalados sobre superficies planas llamadas plaquetas o tarjetas, (en ingls cards o boards) que permiten la interconexin de los CI y otros elementos (capacitores, resistencias, etc.) electrnicos. Como estas conexiones se encuentran dispuestas sobre la superficie de las plaquetas o tarjetas (impresas, grabadas, etc.) tambin se las llama tarjetas impresas, en ingls printed circuit boards. Las tarjetas impresas se conectan a otras tarjetas impresas por medio de gran cantidad de conectores, (50 o ms),
U.N.S.L. Argentina
Las Computadoras
que permiten la interconexin de varias tarjetas y que se conocen con el nombre de bus, porque permiten canalizar muchos impulsos elctricos de unos elementos electrnicos a otros al mismo tiempo. Las computadoras se construyen, en definitiva, combinando juiciosamente distintos tipos de circuitos integrados sobre tarjetas impresas y estas, a su vez, entre s, generalmente por medio de uno (o ms) buses.
1.2 Las partes de una computadora

Introduccin
A las computadoras, por su amplia utilizacin as como por su aplicacin a la solucin de tantos y diversos problemas, se tiene tendencia a antropomorfizarlas. Es decir, atribuirles caractersticas propias de los seres humanos, particularmente la capacidad de pensar. Sin embargo, ya hemos dicho que las computadoras no son ms que mquinas y si bien esta comparacin con los seres humanos es til para comprender algunos detalles de su funcionamiento no es conveniente abusar de ella. As, al hablar de las partes de la computadora y usando (abusando?) de esta analoga humanoide: Hablaremos de los sentidos (ver, escuchar, olfatear, gustar, or, etc.) y diremos que son las entradas a la computadora, por donde sta, a travs de los rganos de los sentidos (ojos, odos, nariz, etc.), capta el medio ambiente. Hablaremos de las acciones (hablar, escribir, andar, etc.) y diremos que son las salidas de la computadora, y que, por medio de los rganos adecuados (cuerdas vocales, manos, piernas, etc.), acciona sobre el mundo exterior. Por supuesto que las computadoras no tienen los sentidos, ni las acciones, ni los rganos correspondientes de la misma forma que los seres humanos. Pero a los efectos de una rpida explicacin estas analogas son suficientes. En general es posible separar (arbitrariamente y al solo efecto de brindar una explicacin superficial de las mismas) las partes de una computadora en dos: internas y externas. La primera tiene que ver con las actividades internas que pueda realizar la mquina y la segunda con los componentes de la computadora dedicados a recibir impulsos del medio ambiente y accionar sobre l. Podemos decir que la parte interna es el cerebro de las computadoras, mientras que las partes externas tienen que ver con los sentidos de la mquina as como con los medios que utilice para accionar sobre el mundo exterior: diramos que es el equivalente de sus manos, voz, etc. Muchas veces se habla de perifricos para referirse a las partes externas de la computadora, quizs porque en el pasado las primeras computadoras tenan lo que hemos llamado partes externas, en armarios alrededor, en la periferia, de la mquina principal.
Las partes internas

Decamos que la parte interna de las computadoras poda compararse con el cerebro de las mismas. Podemos distinguir aqu dos partes: la Unidad Central de Proceso y la memoria principal.
Unidad Central de Proceso

La Unidad Central de Proceso (UCP) o Central Processing Unit (CPU) en ingls, est compuesta de los circuitos electrnicos destinados a ordenar el funcionamiento general de la mquina, as como de reconocer un nmero fijo y determinado de rdenes o instrucciones que son las nicas acciones que la computadora puede realizar y sobre las que se construyen (a travs de programas que se hacen empleando dichas instrucciones) las acciones que las computadoras realizan. Estas instrucciones se conocen generalmente bajo el nombre de conjunto o juego de instrucciones, o instruction set en ingls. En efecto, uno de los aspectos ms importantes de una CPU es que la misma slo reconoce un conjunto de instrucciones y slo esas. Es empleando juiciosamente estas instrucciones que pueden hacerse programas para que una computadora realicen las tareas que se pretende de ella.
U.N.S.L. Argentina
Las Computadoras
Este conjunto de instrucciones consta, generalmente, de 50 a 200 instrucciones, an cuando haya CPUs que solo reconozcan una instruccin y otras ms de 200. Quiere decir que las instrucciones, que una CPU reconoce, son las que han sido incorporadas, a travs de circuitos electrnicos (por lo menos en la mayora de las computadoras en uso corriente), por el fabricante de la misma. El criterio que cada fabricante tiene para decidir qu instrucciones incorporar a la CPU que l fabrica es esencialmente comercial. En efecto incorporar aquellas instrucciones que, luego de un anlisis de mercado y otros, considere que har ms atractiva su CPU en el mercado y le permitir venderla ms fcilmente por sobre la de sus competidores. Est claro que una CPU que reconoce cincuenta instrucciones, por ejemplo, no necesariamente ejecuta programas (hechos con esas instrucciones) de cincuenta instrucciones. De la misma manera que un ser humano que conoce slo tres mil palabras puede leer libros que contienen muchas ms de tres mil palabras ya que puede leer y entender cada palabra varias veces, una CPU puede ejecutar programas muy largos, siempre y cuando estn formados de instrucciones que ella reconoce. La CPU ser, entonces, la encargada de ejecutar las instrucciones que se le den ordenadas en programas. Estas instrucciones sern ejecutadas en un orden secuencial, es decir una despus de la otra y a un ritmo, a una velocidad, predeterminada. Este ritmo, esta velocidad, que permite a cada instruccin ejecutarse an cuando no todas ellas tomen el mismo tiempo para hacerlo, est controlada por circuitos especiales dentro de la CPU, llamados generalmente Unidad de Control. Estos circuitos emplean un reloj, as como una tabla especial que les permite conocer cunto tiempo tarda cada instruccin en ejecutarse. Este reloj produce ticks, ciclos o pulsos a un ritmo determinado, es decir que hay un nmero fijo de ciclos por intervalo de tiempo establecido, de la misma manera que lo hacen los relojes usados por los seres humanos. Un reloj comn, generalmente, produce un pulso, ciclo o tick cada segundo: tiene una frecuencia de un ciclo (o tick, si se prefiere) por segundo. Est claro que este reloj slo puede medir intervalos de un segundo, si se desea medir intervalos menores a un segundo ser necesario aumentar la frecuencia del reloj (ms de un tick por segundo, por ejemplo). La frecuencia se mide en ciclos por segundo (c/sec o sec ) o hercio o hertz (Hz). As, por ejemplo, un reloj que mide segundos deber tener, como mnimo, una frecuencia de 1 Hz o 1 c/sec y uno que mida dcimas de segundo 1 deber tener una frecuencia de 10 Hz o 10 sec . Los relojes empleados en las computadoras deben producir muchos pulsos o ciclos por segundo ya que las computadoras ejecutan muchas instrucciones por segundo, del orden de varios miles. Una instruccin puede tardar, 6 por ejemplo un micro segundo (1 x 10 o 0,000001, una millonsima de segundo) en ejecutarse. Esta velocidad se incrementa permanentemente ante la constante mejora de las tecnologas empleadas. La frecuencia de los relojes de las computadoras es, entonces, muy alta: hay muchos pulsos por segundo. Los necesarios para medir el tiempo ms corto que tarda la ejecucin de la accin ms corta que debe ejecutar la CPU (que no es necesariamente una instruccin completa sino parte de una). Esto hace que las frecuencias de stos relojes se midan en millones de pulsos por segundo: megahercio (MHz) o en gigahercios (GHz), miles de millones de pulsos por segundo; terahercios, 1012; petahercios, 1015 ; etc.
1
Procesadores y micro-procesadores
A la CPU se la conoce, muchas veces, como el procesador de la computadora, quizs por ser la parte encargada de controlar el procesamiento de la informacin dentro de la computadora. Por otro lado, es muy comn hoy en da hablar de microprocesadores, y como extensin de micro computadoras, para referirse a aquellas mquinas que tienen microprocesadores. En realidad, no existe ninguna diferencia substancial, o conceptual, entre los procesadores y los microprocesadores. Es slo una diferencia de empaquetado. Todas las computadoras tienen CPU, o procesador. Hace unos aos, por razones puramente tecnolgicas, y porque, adems, era posible, se pas de fabricar los procesadores en una o ms plaquetas con varios circuitos integrados, a un procesador hecho en un solo circuito integrado. A estos procesadores construidos en un solo circuito integrado se los llama microprocesadores.
U.N.S.L. Argentina
Las Computadoras
Procesadores y co-procesadores
Las computadoras necesitan de un procesador (CPU) para funcionar. Este tiene todas las funciones, todas las instrucciones bsicas, necesarias para realizar las operaciones ms comunes. Aquellas que faltan pueden reemplazarse por programas hechos usando las instrucciones del conjunto de instrucciones que tiene la CPU. As por ejemplo, muchas CPU cuentan solo con la operacin aritmtica de la suma, pudiendo reemplazar con sta, por medio de programas, las otras operaciones.: por ejemplo, la resta puede ser programada como una suma de nmeros naturales, usando adems la operacin de mdulo; la divisin como restas sucesivas y la multiplicacin como sumas sucesivas). Sin embargo algunas veces estas funciones no son suficientes. En efecto, por razones de velocidad (la mayor parte de las veces) es necesario incorporar otras instrucciones a la CPU. Generalmente, se trata de instrucciones aritmticas (resta, divisin, multiplicacin y otras). En lugar de incorporar las instrucciones a la CPU, lo que la hace ms cara, una solucin encontrada fue agregar otro procesador cuando resultase necesario. Este otro procesador, llamado co-procesador, trabaja bajo el control de la CPU y slo tiene las instrucciones faltantes. Estos co-procesadores tienen diversos usos, los ms comunes son aquellos que cuentan con instrucciones aritmticas, aunque existen otros que agregan instrucciones para el procesamiento de sonidos, imgenes, etc. Sin embargo, muchos procesadores, que empezaron cmo co-procesadores, particularmente para procesamiento de imgenes y grficos, y que necesitan de instrucciones aritmticas complejas, se emplean como procesadores de uso general.
Memoria principal
La memoria principal, es donde la computadora almacena, o memoriza los programas y los objetos o datos sobre los que debe actuar para realizar las acciones para las que ha sido programada. La memoria principal est compuesta de un nmero finito de elementos de almacenamiento. Cada uno de estos elementos de almacenamiento debe poder ser accedido por la CPU, ya sea para almacenar algo o para conocer lo que est almacenado. La accin de almacenar o guardar es conocida como escritura o grabacin; la accin de recuperar, conocer, mirar lo que ya est almacenado, como lectura. Para poder realizar estas acciones de escritura y lectura es necesario que cada uno de los elementos de almacenamiento pueda ser identificado para que se distingan unos de otros. Esto se hace dndole a cada uno una direccin, que en este caso no es ms que un nmero que le es propio y lo distingue. Como la capacidad de contar de la CPU es finita, es decir que solo puede contar hasta un cierto nmero que depende de cada tipo de CPU, las direcciones de elementos de memoria que la CPU puede direccionar dependern de su capacidad de contar. As una CPU que slo puede contar hasta un milln, slo podr direccionar, acceder, un milln de elementos de memoria como mximo. Esto es conocido como el espacio direccionable de la CPU. Toda memoria que se coloque dentro de este espacio la llamaremos memoria principal. En realidad, cuando hablamos de la memoria principal de una computadora queremos referirnos a aquella memoria que la CPU puede direccionar directamente. Dado que la memoria principal le sirve a la CPU para memorizar, guardar programas y datos, hay una estrecha relacin entre la memoria principal de una computadora y la CPU de la misma. El programa, que se desea que la computadora ejecute, o por lo menos las partes que se estn ejecutando en un momento dado, debe estar guardado mientras se ejecuta en la memoria principal. All mismo, en la memoria principal, deben encontrarse los objetos o datos que sean necesarios para realizar las acciones del programa. La interaccin entre la memoria principal y la CPU es, entonces, permanente. Las acciones de ambas deben estar estrechamente sincronizadas: la memoria principal debe entregar a la CPU las instrucciones del programa una a una en el orden establecido en el programa. As mismo debe entregar los objetos o datos necesarios para ejecutar el programa. Este sincronismo se obtiene porque ambos, CPU y memoria principal, conocen sus respectivas velocidades de funcionamiento, y en consecuencia se adaptan uno con el otro, empleando para ello el reloj que toda computadora tiene.
U.N.S.L. Argentina
Las Computadoras
Como muchas cosas, tampoco la memoria principal es infinita en su capacidad de almacenamiento. Por el contrario tiene lmites.
Unidades de medida de almacenamiento

La capacidad de almacenamiento de la memoria principal se mide en unidades de almacenamiento llamados bytes. Un byte es la unidad necesaria para almacenar un carcter. Un carcter es un elemento de un conjunto de smbolos que se usan normalmente en la escritura como por ejemplo: una letra (de la a a la z, o de la A a la Z, ya que en este caso se hace una distincin entre los smbolos empleados para las minsculas y las maysculas); los smbolos empleados para denotar los nmeros del cero al nueve; smbolos de puntuacin y otros, como por ejemplo: + ) @ : , ! ; . $ ( * % & - = ] # [ ? / y otros ms. Se emplea el prefijo Kilo para denotar las unidades de mil caracteres (Kilo bytes o K-bytes o Kb). Sin embargo, por razones de uso del sistema de numeracin binario, en las computadoras, las unidades de mil bytes se equiparan 10 con la potencia de dos ms cercana (2 = 1.024) y as sucesivamente. Es decir que, por ejemplo, 2 Kb es igual a 2.048 caracteres y no a 2.000 caracteres. Lo mismo sucede con las unidades de un milln de bytes, para el que se emplea el prefijo Mega (Mega bytes o 20 M-bytes o Mb). As, por ejemplo, 1 Mb es igual a 1.048.576 (2 ); y 3 Mb es igual a 3.145.728. Hace unos aos atrs la capacidad de la memoria principal de las computadoras ms comunes estaba en el orden de los Kb. Hace unos aos las memorias se medan en megabytes, hoy en da (2009) nos encontramos en el orden de los gigabytes (Gb) (1Gb = 1.073.741.824 bytes). Es de esperar que en los prximos aos tengamos que emplear los Tera bytes (1012), (1Tb = 1.099.511.627.776 bytes), los Petabytes (1015); etc. Para tener una idea de la capacidad de una memoria principal de 1Mb, puede pensarse en un libro de 300 pginas, y para el que suponemos que cada pgina tiene 50 lneas, cada lnea 10 palabras, y cada palabra 5 caracteres: 300 50 10 5 = 750.000 caracteres o bytes, aproximadamente 732 Kb; es decir que no llega a 1 Mb.
Tecnologas de fabricacin
La tecnologa empleada para fabricar los componentes electrnicos necesarios para las memorias de las computadoras es muy variada. Podemos reconocer dos grandes tipos: las memorias RAM, siglas en ingls de Random Access Memory (Memoria de Acceso Aleatorio) cuya caracterstica principal es que, cuando no est alimentada con energa, pierde (se borra) lo que tiene almacenado. Estas memorias pueden escribirse (grabarse) y leerse muchas veces. Por otro lado estn las memorias ROM, siglas en ingls de Read Only Memory (Memoria de Slo Lectura), cuya caracterstica principal es que no pierde lo que tiene almacenado cuando no est alimentada por energa pero que, por el contrario, no puede escribirse (o grabarse) ms que una sola vez. Puede, sin embargo, leerse muchas veces. Existen otros tipos de tecnologa para memorias, variantes de las ROMs, que pueden escribirse ms de una vez an cuando esta escritura es ms complicada que en las RAMs, o que para borrarlas, antes de escribirlas, es necesario realizar algn proceso tambin ms complicado que con las RAMs. Algunas de las ms comunes son las PROM, EPROM, etc. Un papel destacado en las Computadoras Personales (Personal Computers, PC, en ingls)lo ocupan las memorias construidas con tecnologa MOS o CMOS, que sirven, an cuando se apague la PC, para guardar sus caractersticas, la configuracin de la misma (qu tipo y cuantos discos tiene, qu tipo de monitor, etc.). Esto lo pueden hacer porque quedan alimentadas con una batera, que es suficiente, ya que justamente una de sus principales caractersticas (la de las memorias MOS) es su bajo consumo de energa.
Las partes externas

Empleando una analoga con los seres humanos, las partes externas tienen que ver, por un lado, con los sentidos de la computadora y los rganos necesarios para contar con ellos para captar el mundo exterior: las entradas. Por otro lado, las partes externas tienen que ver, tambin, con los medios que utilice la computadora para
U.N.S.L. Argentina
Las Computadoras
accionar sobre el mundo exterior: hablaremos de las acciones (siguiendo con la analoga: hablar, escribir, andar, etc.) y diremos que son las salidas de la computadora, y que, por medio de los rganos adecuados (otra vez la analoga!: cuerdas vocales, manos, piernas, etc.), acciona sobre el mundo exterior. Claro est que los rganos necesarios para producir estas entradas y salidas no son iguales a los de los seres humanos, como que tampoco los sentidos son los mismos. La analoga vale solo para la comprensin inmediata del tema. As hablaremos de dispositivos de entrada/salida de la computadora y no de rganos. Es de hacer notar que, debido a la amplia difusin de las computadoras y su aplicacin en distintas actividades, los dispositivos, tanto de entrada como de salida, son muchos ms variados que los rganos de los seres humanos, por ejemplo, algunos sirven para detectar radiaciones (electromagnticas y sonoras) que van ms all del rango que es accesible a los seres humanos y accionan con una precisin y velocidad varias veces mayor que estos. Puede decirse que la variedad de estos dispositivos se cuentan, quizs, en los miles. Dado el nmero tan grande de dispositivos, describiremos aqu solo algunos de los ms comunes.
Teclado
El teclado ha sido y es, todava, el medio de entrada, a la computadora, ms comn. Por lo menos para entrar caracteres. El teclado es similar al de una mquina de escribir. Cunto tiempo sta analoga ser vlida? Cuntos de los jvenes lectores han visto una mquina de escribir elctrica o mecnica? Consiste de un conjunto de teclas y cada una de ellas representa una letra del alfabeto, un dgito (del cero al nueve), adems de los smbolos corrientes de puntuacin y algunos otros. Cada vez que se presiona una tecla, los circuitos del teclado envan a la computadora un cdigo correspondiente al carcter que dicha tecla representa. Por supuesto, tanto el teclado como la computadora, ambos conocen la codificacin correspondiente a cada tecla, de otra manera la comunicacin sera imposible.
Video
Como el teclado ha sido y es el medio ms comn de entrada, la pantalla de video es y ha sido el medio ms comn de salida. Tanto es as que ambos se encuentran, y son vistos, la mayor parte de las veces como un todo, como un conjunto inseparable. La pantalla de video comparte con la pantalla de los televisores su tecnologa: ambos son tubos de rayos catdicos (Cathode Ray Tube, CRT, en ingls), an cuando en ambos medios, televisin y computacin, comienzan a aparecer otras tecnologas como por ejemplo el cristal lquido (Liquid Crystal Display, LCD, en ingls), o los LEDs (Light Emiting Diode). Sin embargo, la pantalla, que se conoce generalmente con el nombre de monitor, no lo es todo. Al igual que un aparato de televisin que necesita del receptor y amplificador para poder mostrar por la pantalla las imgenes, una pantalla de computadora necesita de un dispositivo electrnico para poder mostrar las salidas que la computadora enva a la pantalla. Este dispositivo es conocido comnmente como el controlador de video, o plaqueta controladora de video, etc., y es el encargado de recibir de la CPU las imgenes a proyectar en la pantalla y de enviar a sta los impulsos electrnicos necesarios para producir dichas imgenes. El controlador tiene su propia memoria, llamada memoria de video, para almacenar temporalmente las imgenes que se envan al monitor. Por supuesto, las imgenes pueden mostrarse tanto en blanco y negro (mal llamado muchas veces monocromo, un solo color) o en color. Para este ltimo caso, se necesitan controladores y monitores condicionados para ello. De acuerdo con la cantidad de colores potenciales que pueden mostrarse se habla de la palette de colores disponibles, esto no es lo mismo que la cantidad de colores que pueden mostrarse al mismo tiempo en la pantalla. En efecto, se pueden tener disponibles varios millones de colores, por ejemplo diecisis millones, pero solo poder mostrarse, por la pantalla, unos pocos al mismo tiempo, diecisis o doscientos cincuenta y seis, dependiendo del controlador y del monitor. La calidad de imagen del conjunto de controlador de video y monitor se mide en la cantidad de puntos que pueden mostrar. Cada uno de estos puntos se lo conoce con el trmino pixel en ingls. En efecto, la pantalla puede verse como un rectngulo lleno de pequeos puntos que pueden estar encendidos o no de acuerdo con la imagen que se desee formar. Cuantos ms puntos se puedan mostrar en una superficie dada mayor ser la calidad de la imagen.
U.N.S.L. Argentina
Las Computadoras
Es decir que cuanto mayor sea la densidad de puntos, para una superficie dada, mayor ser la resolucin. Hay que tener en cuenta que muchas veces se emplea cantidad de pixels para referirse a la resolucin. La cantidad de pixels se mide como el producto del ancho por el alto, ambos medidos en cantidad de puntos, que se pueden mostrar. Sin embargo, la resolucin es la cantidad de puntos por la superficie de la pantalla. Es decir la misma cantidad de puntos dar una mayor resolucin cunto ms pequea sea la superficie. Esto es la densidad. Es de hacer notar que la resolucin incluye otras caractersticas adems de la densidad. Cada pixel tiene una serie de atributos, como por ejemplo el tono en el caso del color y en algunos casos de blanco y negro que se transforman en tonos de grises, el parpadeo, la inversin (de blanco a negro o viceversa), el subrayado, etc. Los caracteres o smbolos (letras, dgitos, signos de puntuacin, etc.) para ser mostrados en la pantalla, al igual que cualquier otra imagen, se construyen con estos puntos o pixels. Muchas veces, en especial en las PCs, se distinguen dos modos de mostrar las salidas en la pantalla: modo texto, que es cuando no se pueden mostrar figuras sino solo smbolos de escritura, de texto, como letras, dgitos (del cero al nueve), signos de puntuacin y modo grfico, que es cuando se puede mostrar cualquier tipo de imagen. A modo de ejemplo damos una tabla con algunos de los estndares ms comunes de las PCs. Algunos de estos estndares ya ha cado en desuso, por ejemplo: Hercules (no lleva acento porque est escrito en ingls), CGA, EGA. Tabla 1.1. Caractersticas de los sistemas de video.
Estndar Observaciones Modo Grfico ancho alto (pixels)
HERCULES CGA EGA VGA SUPER VGA O XGA SXGA+ UXGA WXGA WUXGA En Modo Texto: carcter: (pixels) ancho alto: 8 8 CRT: lneas columnas: 40 x 25 80 x 25 132 x 25/44
carcter: (pixels) ancho alto: 8 x 14
b/n 720 348 b/n 640 200; 4 c 320 200 64 c 640 x 350 640 x 480 video/palette: 32.768/32.768 ; 256/256.000 ; etc. 800 600; 256/256.000; etc. 1.024 768; 256/256.000 ; etc. 1400 1.050 1.600 1.200 1.440 900 1.920 1.200
Usado en general para wide-screens, relacin similar a pantalla de cine: 16:10 o 16:9 en lugar de 4:3
Mouse (Ratn)
Otro dispositivo de entrada a la computadora ampliamente difundido es el mouse (en Ingls) o ratn. Este dispositivo comanda el cursor que se posiciona en la pantalla de video en los ambientes grficos. Para comandar el movimiento del cursor se utilizan distintos mecanismos en el mouse. Algunos son electro-mecnicos: el usuario al mover el mouse sobre una superficie hace que una bola ruede entre dos rodillos colocados a 90, a su vez el movimiento de estos rodillos es detectado electrnicamente lo que permite determinar la direccin y distancia del movimiento del mouse. Existen tambin algunos ratones que emplean un haz de luz cuyo reflejo sobre una superficie es captado electrnicamente y es esto lo que permite en este caso determinar la direccin y distancia del movimiento del mismo.
Memoria auxiliar
Como en muchos casos de la vida corriente, nadie est satisfecho con lo que tiene y las computadoras no son una excepcin: no les basta con la memoria principal y necesitan de memoria auxiliar. En realidad, la diferencia ms importante entre la memoria principal y la memoria auxiliar es que la primera est ntimamente ligada a la CPU, ya que como hemos visto, la CPU puede direccionarla directamente (est dentro de su
U.N.S.L. Argentina
Las Computadoras
espacio direccionable), mientras que la segunda no. Se podra decir que la memoria principal es comparable a la memoria de los seres humanos: reside en el cerebro de stos. La memoria auxiliar podra comparrsela con un cuaderno, una agenda, etc., que puede emplearse a voluntad y que no es estrictamente necesario para el funcionamiento. Adems es extensible: siguiendo con la analoga, pueden comprarse tantos cuadernos, agendas, etc., se necesiten a medida que sean necesarios. Lo mismo pasa con la memoria auxiliar de las computadoras. La capacidad de la memoria auxiliar se mide, igual que la de la memoria principal, empleando los bytes o caracteres. Hay distintos tipos de memoria auxiliar; las ms comunes son las que se encuentran sobre un soporte magntico (a diferencia de los cuadernos, por ejemplo, que estn sobre un soporte hecho de papel). De stas, hay dos clases bien diferenciadas: las cintas y los discos. La diferencia fundamental entre una y otra es la forma de acceso a lo que se encuentra almacenado. En las cintas el acceso es secuencial, como en los antiguos casetes de msica o sonido donde haba que recorrer toda la parte de la cinta que preceda lo que se deseaba escuchar. En los discos el acceso es directo; al igual que los discos de msica, sean estos de pasta long plays u pticos lser o compact disks, donde puede accederse directamente a lo que se quiere escuchar, ac tambin puede accederse de forma directa a lo que se encuentra almacenado. En los ltimos aos han aparecido tambin para las computadoras los discos pticos, conocidos como DVDs (Digital Versatile Disc o Digital Video Disc) y CD-ROM (Compact Disk ROM), porque como se escriben (graban) una sola vez y se leen muchas, se parecen en esto a las memorias ROM. An cuando ya haya CDs y DVDs que pueden leerse y grabarse varias veces. Hay tambin discos opto-magnticos, es decir que emplean ambas tecnologas, ptica y magntica, generalmente la ptica sirve para posicionar la cabeza lecto-grabadora sobre la superficie del disco y la magntica para grabar y leer.
Discos magnticos
Los discos, especialmente los magnticos, se han constituido en el medio ms comnmente empleado en las computadoras. Estos estn hechos sobre una base que tiene una capa de un material que puede soportar un campo magntico sobre el que se graba la informacin. Esta informacin se graba, entonces, empleando propiedades de los campos magnticos. El funcionamiento de los discos es bsicamente muy simple: cuentan con un dispositivo de lectura y grabacin que hace que los mismos giren a una cantidad de revoluciones por minuto establecida, mientras que una cabeza de lectura y grabacin se desplaza, con movimientos radiales o de otro tipo, sobre la superficie para efectuar la operacin deseada de grabacin de informacin o lectura de informacin ya almacenada. El disco est conectado a la CPU por medio de un conjunto de circuitos electrnicos especializados, que se encargan de toda la operacin de la unidad de lecto-grabacin y que se conocen con el nombre genrico de Controlador de Disco. Hay distintos tipos de controladores para los distintos tipos de dispositivos de lectograbacin, capacidad de almacenamiento y velocidad de transmisin de stos. En efecto, la capacidad total de un disco y/o su unidad de lecto-grabacin puede medirse en trminos de su capacidad de almacenamiento y la velocidad de lectura y grabacin, es decir la velocidad con que enva y recibe informacin de la CPU. Existen distintos tipos de discos: flexibles, tambin llamados disquetes o floppy disks en ingls, cuya base es flexible, blanda. Otros son rgidos o duros, porque su base es dura, rgida. No debe confundirse la funda que muchas veces envuelve a los discos, que en algunos casos puede ser flexible y en otros rgida, aun cuando dentro haya un disco flexible. Existen, por otro lado, discos fijos que se encuentran montados dentro del dispositivo de lecto-grabacin en la computadora y que no pueden quitarse a menos de una intervencin de personal especializado y en general por razones de reparacin. Por otro lado, hay discos removibles por el usuario comn de la computadora y que en el curso normal de operacin de la computadora podrn ser puestos o quitados del dispositivo de lecto-grabacin. Es importante, entonces, distinguir entre el dispositivo de lecto-grabacin (el equivalente de un grabador o reproductor de casetes de audio) y el medio sobre el que se almacena la informacin (el equivalente del casete).
U.N.S.L. Argentina
Las Computadoras
Los discos magnticos estn organizados en caras o lados (faces, en ingls), stos a su vez en pistas (tracks en ingls) concntricas (no en un espiral como los discos de pasta de msica) las cuales estn divididas en sectores, que es donde se graban los bytes o caracteres. Generalmente, un disco tiene dos caras o faces. Sin embargo, hay dispositivos de lecto-grabacin que aceptan discos apilados (armados de esa manera) por lo que hay ms de dos caras en cada unidad que se pone en el dispositivo de lecto-grabacin. Las pistas que se encuentran en cada cara en la misma posicin constituyen lo que generalmente se conoce como un cilindro. Los discos que vienen directamente del fabricante deben ser procesados antes de poder ser empleados en la computadora. Este proceso, que se conoce con el nombre de formateado es de caractersticas distintas dependiendo del tipo de disco, de la computadora y sus programas bsicos (Sistema Operativo). Discos magnticos flexibles (floppy disquete) En general, los disquetes son removibles, es decir que pueden ponerse y sacarse del dispositivo de lectograbacin en el curso normal de operacin de la computadora. Al igual que los casetes, stos tienen un sistema de proteccin de grabacin. Hay distintas medidas para los disquetes. Se los puede medir de acuerdo a su dimetro, expresado en pulgadas (por ejemplo, 8, 5, 3, 3, 2), o a su capacidad de almacenamiento. Los ms comunes son de 5 de 360 Kb y de 1,2 Mb. De 3 de 720 Kb y de 1,44 Mb. Los disquetes emplean una o dos caras dependiendo de la capacidad de los mismos. Tienen entre 40 a 80 pistas y 8, 9 o 15 sectores por pista, con una capacidad de 128 a 1.024 caracteres por sector, siendo el de 512 el ms comn. En la actualidad estos dispositivos han cado en desuso y se han reemplazado por las memorias de estado slido, con tecnologa similar, aunque no igual, a la tecnologa empleada para la fabricacin de la memoria principal, que se encuentran en los dispositivos de memoria USB (pen drives, etc.) Discos magnticos rgidos (duros) En general los discos rgidos o duros no son removibles, an cuando hay dispositivos que s lo permiten pero no son los ms comunes. Es decir que el disco se encuentra sellado dentro de la unidad de lecto-grabacin. La capacidad de almacenamiento de estos discos es mucho mayor que la de los disquetes: va de los Megabytes a los Gigabytes. Su velocidad es tambin varias veces mayor que la de los disquetes.
Impresora
La impresora constituye otro de los perifricos ms comunes de las computadoras. Ella sirve para obtener informacin impresa sobre papel. Es, como la pantalla, un dispositivo de salida, siendo sta no sobre una pantalla de rayos catdicos, sino sobre papel. Existen diversas tecnologas de impresoras. Una clasificacin posible es: Impresoras de impacto, que son las que impactan, golpean, mecnicamente sobre una cinta entintada y sobre el papel para imprimir los caracteres, y que a su vez pueden separarse en: impresoras de lnea, que son las que imprimen una lnea por vez, todos los caracteres al mismo tiempo, y de las que existen varias tecnologas (tambor, cinta, etc.); o a carcter, que imprimen un carcter a la vez; estas tambin emplean distintas tcnicas (bocha: similar a ciertas mquinas de escribir mecnicas o electromecnicas, cilindro, roseta o margarita, agujas: las ms comunes). Impresoras de deposicin de tinta, que colocan, depositan, la tinta sobre el papel, sin emplear un golpe para ello. Las tecnologas empleadas para ello son variadas: chorro de tinta: que arroja minsculas gotas de tinta para dibujar el carcter a ser impreso; lser: que emplea un lser u otra fuente de luz coherente para depositar la tinta electroestticamente sobre el papel (similar a las fotocopias). En ste grupo podemos incluir a las impresoras que emplean un papel termo sensible (que reacciona al calor) y que por medio de agujas calientes puede dibujar los caracteres sobre el papel (mtodo empleado por los faxes), aunque, debido al costo y a la calidad de la presentacin del escrito final, han cado en desuso en las computadoras. La capacidad de una impresora puede considerarse desde varios aspectos: una impresora de impacto, que tenga
U.N.S.L. Argentina
10
Las Computadoras
una matriz con el formato de cada carcter, imprimir caracteres muy ntidos (sobre todo cuando est nueva!) pero no podr cambiar ni el tipo (por ejemplo cursiva o negrita o Courier) ni el tamao de los mismos. Tampoco podr imprimir otra cosa que no sean caracteres: no podr, por ejemplo, imprimir figuras ni grficos. Por el contrario las impresoras que tienen una aguja o un chorro de tinta y que construyen, dibujan, cada carcter al imprimirlo, podrn, de la misma manera, imprimir figuras y grficos. Otro aspecto a tener en cuenta es la necesidad de color, ya que hay impresoras que no solo imprimen con un solo color de tinta sino que pueden hacerlo con varios colores distintos. Debe pensarse en el tipo de papel que emplea la impresora (por ejemplo si es termo sensible o papel comn, etc.) as como el tamao mximo de papel que puede emplear. Es importante considerar la velocidad de impresin, que se mide de distintas formas: en las impresoras de lnea en lneas por minuto, de seiscientas lpm, por ejemplo. En las de carcter en caracteres por segundo, de trescientos cps, aunque esto vara mucho de acuerdo con la calidad de impresin. La velocidad de las impresoras lser o de chorro de tinta suele medirse en pginas por minuto. La precisin (algunas veces tambin llamada calidad de impresin) de una impresora es importante ya que hace a la claridad y a la elegancia de la escritura as como a la precisin con que figuras y grficos son impresos. Esto tiene sentido en aquellas impresoras, que como las de chorro de tinta o lser, construyen sus impresos sobre la base de puntos (tanto los caracteres como las figuras). Por eso mismo, la precisin suele medirse en puntos por pulgada, es decir cuntos puntos puede poner en una pulgada. Las impresoras lser y de chorro de tinta ms comunes hacen aproximadamente trescientos o ms puntos por pulgada.
1.3 La informacin dentro de la computadora

Ya hemos dicho que la tarea principal de una computadora es la de ejecutar programas. Pero qu hacen estos programas cuando se ejecutan dentro de la computadora? La respuesta es que procesan informacin. Informacin que ya tienen porque se la ingresaron previamente: o bien porque es el producto de un proceso anterior realizado por la misma computadora, o porque ha sido ingresada durante la ejecucin del programa. Esta informacin es en realidad una representacin de cosas del mundo externo a la computadora. As cuando una computadora procesa la informacin sobre el personal de una empresa para liquidar sueldos, por ejemplo, o procesa la informacin sobre consumo de electricidad de los abonados de una empresa elctrica para producir las facturas, tiene la informacin necesaria para ello (con suerte sin errores para que no se produzcan facturas exorbitantes o sueldos ridculos!). Obviamente, ni los empleados de la empresa a los que hay que liquidar sueldos, ni el dinero para pagarles, ni los kilowatt del consumo elctrico de los abonados estn realmente dentro de la computadora. Solamente se encuentra la informacin que representa dichas cosas. Esta informacin, esta representacin abstracta de aspectos de la realidad, se conoce con el nombre de datos. Son los datos, por ejemplo, sobre los empleados (nombre, direccin, categora, etc.) necesarios para el proceso de liquidar sueldos los que se encuentran almacenados en la computadora cuando se realiza su liquidacin de haberes. Estos datos se encuentran en la memoria auxiliar de la computadora (sobre todo cuando son muchos) y pasan a la memoria principal a medida que son requeridos por la CPU para su procesamiento. Por supuesto que dichos datos deben estar organizados dentro de la computadora para que puedan ser utilizados. Esta organizacin depende, claro, de la finalidad que se desee. As los datos sobre los empleados de una empresa estarn agrupados de manera tal que puedan ser usados para liquidar sueldos si es eso lo que se desea. La decisin sobre el tipo de organizacin depende del usuario de la computadora y del fin que pretenda. El sistema computacional le permitir, por medio de programas especficos realizar dicha organizacin. Generalmente los datos se agruparn, en una primera instancia, en archivos (files, en ingls). Siguiendo con el ejemplo de los empleados, podra existir un archivo que almacene los datos de todos y cada uno de los empleados. Este archivo tendr una identificacin de manera tal que los programas que deban procesar los datos puedan reconocerlo. La mayor parte de las veces la identificacin consistir de un nombre, pero puede haber otros tipos de identificacin; as, archivos con nombres iguales podran distinguirse por medio de la fecha y hora en la que fueron guardados en la computadora, etc. Los archivos podrn, a su vez, agruparse en otros grupos, que se conocen como directorios, o cuentas, de manera tal que se pueda organizar mejor la informacin. Esto sera equivalente a tener organizada la informacin sobre los
U.N.S.L. Argentina
11
Las Computadoras
empleados de una empresa, por ejemplo, en archivos que agrupen a los empleados de las distintas secciones de una sucursal, y a su vez tener un grupo con todas las secciones. Por supuesto estos agrupamientos pueden realizarse en funcin de lo que se desee agrupar y pueden continuarse tanto como sea necesario y se tenga capacidad para hacerlo. Existen distintos tipos de datos; en efecto, las computadoras pueden procesar distintos tipos de informacin, no slo la que representa a los empleados de una empresa tales como el nombre (que son letras), su edad (nmeros), sino tambin puede procesar la foto del empleado (que es una imagen). Es decir, los archivos pueden almacenar datos de distintos tipos. Pese a que podemos almacenar y procesar en una computadora distintos tipos de datos, las computadoras slo almacenan y procesan nmeros. Cmo es esto posible, entonces? Porque las computadoras codifican la informacin que se les da. Transforman, por ejemplo, las letras, las imgenes, los sonidos, en nmeros. Es fcil imaginar cmo es posible esto: por ejemplo podramos codificar las letras del abecedario diciendo que a la letra A le corresponde el nmero uno, a la B el dos y as sucesivamente. Habra que codificar tambin la letra a y todas las minsculas de la misma manera que se codificaron las maysculas. Pero eso no es problema ya que tenemos infinitos nmeros. De esta manera se puede tener, entonces, dentro de una computadora la representacin (la codificacin) de letras, nmeros, smbolos, imgenes, sonidos, etc. Conociendo la codificacin correspondiente se puede restituir la informacin original. De esa manera, por ejemplo, se pueden almacenar nmeros, que surgen de la transformacin y codificacin de sonidos musicales correspondientes a una cancin dada, y luego reproducir dichos sonidos, realizando la transformacin inversa: se descifran (o como algunas veces se dice se decodifican) los nmeros y se los transforma en sonidos. En realidad, si bien las computadoras se han diseado para que empleen nmeros, la notacin de los mismos o el sistema de representacin empleado, no es el decimal, que es el comnmente usado por los seres humanos, sino que por razones tecnolgicas el sistema numrico empleado es el binario. El sistema binario tiene como base el nmero dos, ya que es fcil hacer corresponder, electrnicamente, los dos nicos nmeros que puede emplear (el cero y el uno) con la existencia o no de corriente, o con dos voltajes distintos, etc. Existen distintas formas de codificar los caracteres (letras, dgitos decimales -0 al 9-, smbolos de puntuacin, etc.), dentro de las computadoras. Una de las ms utilizadas en los ltimos tiempos es la llamada ASCII, que se pronuncia asqui y cuyas siglas corresponden a las iniciales de American Standard Comunication Information Interchange. En el Apndice A se muestra una tabla conocida como la tabla ASCII que muestra la correspondiente codificacin para 128 caracteres. Emplea los nmeros del cero al ciento veintisiete (ciento veintiocho cdigos), para lo que se necesitan siete dgitos en la numeracin binaria. La tabla ASCII extendida emplea doscientos cincuenta y seis cdigos, del cero al doscientos cincuenta y cinco, necesitando as ocho dgitos en la numeracin binaria para representar el nmero ms grande de esta codificacin, el 11111111. Como las computadoras slo trabajan con nmeros, las tablas de caracteres, como la ASCII, contienen los cdigos numricos asignados no slo a los caracteres imprimibles como, por ejemplo a o + sino tambin aquellos asociados a caracteres de control como por ejemplo el 10 que corresponde a avanzar una lnea en una impresora. Estos ltimos que son los primeros treinta y dos se conocen como caracteres no imprimibles o de control, es decir que no se los ve. Hoy en da no son muy utilizados, adems la descripcin de los mismos (lo que hacen) no es muy clara ya que la tabla ASCII apareci hace ya mucho tiempo (alrededor de 1963) y se usaba para los teletipos por lo que muchos de esos caracteres no imprimibles eran para acciones propias de los teletipos. Esta tabla es tambin la adoptada por la International Standards Organization (ISO) y se la conoce como ISO 8859 o ISO 10646, que es la nueva norma de ISO para compatibilizarla con UTF-8 que es la norma del consorcio Unicode. Tradicionalmente, entonces, se emplean los ocho dgitos binarios necesarios para representar los caracteres de la tabla ASCII, como un byte. Un byte tendr entonces la capacidad de codificar, o representar, doscientos cincuenta y seis nmeros (del cero al doscientos cincuenta y cinco, generalmente), por lo que necesitar de ocho dgitos binarios. Cada uno de estos dgitos se conoce con el nombre de bit, de binary digit (dgito binario, en ingls, algunos emplean dio, de dgito binario), por lo que generalmente se dice que un byte est compuesto de ocho bits. Otras codificaciones, introducidas para representar otros alfabetos (griego, rabe, cirlico, etc.) tales como Unicode y Conjunto de Caracteres Universal (UCS) ISO/IEC 10646 definen un conjunto de caracteres mucho mayor, y sus diferentes formas de codificacin han empezado a reemplazar ISO 8859 y ASCII rpidamente en muchos entornos.
U.N.S.L. Argentina
12
Las Computadoras
1.4 El funcionamiento
Cada vez que se enciende una computadora, sta solo se dedicar a ejecutar un programa. Esta es la nica tarea que las computadoras saben realizar. Pero sin embargo pueden, o parecen poder, hacer muchas otras cosas. En realidad esta capacidad de realizar las ms diversas tareas es producto de los programas que las computadoras ejecutan. Son los programas los que le dicen a la CPU, y en consecuencia a toda la computadora, qu debe hacer. Sin estos no habra actividad. Utilizaremos indistintamente los trminos programa y sistema. Generalmente la distincin hecha entre ambos es una de cantidad y no de calidad. En efecto, se reserva la palabra sistema para aquellos programas, que adems de constituir una unidad de propsito, son grandes, reservando la palabra programa para los que son ms pequeos. Como las cualidades de grande y pequeo son altamente subjetivas es que emplearemos uno u otro indistintamente. La ejecucin de un programa, instruccin tras instruccin, es tarea propia de la CPU. Estas series de instrucciones le dirn a ella que hacer, no solo con los datos que tenga, sino tambin con los distintas partes y dispositivos que se encuentran formando parte de la computadora. Las instrucciones de los programas, as como los datos sobre los que estas deban actuar, deben encontrarse en la memoria principal de la computadora. Sin embargo, sta puede no tener la capacidad para almacenar, de una sola vez, todas las instrucciones y datos necesarios para la ejecucin de un programa. Esto se resuelve almacenando el programa y sus datos en la memoria auxiliar (discos, cintas, etc.) y trayendo lo necesario (instrucciones y datos) a la memoria principal a medida que se los necesite. El arranque (boot o bootstraping, en ingls) de las computadoras merece un prrafo aparte. En efecto, apenas encendida, la CPU ejecutar instrucciones, pero qu instrucciones? Las necesarias para que de ah en ms la computadora est lista para seguir funcionando. Estas son escogidas juiciosamente por el fabricante de la computadora para que esto suceda y el programa correspondiente es colocado en una parte de la memoria principal para que cada vez que se encienda la computadora comience a funcionar correctamente. Este programa se encargar de traer desde la memoria auxiliar el resto de los programas o sistemas necesarios para continuar con el funcionamiento de la computadora, usualmente el sistema operativo. En muchas computadoras casi el mismo efecto puede lograrse si se tiene un botn o interruptor para efectuar lo que se llama, en ingls, reset, que podemos decir que significa poner a cero las distintas partes de la computadora. Decimos que es casi lo mismo, an cuando internamente no es exactamente lo mismo, porque por ejemplo no se borra la memoria principal de la computadora, cosa que s sucede cuando se la apaga. Podemos decir que, entre los programas o sistemas que se encuentran ms frecuentemente en las computadoras, el ms comn y necesario es el que se conoce como sistema operativo, que es el encargado de administrar y hacer funcionar adecuadamente los distintos dispositivos y partes de la computadora y adems de permitir que otros programas o sistemas puedan servirse de ellas. Sin un programa o sistema que se encargue de estas tareas sera imposible que la computadora pudiese funcionar en forma til. Esto es as an cuando el sistema operativo no sea de uso general, sino orientado a una funcin especfica, porque as lo requiere el destino de la computadora como por ejemplo, un sistema operativo encargado de administrar una computadora encargada del funcionamiento de una mquina de lavar platos. En estos casos, en general, no se habla de sistema operativo sino de un sistema orientado, reservando el trmino sistema operativo para aquellos sistemas de software que sirven para administrar una computadora de uso ms general. Es el sistema operativo el encargado de relacionar y coordinar el funcionamiento y la administracin de la mquina y de sus partes: CPU, memoria, teclado, pantalla, impresora, memoria auxiliar, discos, etc., as como de la administracin de los archivos, directorios, cuentas, etc., que se encuentran en la memoria auxiliar de la computadora. Existen distintos tipos de sistemas operativos. Estn los monousuarios, que administran las computadoras suponiendo que las mismas sern usadas por un solo usuario por vez y los multiusuarios, que administran las computadoras suponiendo que las mismas sern usadas por ms de un usuario por vez. Se los puede clasificar tambin de acuerdo a la cantidad de tareas que pueden realizar a la vez: Los monotarea, que pueden ser monousuario o multiusuario, y que administran las computadoras permitiendo al o a los usuarios de las mismas, realizar slo una actividad o tarea (ejecutar un programa o sistema) por vez, y los multitareas, que pueden ser monousuario o multiusuario, y que administran las computadoras permitiendo al o a los usuarios de las mismas,
U.N.S.L. Argentina
13
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase realizar ms de una actividad o tarea (ejecutar un programa o sistema) por vez.
Las Computadoras
Por supuesto, los sistemas operativos multiusuarios deben permitir que ms de un usuario trabaje sobre la computadora al mismo tiempo. Esto se hace conectando a la mquina terminales, que son dispositivos de entrada y salida formados, generalmente, de un teclado y una pantalla. Habr, entonces, tantos usuarios usando la computadora al mismo tiempo como terminales tenga sta conectadas. Distinto es el caso de las llamadas redes de computadoras donde varias computadoras estn interconectadas entre s y permiten que los usuarios respectivos puedan comunicarse, intercambiando datos. Aqu hay varias computadoras conectadas, y no una sola con varias terminales. El sistema operativo est compuesto de distintas partes, subsistemas o programas que se encargan de las distintas tareas que el sistema operativo debe llevar adelante. Las partes que administran los dispositivos de entrada y salida de datos, de memoria auxiliar, son generalmente conocidas con el nombre genrico, en ingls, de drivers (conductores o chferes) ya que se suponen que conducen a dichos dispositivos. Los sistemas operativos son, en general, propios a una familia de computadoras y varan en sus prestaciones (an cuando todos tengan un conjunto de caractersticas bsicas esenciales) de una computadora a otra, y para las mismas computadoras, de un fabricante a otro. Estn en permanente cambio y actualizacin, no slo para seguir los cambios de las computadoras, sino para corregir defectos. Estas actualizaciones se conocen con el nombre de versiones, que estn generalmente numeradas para indicar su aparicin en el tiempo. Los sistemas operativos son conocidos como software de base, justamente por estar en la base del funcionamiento de las computadoras. Existen otros sistemas o programas que tienen funciones bsicas, an cuando no tan estrictamente necesarias como los sistemas operativos. Ellos son por ejemplo los programas de comunicacin y redes, que permiten a las computadoras comunicarse entre s; de diagnstico de error; etc. Algunas veces dichos sistemas integran de una manera u otra el sistema operativo por lo que tambin son conocidos como software de base. Esto pasa tambin con los compiladores, que son sistemas encargados de traducir los programas escritos en un lenguaje de programacin, al lenguaje que entiende la CPU, para que as, el programa pueda ser ejecutado. Con el nombre global de utilitarios se conocen una serie de sistemas que permiten realizar distintas tareas que ya se han transformado casi en tradicionales en el mbito de la computacin: editores de texto, que como su nombre lo indica permiten a los usuarios de las mquinas, editar (escribir, corregir, cambiar, etc.), con mayor o menor facilidad, un texto. Planillas de clculo, administradores de bases de datos, y otros tambin pueden encuadrarse en esta categora.
1.5 El sistema operativo

El sistema operativo es el programa que permite administrar las distintas partes de la computadora y hace que un usuario pueda realizar esto por medio de comandos, que son rdenes que los usuarios puedan darle para realizar las distintas operaciones. Los comandos son, generalmente, en la mayor parte de los sistemas operativos, de dos tipos: internos y externos. Los internos son aquellos que estn incorporados al ncleo (algunas veces se lo llama kernel, en ingls) del sistema operativo que es la parte central del mismo y podra decirse la que contiene lo mnimo necesario para que la computadora pueda operar. Los externos son aquellos que se pueden ir incorporando, como archivos de programa separados a medida que son necesarios. El sistema operativo, por medio de su ncleo, sin embargo ejecuta todos ellos. Los comandos tienen una sintaxis, una ortografa propia que hay que respetar, ya que le sirve al sistema operativo para reconocerlos. Algunos de estos comandos pueden tener parmetros, es decir objetos sobre los que el comando operar. Por ejemplo, si se desea borrar un archivo, sacarlo del sistema, habr que dar el comando correspondiente y el parmetro ser el nombre del archivo que se desea borrar. Algunos comandos tienen un valor del parmetro por defecto (default, en ingls), es decir que si no se da ningn valor el sistema operativo asume uno. Dentro de los parmetros pueden emplearse caracteres comodines (wild cards, en ingls), que como la carta del juego de cartas as llamada puede tomar cualquier valor. Algunos sistemas operativos permiten que un grupo, o un lote (batch, en ingls), de comandos puedan ser incorporados a un archivo y ejecutados todos, uno detrs del otro, ejecutando el archivo que los contiene como si fuese un programa. Es decir que se pueden armar programas de comandos para que sean ejecutados sin necesidad de
U.N.S.L. Argentina
14
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase entrarlos uno a uno cada vez que se los necesite.
Las Computadoras
Hay sistemas operativos que tienen incorporados mayores facilidades para esto ya que tienen un lenguaje de programacin que va ms all de los comandos, permitiendo realizar gran cantidad de tareas en forma mucho ms gil y dinmica. A lo largo del tiempo, la interfaz del usuario, que es como generalmente se conoce el conjunto de comandos que permiten que los usuarios y el sistema operativo se relacionen, ha cambiado. De los sistemas operativos basados en comandos escritos se ha pasado a comandos puramente grficos, simblicos, que representan sus comandos por medio de iconos, pequeas figuras que representan simblicamente la accin deseada. Estas interfaces son conocidas como GUI, de las siglas en ingls Graphical Users Interface (Interfaz Grfica del Usuario). En algunos casos, cuando los sistemas operativos no han sido diseados originalmente con este tipo de interfaz, se agrega dicha interfaz al sistema operativo como una cscara (shell, en ingls) alrededor o por encima del sistema operativo. Los sistemas operativos para que funcionen sobre una computadora determinada deben conocer como esta est compuesta, deben conocer su configuracin, las partes que la componen y sus caractersticas. De esta manera el sistema operativo podr incorporar los drivers correspondientes a cada dispositivo que necesite administrar. Muchas veces todas estas caractersticas estarn agrupadas en un archivo que se conoce con el nombre genrico de archivo de configuracin o de instalacin. Cada dispositivo podr tener, adems de su nombre fsico (por ejemplo: disco, marca, modelo, etc.), un nombre lgico (por ejemplo: pepe), que le servir al sistema operativo para reconocerlo cuando los usuarios lo nombren. Todas las tareas que sirven para definirle la computadora y sus partes al sistema operativo y cmo se quiere que funcionen, se conocen generalmente con el nombre de instalacin, ya que la operacin es la instalacin del sistema operativo en la computadora. Cada vez que la computadora arranque empezar a funcionar ejecutando el sistema operativo. Este a su vez deber realizar una serie de acciones llamadas de inicializacin, que le permitirn seguir funcionando. Muchos sistemas operativos permiten que los usuarios puedan definir algunas acciones iniciales para que puedan ejecutarse en el momento del arranque. Estos son archivos especiales, de comandos, que el sistema operativo reconoce que deben ejecutarse inicialmente, en el arranque de la mquina.
U.N.S.L. Argentina
15
Lgica
CAPTULO 2 LGICA
2.1 Introduccin
La Lgica es una disciplina que tiene una larga tradicin. Muchos autores consideran a Aristteles (384 a.c. 322 a.c.) como el creador, o como uno de los primeros pensadores, que sistemticamente realiz una exposicin y uso formal de una metodologa de razonamiento que puede entenderse que es propia del mbito de la Lgica. Posteriormente, especialmente desde el siglo XIX, con George Boole (18151864), la Lgica se formaliza y adquiere herramientas algebraicas que le permiten manipular smbolos y conceptos. El Diccionario de la Real Academia la define: lgica. (Del lat. logca, y este del gr. o). f. Ciencia que expone las leyes, modos y formas del conocimiento cientfico. || 2. Tratado de esta ciencia. Escribi una lgica que fue muy comentada. || ~ borrosa, o ~ difusa. f. La que admite una cierta incertidumbre entre la verdad o falsedad de sus proposiciones, a semejanza del raciocinio humano. || ~ formal, o ~ matemtica. f. La que opera utilizando un lenguaje simblico artificial y haciendo abstraccin de los contenidos. || ~ natural. f. Disposicin natural para discurrir con acierto sin el auxilio de la ciencia. || ~ parda. f. coloq. gramtica parda. Aunque hay muchas otras definiciones y explicaciones sobre qu es la Lgica (quizs tantas como autores hay que se dedican a ella), podemos decir, por lo menos en una introduccin como esta, que la Lgica es la ciencia o la disciplina que estudia la forma de exponer argumentos. Qu es un argumento? Segn la Real Academia un argumento es: argumento. (Del lat. argumentum). m. Razonamiento que se emplea para probar o demostrar una proposicin, o bien para convencer a alguien de aquello que se afirma o se niega. Hay muchas lgicas, o quizs mejor dicho, muchas ramas de la Lgica. Nosotros nos limitaremos en ste captulo a dar una breve introduccin a una de las formas ms sencillas de ella: la llamada Lgica Proposicional. Esta Lgica, por emplear un lenguaje formal muy cercano al lenguaje de la Matemtica, juega un papel fundamental en la Ciencia de la Computacin y por ende en Programacin. Es por ello que antes de comenzar a ver qu es programar es necesario tener una idea bsica de Lgica Proposicional. Aquellos familiarizados con el tema pueden saltar este captulo.
2.2 Proposiciones
Llamaremos proposicin (o enunciado, o enunciado proposicional) a toda expresin del lenguaje para la cual tenga sentido uno y slo uno de los valores siguientes: Verdadero o Falso Es decir, que se pueda afirmar sobre dicha expresin que es verdadera o falsa, pero no ambas. La Lgica Proposicional es una lgica bivalente, porque acepta slo dos valores: Verdadero y Falso. Hay lgicas multivalentes (o multivaluadas) que aceptan tres o ms valores. Por ejemplo, son proposiciones: a) Si se aade cido sulfrico al agua, se obtiene una camioneta.
b) 2 + 2 = 4 c) 3+2=4
d) 3 es mltiplo de 8 e) Todos los estudiantes de computacin estn preocupados por el hambre y el desempleo que hay en nuestro pas. 16 Departamento de Informtica
U.N.S.L. Argentina
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase En cambio no son proposiciones, las siguientes: f) Qu distancia hay de la Tierra a la Luna?
Lgica
g) Qu fro! h) La Ctedra de programacin. i) j) 3 + x = 16 x - 3y + 6 = 0
Las expresiones f) a j) no son proposiciones porque no es posible afirmar si ellas son verdaderas o falsas. Sin embargo las expresiones i) y j) pueden llegar a transformarse en enunciados proposicionales si se le asignan valores a las variables x e y. Slo haciendo ese reemplazo podremos afirmar que esas expresiones son verdaderas o falsas y que por lo tanto son proposiciones. A x e y se les denomina variables de objeto, y las expresiones que las contienen se llaman funciones proposicionales. Es decir, que las expresiones i) y j) son funciones proposicionales que, cuando se les da valores a las variables x e y, se transforman en proposiciones. Para referirnos a un enunciado cualquiera utilizaremos las letras p, q, r, s, t, etc. Las llamaremos variables de enunciados o variables proposicionales. Estas variables proposicionales, entonces, pueden representar cualquier proposicin que pueda tomar el valor Verdadero o Falso. Se llama valor de verdad de una proposicin al valor Verdadero o Falso que la misma tiene. As, por ejemplo, el valor de verdad de la proposicin 3 > 4 es Falso. Est claro que si se habla, por ejemplo, de la variable proposicional p, ella no es de por s ni verdadera ni falsa. Lo ser recin cuando se le d una interpretacin, o sea cuando se reemplace p por una proposicin concreta, aunque s podemos afirmar que, por ser p una variable proposicional, ella puede tomar uno de los dos valores: Verdadero o Falso. Por ejemplo, si p es reemplazada por la frase todos los gatos son negros, su valor ser Falso, pero si a p le asignamos el significado de el cigarrillo es perjudicial para la salud, su valor ser verdadero ya que, luego de estudios realizados recientemente, se habra descubierto una relacin qumica no estadstica entre la combustin del tabaco y el cncer de pulmn. Sin embargo, las manipulaciones y aseveraciones que veremos ms adelante en ste captulo, son independientes de la verdad o falsedad de las proposiciones involucradas. Dichas manipulaciones y aseveraciones son tiles por la forma misma que tienen, independientemente del significado que se asigne a ellas, por eso es que podemos reemplazar proposiciones concretas por smbolos (las letras p, q, r, s, t, etc., en nuestro caso) y las manipulaciones y aseveraciones que hagamos con ellas seguirn siendo equivalentes a las que podamos hacer con proposiciones concretas. Muchos lgicos distinguen entre validez y valor de verdad. La validez queda reservada para los argumentos (o razonamientos), mientras que el valor de verdad es para las proposiciones. Siendo que en esta introduccin slo trataremos con proposiciones no veremos nada sobre validez. Emplearemos como smbolos para Verdadero una V y para Falso una F. Por supuesto que dos smbolos cualesquiera pueden emplearse para ello, aunque, obviamente, una vez elegidos no pueden intercambiarse. As, tambin, se emplean True (en Ingls) para Verdadero y False (en Ingls) para Falso, o T y F respectivamente. Muchas veces se emplean tambin los dgitos 1 y 0. Cualquiera de ellos pueden emplearse como sinnimos: Verdadero, True, T, V, 1, y por otro lado: False, F, 0.
2.3 Operadores, conectivas o funtores

Las proposiciones vistas hasta ahora son proposiciones simples. Las proposiciones complejas o compuestas son aquellas que se forman empleando dos proposiciones que se encuentran relacionadas entre s por un operador, funtor o conectiva lgica. Cada una de estas proposiciones puede ser, a su vez simple o compuesta. En el lenguaje comn hay ciertas partculas gramaticales que se usan para conectar dos enunciados, dando as origen a un nuevo enunciado, compuesto de los otros dos, ms la partcula gramatical que los une. Lo mismo se puede hacer con las proposiciones en la Lgica.
U.N.S.L. Argentina
17
Lgica
El valor de verdad de este nuevo enunciado lgico depende del (o tambin podemos decir es funcin del) valor de verdad de los enunciados que se unen junto con el significado que tiene la partcula que los une. Estas partculas se denominan, en Lgica, funtores o funtores de verdad. Tambin se los conoce como operadores lgicos o conectivas lgicas. Podemos, entonces, decir que si p,q son enunciados o proposiciones, entonces tambin lo son: pyq poq
El valor de verdad de estas proposiciones compuestas depende del valor de p y de q como as tambin del sentido o significado que le demos a y y a o. En el lenguaje natural (por ejemplo el castellano) la interpretacin de una expresin lingstica no siempre es nica, puede ser ambigua. En la Matemtica (la que incluye la Lgica que estamos exponiendo), por el contrario, el lenguaje empleado es no ambiguo (a menos que haya un error), es decir que cada expresin tiene una nica interpretacin. Las proposiciones compuestas tambin se las llaman expresiones lgicas. Seguiremos usando las letras p, q, r, s, t, etc. para denotar proposiciones simples o compuestas de aqu en ms. De resultar necesario distinguir entre proposiciones simples o compuestas, utilizaremos las minsculas (p, q, r, s, t, etc.) para las simples y maysculas (P, Q, R, S, T, etc.) para las expresiones lgicas o proposiciones compuestas. Tambin emplearemos parntesis: ( ), cuando sea necesario para evitar ambigedades en los casos de proposiciones compuestas. Las conectivas lgicas relacionan dos (no ms ni menos), proposiciones entre s. Asumiendo, como dijimos, que estas proposiciones pueden tener dos valores posibles (verdadero o falso), y si, como dijimos, la relacin de dos proposiciones por medio de una conectiva puede tener uno de dos valores posibles (verdadero o falso), las posibles conectivas no pueden ser ms de diecisis. Sin embargo, no todas estas combinaciones son interesantes. En realidad, utilizando manipulaciones algebraicas, puede demostrarse que con solo una de ellas pueden representarse todas las otras (hay dos que permiten esto). Sin embargo esto sera poco prctico en el uso corriente, por lo que en general se consideran unas cuantas ms, que son las que trataremos a continuacin. p V F
El significado de las conectivas se establece a travs de lo que se llama tabla de verdad Figura 2.1 para la conectiva dada. Una tabla de verdad es una lista completa de todos los valores de verdad posibles de una proposicin (simple o compuesta). As, por ejemplo, la tabla de verdad de una proposicin p es la que se muestra en la Figura 2.1. Entonces, por medio de una tabla se establece qu valores (verdadero o falso) puede tomar la nueva proposicin (compuesta de dos proposiciones ms la conectiva), teniendo en cuenta qu valores tienen cada una de las proposiciones que la conforman. Por supuesto, es necesario que todos los casos posibles de valores de verdad para cada una de las proposiciones queden establecidos. De ahora en ms denotaremos con V el valor verdadero de una proposicin y con F el valor falso. Si en Lgica las expresiones tienen una nica interpretacin o significado (pueden tomar un solo valor: verdadero o falso), daremos, entonces, un nico significado a las conectivas (partculas) y y o. p V V q V F V F
pq V F F F
Conjuncin
Llamaremos conjuncin a la conectiva y. Emplearemos el smbolo para denotarla. Esta conectiva se conoce en Ingls como and. La tabla de verdad para la conjuncin es la que se muestra en la Figura 2.2.
F F
Figura 2.2. Tabla de verdad de la conjuncin
O sea que p q es verdadero (V) solamente cuando ambas p y q son verdaderas. En otras palabras, cuando la
U.N.S.L. Argentina
18
Lgica
proposicin p es verdadera y la proposicin q es verdadera. La proposicin p q ser falsa (F) en todos los otros casos: ya sea que p o q sean ambas falsas o que una cualquiera lo sea. Ejemplos: 1) (2 < 3) (13 < 20) es verdadero (V) pues (2 < 3) es verdadero (V) y (13 < 20) tambin es verdadero (V). 2) (2 < 3) (6 2 = 20) es falso (F) pues si bien (2 < 3) es verdadero (V), (6 2 = 20) es falso (F).
Disyuncin
La conectiva o se la conoce como disyuncin. Esta conectiva, tiene, sin embargo, en el lenguaje natural, dos interpretaciones: una incluyente y otra excluyente, emplendose en ambos casos el mismo smbolo (o), lo que se presta, en ms de una ocasin a ambigedades de interpretacin. Esta ambigedad no es posible en la Lgica. Esto nos obliga a tener dos smbolos para cada caso, y en consecuencia dos Tablas de Verdad distintas. Emplearemos el smbolo para denotar la conectiva o incluyente, con la tabla de verdad que se ve en la Figura 2.3. En Ingls se la conoce como or. Decimos, entonces, que p q es verdadero (V) cuando ya sea p o q es verdadero o ambas lo son. Ejemplos: 1) (2 < 3) (13 < 20) es verdadero (V) pues (2 < 3) es verdadero (V) y (13 < 20) tambin es verdadero (V). 2) (2 < 3) (6 2 = 20) es verdadero (V) pues (2 < 3) es verdadero (V), y no importa que (6 2 = 20) es falso (F). Vase la diferencia entre este ejemplo y el mismo pero para la conectiva . El smbolo generalmente empleado para la conectiva o excluyente es tambin usados. La tabla de verdad para ella es la que se muestra en la Figura 2.4. Vemos que p q es verdadero (V) slo cuando o p es verdadero o q es verdadero, no cuando ambas lo son. Ejemplos: 1) (2 < 3) (13 < 20) es falso (F) pues (2 < 3) es verdadero (V) y (13 < 20) tambin es verdadero (V).Vase la diferencia entre este ejemplo y el mismo pero para la conectiva . 2) (2 < 3) (6 2 = 20) es verdadero (V) pues (2 < 3) es verdadero (V), y (6 2 = 20) es falso (F). Es interesante comparar ambas Tablas para detectar la diferencia entre ellas. En sentido incluyente p o q (p q) es verdadero (V) si ambas proposiciones son verdaderas o si una sola de ellas lo es. Si ambas son falsas, entonces p q ser falso (F). En sentido excluyente p o q (p q) es verdadero (V) si una sola de ellas lo es. Si ambas son falsas, o si ambas son verdaderas, entonces p q ser falso (F). p V V F F q V F V F pq V V V F
Figura 2.3. Tabla de verdad de la disjuncin (o) incluyente
. Sin embargo los smbolos ; son

p V V F F q V F V F pq F V V F
Figura 2.4. Tabla de verdad de la disjuncin (o) excluyente
U.N.S.L. Argentina
19
Lgica
Condicional o implicacin
Otro funtores o conectiva interesante es la llamada condicional o implicacin. El smbolo empleado comnmente para representar esta conectiva es . La tabla de verdad es la que muestra la Figura 2.5. A la primera proposicin (p) se la denomina antecedente. A la segunda proposicin (q) se la denomina consecuente. El condicional es falso (F) solo cuando el antecedente es verdadero (V) y el consecuente es falso (F). En todos los otros casos el condicional es verdadero (V). Especial atencin merece el hecho que si p q es verdadero (V) no implica nada sobre los valores de verdad de p y de q, estos pueden ser verdaderos o falsos. Sin embargo, si el antecedente es verdadero la implicacin ser verdadera si el consecuente es tambin verdadero. Esto debe interpretarse como que de una verdad no puede deducirse una falsedad. Ejemplos: 1) (2 < 3) (13 < 20) es verdadero (V) pues (2 < 3) es verdadero (V) y (13 < 20) tambin es verdadero (V). 2) (2 < 3) (6 2 = 20) es falso (F) pues (2 < 3) es verdadero (V), y (6 2 = 20) es falso (F). Hasta ahora las conectivas mostradas tienen una tabla de verdad que es deducible intuitivamente: la conjuncin es verdadera solo si ambas proposiciones lo son, la disyuncin es verdadera cuando alguna de las dos proposiciones es verdadera o ambas lo son. Sin embargo, la tabla de verdad de la implicacin no es deducible tan intuitivamente como las otras dos. La implicacin puede expresarse de varias maneras en Castellano, por ejemplo: (a) si p entonces q, (b) p implica q, (c) p es condicin suficiente de q, (d) q es condicin necesaria de p, (e) p solo si q, (f) q si p. As, cuando la implicacin tiene el valor de verdad verdadero podemos afirmar que: Si p es verdadero entonces q es verdadero, pero esta es una afirmacin condicional. En efecto no afirmamos que siempre que p es verdadero q tambin lo es. Decimos, afirmamos, con el condicional, que cuando la implicacin tiene el valor de verdad verdadero, SI p es verdadero ENTONCES q tambin es verdadero. Esto se abrevia muchas veces diciendo Si p entonces q. Es interesante la expresin (e) ms arriba que nos dice que si la implicacin es verdadera, p es verdadera slo si q tambin es verdadera. Importantes son tambin las expresiones (c) y (d) que nos muestran con precisin cules son los casos de condiciones necesarias y suficientes. p V V F F q V F V F pq V F V V
Figura 2.5. Tabla de verdad del condicional
Condicin suficiente y condicin necesaria

Dados p y q, decimos que p es una condicin suficiente de q cuando la verdad de p garantiza la verdad de q. Por el contrario, q es condicin necesaria de p cuando la falsedad de q garantiza la falsedad de p. Diremos entonces que, en la implicacin, el antecedente es condicin suficiente del consecuente y que el consecuente es condicin necesaria del antecedente. Entonces p solo si q asevera que q es condicin necesaria de p. Entonces podemos decir que en la implicacin, la condicin necesaria del antecedente es el consecuente de dicha implicacin.
U.N.S.L. Argentina
20
Lgica
Bicondicional o equivalencia
Otro funtor o conectiva, es la llamada bicondicional o equivalencia. El smbolo empleado comnmente para representar esta conectiva es . Tambin se emplea el smbolo . La tabla de verdad es la que muestra la Figura 2.6. p q pq El bicondicional es verdadero (V) solamente (si y solo si) ambas V V V proposiciones son verdaderas o falsas, al mismo tiempo. Ejemplos: 1) (2 < 3) (13 < 20) es verdadero (V) pues (2 < 3) es verdadero (V) y (13 < 20) tambin es verdadero (V). 2) (2 < 3) (6 2 = 20) es falso (F) pues (2 < 3) es verdadero (V), y (6 2 = 20) es falso (F). V F F F V F F F V
Figura 2.6. Tabla de verdad del bicondicional
Nuevamente, como en el caso de la implicacin, nos encontramos con una afirmacin condicionada: cuando la equivalencia tiene el valor de verdad verdadero, p es verdadero SI Y SOLO SI q tambin es verdadero. Si y solo si se suele abreviar como sii. Podemos abreviar todo esto diciendo: p sii q. Algunas veces esta conectiva se expresa tambin: Si y solo si p es verdadero entonces q es verdadero. Es de hacer notar que (p q) = (p q) (q p) Esto puede comprobarse con la tabla de verdad de la Figura 2.7. p V V q V F V pq V F V qp V V F (p q) (q p) V F F
egacin
Toda proposicin puede ser negada, es decir que si F F V V V podemos afirmar, por ejemplo, est lloviendo, pudiendo ser esta proposicin verdadera o falsa, Figura 2.7. tambin podemos afirmar no est lloviendo, y esta proposicin tambin puede ser verdadera p ~p o falsa. Decimos que toda proposicin puede ser negada y hacemos esto V F anteponiendo a la proposicin el operador no. F V Este operador no relaciona dos proposiciones, sino que afecta a una sola proposicin. Se podra decir que los funtores vistos hasta ahora (conjuncin, disyuncin, condicional y bicondicional) son binarios porque afectan (relacionan) dos proposiciones, mientras que la negacin es unaria, porque solo afecta una proposicin. As, si p es una proposicin, no p tambin lo es. Este operador se denota con el smbolo ~ (muchas veces tambin se usa el smbolo ) La tabla de verdad es la que muestra la Figura 2.8.
Figura 2.8. Tabla de verdad de la negacin
2.4 Equivalencias lgicas

Llamamos tautologa a toda expresin compuesta cuyo valor de verdad es siempre verdadero cualquiera sea el valor de verdad de las proposiciones que la componen. Llamamos contradiccin a toda expresin compuesta que es siempre falsa cualquiera sea el valor de verdad de las proposiciones que la componen. A aquellas expresiones que pueden ser verdaderas o falsas de acuerdo con el valor de verdad de las proposiciones que la componen se las denominan contingentes.
U.N.S.L. Argentina
21
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase Sea P una expresin lgica, si P es una tautologa entonces ~P es una contradiccin y viceversa.
Lgica
La forma de determinar si una expresin lgica es una tautologa o una contradiccin es analizando la correspondiente expresin empleando la tabla de verdad. Tautologas y equivalencias lgicas son muy tiles para operar y simplificar expresiones lgicas complejas. Sean P, Q, R, expresiones lgicas. Algunas de las tautologas y equivalencias lgicas ms comunes son las siguientes: Tautologas Bsicas P (~P) P P PP (P Q) P
Identidad P V=P PF=P
Doble egacin ~ (~ P) = P
Conmutatividad P
Q = Q
Q = Q
P Q = Q P
Asociatividad (P Q) R = P (Q R) (P Q) R = P (Q R) (P
Q) R = P
(Q R)
Distributividad P (Q R) = (P Q) (P R) P (Q R) = (P
Q)
(P R)
Leyes de DeMorgan ~ (P Q) = ~ P ~ Q ~ (P Q) = ~ P ~ Q
(P Q) ( Q R) (P R)
Transitividad
(P Q) (Q R) (P R)
U.N.S.L. Argentina
22
A. Dasso, A. Funes ntroduccin a la Programacin Notas de Clase
Programar
CAPTULO 3 PROGRAMAR
3.1 Introduccin
Qu es programar? La Real Academia de la Lengua Espaola (http://www.rae.es/) da la siguiente definicin: programar tr. Formar programas, previa declaracin de lo que se piensa hacer y anuncio de las partes de que se ha de componer un acto o espectculo o una serie de ellos. || 2. Idear y ordenar las acciones necesarias para realizar un proyecto. U. t. c. prnl. || 3. Preparar ciertas mquinas por anticipado para que empiecen a funcionar en el momento previsto. || 4. Preparar los datos previos indispensables para obtener la solucin de un problema mediante una calculadora electrnica. || 5. Inform. Elaborar programas para la resolucin de problemas mediante ordenadores. || 6. Mat. Optimar el valor de una funcin de muchas variables cuyos valores extremos son conocidos. Vemos que la acepcin 5 hace referencia a la Informtica y es la que se aplica especficamente en nuestro caso. Sin embargo la primera acepcin es interesante tambin: Formar programas, previa declaracin de lo que se piensa hacer y anuncio de las partes de que se ha de componer un acto o espectculo o una serie de ellos. An cuando no haya una referencia directa a la Informtica, la actividad de programacin est directamente relacionada con muchos aspectos de la vida corriente, no slo con la Informtica. Si programar es Formar programas ..., qu es un programa? Nuevamente la Real Academia de la Lengua Espaola nos puede ayudar: programa. (Del lat. programma, y este del gr. ). m. Edicto, bando o aviso pblico. || 2. Previa declaracin de lo que se piensa hacer en alguna materia u ocasin. || 3. Tema que se da para un discurso, diseo, cuadro, etc. || 4. Sistema y distribucin de las materias de un curso o asignatura, que forman y publican los profesores encargados de explicarlas. || 5. Anuncio o exposicin de las partes de que se han de componer ciertos actos o espectculos o de las condiciones a que han de sujetarse, reparto, etc. || 6. Impreso que contiene este anuncio. || 7. Proyecto ordenado de actividades. || 8. Serie ordenada de operaciones necesarias para llevar a cabo un proyecto. || 9. Serie de las distintas unidades temticas que constituyen una emisin de radio o de televisin. || 10. Cada una de dichas unidades temticas. Va a comenzar el programa deportivo. || 11. Cada una de las operaciones que, en un orden determinado, ejecutan ciertas mquinas. || 12. Inform. Conjunto unitario de instrucciones que permite a un ordenador realizar funciones diversas, como el tratamiento de textos, el diseo de grficos, la resolucin de problemas matemticos, el manejo de bancos de datos, etc. || 13. coloq. Ecuad. y Ur. Relacin amorosa furtiva y pasajera. || 14. coloq. Ur. Cita amorosa. || 15. coloq. Ur. Persona con quien se tienen relaciones sexuales pasajeras. || ~ continuo. m. sesin continua. Si bien la acepcin 12 es la que corresponde a Informtica, otras acepciones pueden ser tiles para entender mejor qu es un programa. Vase, por ejemplo, las acepciones 7, 8, 11. Entendemos fcilmente cuando alguien habla de programar un viaje, programar una fiesta, etc. Se hace un programa, se programa una serie de actividades y una lista de las cosas que sern necesarias para lograr un objetivo dado. As, si lo que se programa es una fiesta, ser necesario pensar en las bebidas, en la comida, vajilla, etc. y en las actividades, acciones para obtener esas cosas, as como en las acciones a realizar con ellas. En todos los casos hay un conjunto de elementos a tener en cuenta para llevar a buen puerto la actividad que se programa: (a) acciones a realizar, algunas veces en un orden determinado, una despus de otra o inclusive algunas que pueden desarrollarse simultneamente; (b) objetos sobre los cuales se ejecutarn las acciones. Por ejemplo, en el caso de programar una fiesta una accin ser la de invitar a un grupo de personas (en este caso el objeto sobre el cual se ejecuta la accin es el conjunto de personas);
U.N.S.L. Argentina
23
Programar
(c) y algo que es tan obvio que algunas veces se pasa por alto: quien ejecutar, quien llevar a la prctica el programa. Es de hacer notar que cualquiera sea la actividad que uno est programando (por ejemplo, organizar un viaje, hacer una torta, etc.) lo primero que hacemos o preparamos es un programa de la misma antes de que el mismo sea puesto en ejecucin. Hay tambin que pensar que hay programas y programas: algunos ms complejos y/o largos que otros y que necesitan una mejor y ms afinada preparacin. Es as como podemos distinguir dos etapas en cualquier actividad programable: (1) el diseo, preparacin, planificacin, o creacin del programa en s mismo; (2) la ejecucin o puesta en prctica del programa. Muchas veces, cuando creamos un programa, lo hacemos slo en nuestra mente, es decir sin necesidad de anotar nada. Esto ocurre, generalmente, en aquellos casos en que las tareas a llevar a cabo son pocas y sencillas, y en consecuencia no se corre el riesgo de olvidar ningn paso. Esto presupone, por supuesto, que quien va a llevar a la prctica el programa, es decir, lo va a ejecutar, es la misma persona que lo dise. Por el contrario, si el programa es largo, complejo y/o quien o quienes debern llevarlo a la prctica no son los mismos que quienes lo han diseado, entonces habr que tomar nota paso a paso de todas las actividades que deben ser llevadas a cabo, es decir, escribir un programa, no slo para no olvidar ninguna accin a realizar, ni objeto con el que haya que trabajar, sino, sobre todo, por si resulta necesario darle a alguien las instrucciones para llevar a cabo la actividad para la cual se ha hecho el programa. Al dar las instrucciones habr que ser extremadamente cuidadoso. En efecto, si uno espera que su programa se lleve a cabo con xito, debe asegurarse que quienes lo ejecuten entiendan perfectamente las instrucciones que se les dan. Deberemos elegir el idioma, o lenguaje, en que escribiremos las rdenes, as como las palabras empleadas, evitando usar un idioma desconocido para quien ejecutar el programa, as como palabras o giros idiomticos incomprensibles para dichas personas. Es decir que estaremos obligados a usar un lenguaje que la o las personas, que ejecutarn nuestro programa, entiendan. Obviamente, el programa que hagamos no deber tener ningn tipo de error si queremos que sea un xito; ni errores en su redaccin, que puedan causar que el mismo no sea comprendido por quienes deben ejecutarlo; ni errores en su concepcin, que impliquen que an cuando el programa se ejecute correctamente, es decir de acuerdo con las instrucciones dadas, el resultado no sea el esperado sino otro muy distinto o incluso que debido a los errores no pueda ser llevado a la prctica. En consecuencia hay dos aspectos importantes a tener en cuenta: (1) El lenguaje que se emplear para escribir el programa. (2) La correccin del programa. Es importante no slo elegir un lenguaje adecuado, que sea comprensible por quienes van a ejecutar el programa y que no permita ambigedades, es decir, interpretaciones mltiples, sino tambin es importante el uso que hagamos de este lenguaje. Con esto queremos decir que, en nuestros programas, no deben existir errores de escritura (ortografa) ni de uso incorrecto de la gramtica del lenguaje (sintaxis). Tambin es importante la correccin del programa. Esto significa que el programa que hagamos, las actividades programadas, los objetos empleados, son aquellos que nos llevarn al resultado esperado. Es decir que las acciones programadas y el orden en el cual las mismas deben ser llevadas a cabo son las correctas para lograr nuestro objetivo. Ms de una vez, una actividad planificada de antemano no resulta como se esperaba porque se comenten errores en la planificacin de la misma, en la programacin de ella ya que alguna actividad estaba de ms, o faltaba una actividad o se hizo una actividad en lugar de otra, o no se usaron los objetos correctos y necesarios para la actividad programada, o se los emplearon de manera incorrecta, etc. Por supuesto, los errores en los resultados, tambin pueden deberse a mala interpretacin, o a una incorrecta ejecucin de los encargados de llevar a la prctica (ejecutar) el programa. Resumiendo, podemos decir que la actividad de programar tiene las siguientes caractersticas: (1) Hay acciones a realizar, la mayor parte de las veces en un orden determinado.
U.N.S.L. Argentina
24
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase (2) Hay objetos o cosas sobre los que las acciones se realizan. (3) Existen uno o ms ejecutores del programa. (4) Hay dos etapas bien distinguidas en una actividad programable:
Programar
(a) La programacin, que es la preparacin o planificacin del programa. En esta etapa las acciones y los objetos slo se definen, no es necesario que los mismos existan. As, los objetos necesarios para realizar las acciones se representarn de alguna manera y a dicha representacin abstracta le llamaremos datos. (b) La ejecucin del programa, que es la puesta en prctica del mismo. En esta etapa las acciones se ejecutan. (5) Es necesario un lenguaje para describir el programa, las acciones y los objetos del programa. Este lenguaje debe tener las siguientes caractersticas: (a) Ser entendible, conocido, por el ejecutor del programa. (b) o permitir, en lo posible, ambigedades en su empleo. (6) En la programacin es necesario: (a) Evitar errores de concepcin, de la lgica, del programa; errores que lleven a un resultado distinto del esperado, an cuando el programa se ejecute correctamente. (b) Evitar errores de redaccin, de escritura, de sintaxis, del programa; errores de uso incorrecto del lenguaje de programacin, que impidan que el ejecutor del programa entienda el mismo.
3.2 Programacin de computadoras

La programacin de computadoras comparte todas las caractersticas antes enunciadas. Un aspecto importante es, sin embargo, que quien ejecuta el programa es una mquina. En consecuencia el lenguaje empleado para programar debe ser el que la mquina entienda. El uso del lenguaje de programacin, la atencin con la sintaxis, debe ser mucho ms cuidadosa, ya que la mquina, la computadora, es mucho ms estricta y rigurosa que un ser humano y, por eso mismo, menos tolerante con los errores sintcticos y ms dispuesta a la ejecucin literal del programa. Por otro, lado las computadoras no pueden entender, por lo menos por el momento, los lenguajes naturales que son los empleados por los seres humanos. Entienden, si sta palabra puede ser aplicada a mquinas, un lenguaje bastante ms restringido, ms simple, pero al mismo tiempo ms estricto y riguroso en su sintaxis que los lenguajes empleados por el hombre. Los lenguajes de programacin empleados para las computadoras han evolucionado y siguen evolucionando, tratando de hacerlos ms fciles en su uso y al mismo tiempo incorporando principios y tcnicas de programacin que no solo hagan a sta ms fcil sino menos sujeta a errores. En efecto, la atencin a los detalles en la programacin, y sobre todo la cantidad de acciones a describir en un programa para una computadora, hace necesario el uso de tcnicas de programacin orientadas a evitar programas con errores. En algunos casos, estas tcnicas se incorporan a los lenguajes de programacin, en otros slo son reglas empricas o heursticas a seguir en la confeccin de programas para evitar los errores.
3.3 Programacin y resolucin de problemas

Muchas veces, se conoce cmo obtener un resultado. Se sabe cmo programar una serie de actividades, con el objetivo de alcanzar un resultado. El algoritmo es algo conocido y solo debemos repetir los pasos y acciones, empleando los objetos indicados para conseguir el resultado deseado. En estos casos, el problema ya est resuelto de antemano y solo hay que echar mano a la solucin conocida, es decir, hay que llevar a la prctica, ejecutar, dicha solucin. Otras veces si bien se conoce el objetivo que se desea, no se conoce la forma de alcanzarlo. Los pasos y acciones
U.N.S.L. Argentina
25
Programar
as como los objetos necesarios para obtenerlo, son desconocidos total o parcialmente. En estos casos, el problema no est resuelto y por el contrario debe encontrarse una solucin para el mismo. En el primer caso existe un programa, o un algoritmo (que es otra palabra que puede emplearse) conocido que resuelve el problema y solo hay que aplicarlo; es decir seguir, ejecutar, los pasos indicados en el algoritmo o programa. En el segundo caso el algoritmo no existe. No hay una solucin conocida al problema planteado para obtener el resultado esperado y la solucin debe descubrirse. Hay que resolver el problema, encontrar la secuencia de pasos, acciones y las cosas y objetos necesarios, para obtener el algoritmo o programa que nos permita alcanzar el resultado. En general reservaremos el trmino algoritmo para una secuencia de instrucciones u rdenes encaminadas a dar la solucin de un problema, escritas en un lenguaje no ambiguo cercano al de los seres humanos. La palabra programa ser la secuencia de instrucciones u rdenes encaminadas a dar la solucin de un problema, escritas en un lenguaje cercano a las mquinas, generalmente llamado lenguaje de programacin. La programacin est ntimamente ligada a la resolucin de problemas. En caso que el algoritmo exista, solo se lo debe copiar y seguir sus indicaciones para obtener el resultado deseado. Por ejemplo, se conoce el algoritmo (ingredientes y pasos necesarios) para obtener cido acetilsaliclico (la vulgar aspirina), solo hay que seguir dicha receta o programa o algoritmo para fabricarlo. Se conocen los pasos necesarios para demostrar que existe una 2 2 2 solucin para la ecuacin x + y = z (Teorema de Pitgoras!). Pero se desconoce, lamentablemente hasta el momento, una cura definitiva contra el SIDA. No existe un programa o algoritmo conocido que nos permita producirla. Este es un problema que debe resolverse, es un algoritmo que debe descubrirse si se quiere alcanzar el resultado deseado de una cura del SIDA. Asimismo, se desconocen los pasos necesarios para demostrar que si n es un entero mayor que 2 no hay solucin posible en los n n n enteros positivos a la ecuacin x + y = z ; an cuando Pierre de Fermat, en el siglo XVII dijo haber encontrado la solucin pero nunca se encontr nada escrito. Yoichi Miyaoka, en 1988, pareci encontrarla, pero su demostracin tena un error. Andrew Wiles, en 1993, parece haber encontrado la solucin. Tendr un error su solucin? Lamentablemente (o quizs deba decirse por suerte!, quin sabe) no existe un algoritmo conocido que nos permita resolver problemas, cualquier problema. La resolucin de problemas es un mbito reservado a la inteligencia y habilidad de los seres vivos. Es, se podra decir, un arte. Existen, sin embargo, mtodos y tcnicas que pueden ayudar a resolver problemas. Algunas de orden muy general otras de aplicacin a casos particulares. La programacin tiene como objetivo fundamental expresar en un lenguaje entendible por la computadora un algoritmo o solucin a un problema dado, es decir, producir un programa. Muchas veces, nos enfrentaremos con problemas inditos, es decir problemas cuya solucin se desconoce. Por supuesto, la mayor parte de las veces la solucin es relativamente simple y puede obtenerse aplicando, por analoga, soluciones de problemas similares. Otras veces consiste en juntar las soluciones de varios problemas, ya resueltos, para obtener una nueva solucin
3.4 El proceso de resolucin de problemas

Introduccin
Si programar implica resolver problemas, veamos un poco ms de cerca qu significa esto. Un problema, dice nuestro viejo amigo, el Diccionario Manual e Ilustrado de la Real Academia de la Lengua Espaola, es una cuestin que se trata de aclarar. Es por eso que un problema lleva implcita la necesidad de resolverlo o aclararlo. El problema es justamente ese: cmo resolver problemas, cmo aclararlos. Hasta ahora no existe una nica e infalible metodologa de resolucin de problemas. No hay recetas que puedan aprenderse y que siguindolas nos lleven a la segura solucin de cualquier problema. Hay, sin embargo, algunos mtodos generales que, para algunos problemas, pueden ayudar en la resolucin de los mismos. Algunas veces es difcil, no ya la solucin del problema sino, entender el mismo. Por ejemplo, mal puede intentarse encontrar la solucin al problema de una cura contra el SIDA si desconocemos los trminos en los cuales
U.N.S.L. Argentina
26
Programar
dicha cura debe basarse. Ni siquiera podemos plantear el problema (salvo en trminos muy generales, tal como lo hemos hecho aqu), es decir desconocemos la naturaleza del mismo; o por ejemplo, porqu con tres pedazos de madera de 6 cm., 8 cm. y 10 cm. de largo cada uno, se puede construir una escuadra? Para demostrar esto hay que poder definir el problema en trminos ms precisos, hay que poder conocer ms el problema en s. Muchas veces describir claramente el problema, entender de qu se trata, puede ser el principio de su solucin, sino la solucin misma. Es difcil pensar en resolver problemas (por lo menos problemas algo complejos) sin plantearlos antes y mucho ms difcil concebir que puedan plantearse problemas complejos y resolverlos, encontrar una solucin a los mismos, sin recurrir a algn tipo de lenguaje para registrar tanto el planteo del problema como su solucin. Esto equivaldra a preguntarse si podemos pensar sin tener algn lenguaje en el cual hacerlo. Este lenguaje puede tener muchas formas: hablado (sonido), escrito (con smbolos que equivalen a letras o palabras), puramente grfico (con dibujos o diagramas); puede ser tan formal como el lenguaje matemtico o tan informal como el lenguaje natural, pero parece imposible separar la actividad de pensar de la existencia de un lenguaje cualquiera. De ah que la actividad de resolver problemas se encuentre ntimamente relacionada con el lenguaje empleado para plantear y resolver los problemas. Tan relacionada est que algunas veces se confunde la tarea de resolver el problema con la de escribir su solucin en un lenguaje cualquiera. Como los lenguajes tienen una sintaxis, una ortografa determinada, es decir, tienen reglas para escribir correctamente en un lenguaje, no debe confundirse el conocimiento de la sintaxis, y su correcto empleo, con una metodologa de resolucin de problemas. Por otro lado, debemos convenir que existen problemas de todo tipo. Desde los ms sencillos y cotidianos a los ms complejos y difciles. As podemos agrupar los problemas, clasificarlos, y decir que una persona enfrentada con un problema puede verse en las siguientes situaciones: (a) Conoce no slo el problema sino su solucin. En este caso, slo queda aplicar la solucin para resolverlo. (b) Conoce el problema y sabe que existe una solucin an cuando no la conozca, pudiendo recurrir a otra persona, o a un libro, que s la conoce. (c) Conoce el problema pero no la solucin y sabe que no existe nadie ni nada que la tenga. En este caso, debe descubrir la solucin. Es aqu donde podemos hablar de mtodos de resolucin de problemas, an cuando el proceso es fundamentalmente individual y propio de la capacidad para resolver problemas de cada uno. En este caso, sin embargo, podemos separar algo ms las caractersticas de los problemas: (c.1) Cuando puede aplicarse una solucin equivalente de un problema similar al que debe resolverse. (c.2) Cuando existe una solucin parcial, conocida, al problema. (c.3) Cuando la solucin del problema requiere la aplicacin de varias soluciones conocidas, las que unidas lo resuelven. (c.4) Cuando no se conoce una solucin al problema y se sabe que no existe, por el momento, una solucin al mismo, lo que no significa que no pueda encontrarse una. En este caso, una solucin posible del problema es demostrar que el problema no tiene solucin. En computacin y ms concretamente, en programacin, la mayor parte de los problemas ms comunes y corrientes, se encuentran en los casos de los puntos (a) y (b); es decir que solo queda aplicar la solucin, receta o algoritmo conocido. Hay muchos que entran en los grupos (c.1) a (c.3) y unos cuantos cuya solucin se desconoce totalmente y que se encontraran en el grupo (c.4). Sin embargo, para alguien que empieza a aprender a programar es bueno considerar, hasta los problemas ms sencillos, como pertenecientes a los del grupo (c.4). En general, en programacin, la solucin de un problema (y su explicacin, as como su enunciacin) es el programa escrito en algn lenguaje de programacin. As se entiende que programar la solucin a un problema, para que una computadora ejecute el programa y resuelva el problema (si el programa no tiene errores y es la solucin correcta), consiste en escribir, en codificar, la solucin encontrada, usando un lenguaje de programacin. De esto surge un texto con el programa escrito en el lenguaje de programacin elegido, el que debe ser incorporado a la computadora para que esta someta dicho texto de
U.N.S.L. Argentina
27
Programar
programa a un compilador, el cual es a su vez un programa que, al ejecutarse en la computadora, resuelve el problema que significa traducir del lenguaje de programacin, en el cual el programa ha sido escrito, al lenguaje que pueda entender la CPU.
Etapas de la resolucin de problemas

Es difcil, como ya se ha dicho, dar reglas generales de resolucin de problemas. Hay muchos autores que se han dedicado a proponer mtodos de resolucin de problemas, particularmente en el rea de la programacin de computadoras. Un principio ampliamente difundido es el de dividir para reinar. Enfrentado con un problema complejo, y cuya solucin no se encuentra fcilmente, es conveniente separar el problema en partes, en problemas ms chicos y por eso mismo ms manejables y para los que, quizs, ya exista una solucin. Por supuesto este principio no tiene limitacin alguna. Puede dividirse un problema, en tantos problemas menores, como se desee. As mismo cada uno de estos problemas puede, a su vez, dividirse cuantas veces se desee o sea conveniente. Ahora cada parte del problema general y ms grande, puede ser atacada por separado y quizs entendida y resuelta ms fcilmente. Solucionada cada una de las partes es probable que se tenga la solucin del problema original. Es probable pero no seguro: la unin de cada una de las partes para conformar la solucin general no siempre es tan fcil como parece. Cmo un ejemplo posible vamos a establecer una serie de pasos o etapas que parece razonable tener en cuenta cuando se intenta resolver un problema complejo, o cada una de las partes de un problema, y cuya solucin se desconoce inicialmente. Estas etapas son solo a ttulo de ejemplo y es posible que haya otras mejores y ms efectivas. Recurdese que al fin de cuentas la resolucin de problemas depende ms de quien lo resuelve que del mtodo empleado para ello. 1.- Definir el problema (objetivo). Parece razonable que, antes de intentar resolver un problema, se sepa de qu se trata, es decir cul es el problema a resolver. Para ello es til definir el problema: 1.1.- Primero, en trminos sencillos y generales, empleando un lenguaje comn y generalmente natural. 1.2.- Segundo, tratando de avanzar en una definicin en trminos lo ms formales posibles. 2.- Determinar la naturaleza del problema. Es bueno intentar saber si el problema es conocido, si ya tiene una solucin conocida, si tiene una solucin compuesta de soluciones ya conocidas. 3.- Determinar las salidas del problema resuelto. En el caso de la programacin de computadoras es til definir las salidas, los resultados que el problema resuelto producir. Definir qu datos, de qu tipos sern los resultados y dar algunos ejemplos de los resultados que se obtendrn. 4.- Determinar las entradas necesarias. Si se conocen las salidas, los resultados del problema resuelto, habr que definir las entradas necesarias (los datos, y sus tipos) para obtener las salidas del problema resuelto, dando algunos ejemplos de las mismas para los resultados esperados. 5.- Disear la solucin. Es til comenzar a bosquejar una solucin tentativa del problema, empleando en lo posible lo obtenido en los pasos anteriores, especialmente en los puntos 1 y 2. Por otro lado, este bosquejo inicial de la solucin puede ser tratado en dos partes: 5.1.- Describiendo, inicialmente, informalmente la solucin en trminos de acciones generales, empleando el principio dividir para reinar. 5.2.- Describir, luego, formalmente la solucin, obtenida en 5.1 en trminos de algn lenguaje algortmico.
U.N.S.L. Argentina
28
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase 6.- Disear la solucin de cada trozo del problema.
Programar
Para cada pedazo del problema, que pueda haberse separado, debe aplicarse el mismo criterio que para el problema general, hasta encontrar la solucin del mismo. El empleo sistemtico de los pasos 1 a 6 para cada trozo de solucin constituye el principio de desagregacin: ir de lo ms general a lo particular. 7.- Ejecutar el algoritmo manualmente. Es sumamente conveniente convencerse que la solucin encontrada es la correcta. Para ello un mecanismo posible consiste en ejecutar manualmente el algoritmo de la solucin, por medio de ejemplos concretos. Esto es una forma ms de comprobar que la solucin hallada es la correcta. 8.- Codificar la solucin en el lenguaje de programacin elegido. Slo al final, una vez encontrada la solucin, debe codificarse sta en un lenguaje de programacin. Es poco conveniente atarse a los problemas de sintaxis antes de tener una solucin al problema, ya que stos pueden oscurecer o dificultar la bsqueda de la solucin del problema. La solucin de los problemas de codificacin, de los problemas sintcticos, debe dejarse para el final, ya que son los que ms fcilmente pueden resolverse.
3.5 Los paradigmas de la programacin

Un paradigma es un ejemplo o algo ejemplar. La palabra se usa en computacin para designar un conjunto de reglas, mtodos, principios de programacin, que comparten una filosofa comn de programacin. En general, pueden distinguirse los paradigmas imperativo, funcional, lgico y objeto. Sobre ste ltimo puede discutirse si es un paradigma como lo son los otros tres anteriores, o si es slo un mtodo que puede aplicarse en cualquiera de los otros paradigmas. El paradigma imperativo se basa fundamentalmente en programar dando rdenes o instrucciones en forma, justamente, imperativa. El funcional describe la solucin del problema a travs de funciones que lo resuelven. El lgico emplea la lgica para describir las relaciones lgicas, entre los objetos, los datos, que forman parte del problema, para describir la solucin. El orientado a objeto considera, justamente, cada uno de los objetos que forman parte del problema, as como aquellos que forman parte de la solucin, y las acciones que sobre cada uno de ellos se realizan, como un todo nico e inseparable, permitiendo la manipulacin de los objetos slo por medio de las acciones previamente definidas para ellos. Cada paradigma ha sido llevado a la prctica, implementado, en uno o varios lenguajes de programacin. Rara vez, sin embargo, estos lenguajes son puros, es decir que no tienen principios propios de alguno de los otros paradigmas. As, por ejemplo, muchos lenguajes imperativos incluyen principios (a travs de estructuras sintcticas del lenguaje) del paradigma funcional. Los lenguajes imperativos son los ms conocidos: COBOL, FORTRAN, BASIC, Pascal, C, Ada, y otros ms. Los lenguajes funcionales, an cuando el paradigma existe desde hace tiempo, no han tenido tanta difusin: Lisp, SNOBOL, Haskell, entre otros. El PROLOG es el lenguaje ms conocido del paradigma lgico. SMALLTALK es tradicionalmente el asociado al paradigma de objetos, an cuando se han hechos muy populares las extensiones, con principios de la metodologa de objetos, a los lenguajes imperativos, como por ejemplo Object Pascal, C++, etc.
U.N.S.L. Argentina
29
Programacin Imperativa
CAPTULO 4 PROGRAMACI IMPERATIVA

4.1 Introduccin
La programacin imperativa, o por frases, consiste justamente en describir la solucin de un problema a travs de las rdenes, frases, instrucciones o sentencias, necesarias para resolverlo. Estas rdenes describen las acciones que deben realizarse sobre los datos que forman parte del problema. As, un programa imperativo es un conjunto de sentencias que le indican a la computadora cmo realizar una tarea. En consecuencia, distinguimos dos grandes partes: (a) los datos que forman parte del problema o que se requieren para resolverlo. (b) las acciones necesarias para resolver el problema, y que procesan los datos. Ya hemos dicho que los paradigmas de la programacin se implementan a travs de lenguajes de programacin. Estos lenguajes tienen una sintaxis, que no es ms que una forma, una gramtica, una ortografa, un conjunto de reglas determinado para que los programas escritos en dichos lenguajes, puedan ser entendidos por el compilador, que es el programa encargado de traducir del lenguaje de programacin, empleado para escribir un programa, al lenguaje que entiende la CPU.
Las etapas en la construccin de un programa

1. Diseo de la solucin, empleando algn mtodo y diversas herramientas: diagramas, lenguaje natural (el castellano, por ejemplo), algn lenguaje propio del mbito del problema a resolver (el lenguaje de la Matemtica, por ejemplo, si el problema a resolver es de ese mbito), etc. Codificacin de la solucin en algn lenguaje de programacin. Muchas veces, esta etapa es llevada a cabo en forma conjunta con la siguiente etapa (Edicin). Problema? Resolucin Codificacin y Edicin
2.
Con errores
Con errores Prueba Compilacin
Sin errores A usar el programa!
Sin errores
Figura 4.1. El proceso de resolucin de problemas e implementacin de un programa que lo resuelve. 3. 4. Edicin del programa, que es la escritura del programa sobre la computadora. Compilacin del programa, que es la traduccin del programa escrito en el lenguaje de programacin elegido al lenguaje que entiende la mquina que ejecutar el programa. La compilacin es, a su vez, hecha por un programa, el compilador del lenguaje de programacin elegido. En esta etapa, cuando ejecutamos el compilador, debemos pasarle como entrada nuestro programa, escrito en algn lenguaje de programacin (por 30 Departamento de Informtica
U.N.S.L. Argentina
ej. Pascal, C, Java, etc.), produciendo como salida una nueva versin de nuestro programa pero escrita en el lenguaje que entiende la CPU en la cual estemos trabajando. 5. 6. 7. Si durante la etapa de compilacin, el compilador detecta que hay errores de sintaxis en nuestro programa, deberemos volver a editar el programa (paso 2).para corregir los errores detectados. Ejecucin del programa, si no hay errores de sintaxis detectados durante la compilacin. Si hay errores en la solucin diseada en el paso 1 y se detectan en la ejecucin (paso 5) del programa, ser necesario volver al paso 1 (diseo de la solucin), repitiendo nuevamente .todos los pasos cuantas veces sea necesario hasta que el programa funciones correctamente.
4.2 Definicin de los lenguajes de programacin

Los lenguajes de programacin tienen ciertas caractersticas que son importantes de sealar. Son formales, por lo menos en su sintaxis, es decir que no son ambiguos, para cada significante (smbolo) posible existe un solo significado, cosa que no ocurre con la mayor parte, sino todos, los lenguajes naturales hablados por el hombre. Los lenguajes de programacin, adems, son poco o nada redundantes, es decir que un mismo significado rara vez puede expresarse con ms de un significante. Un lenguaje formal es un conjunto infinito de secuencias o cadenas de smbolos; as, un programa es alguna de estas cadenas. Por supuesto, los smbolos con los que podemos formar las cadenas de smbolos provienen de un conjunto finito, que se conoce con el nombre de vocabulario o alfabeto. Algo similar pasa, por ejemplo, con el castellano donde, empleando el abecedario, pueden crearse no slo nuevas palabras sino tambin infinitas frases. Las cadenas se forman empleando la operacin de concatenacin, que es la operacin de enlazar, juntar, smbolos y/o cadenas uno al lado del otro, tal como escribimos las palabras y las frases en la mayor parte de los idiomas hablados. Sin embargo, no todas las cadenas de smbolos son parte del lenguaje, no cualquier combinacin de letras es una palabra del castellano, o cualquier combinacin de palabras es una frase. Para eso hay reglas sintcticas, la sintaxis o gramtica, de la que ya hablamos, que permiten construir las palabras y las frases correctas. Adems, como ya dijimos, todo programa, escrito empleando algn lenguaje de programacin, debe ser traducido por el compilador al lenguaje que la CPU entiende. Por lo tanto, es conveniente que estos lenguajes sean definidos de la manera ms precisa y exacta posible. Esto es equivalente, aunque no se haga con la misma precisin, a lo que sucede con las gramticas de los lenguajes naturales, que sirven para definir cmo construir sus frases. Por ejemplo, la gramtica de la lengua espaola, que describe como se forman las frases o sentencias en dicho idioma. Todo lenguaje tiene, adems de los smbolos que lo componen, estructuras sintcticas que sirven para definirlo. As el castellano cuenta, por ejemplo, con palabra, frase, verbo, sujeto, objeto, etc., que no forman parte estrictamente del lenguaje pero que son estructuras que sirven para definirlo, por ejemplo se podr decir que una frase se compone de un sujeto seguido de un verbo, seguido de un objeto. Para definir los lenguajes de programacin, para definir su sintaxis, se han creado lenguajes de definicin. Estos lenguajes que sirven para definir lenguajes se los conoce bajo el nombre genrico de metalenguajes. El prefijo meta significa despus o ms all, de ah que se emplee para estos lenguajes de definicin porque se suponen estn ms all de los lenguajes que definen.
Metalenguaje B F
Uno de los metalenguajes ms difundidos es el que se conoce bajo el nombre de BNF, cuyas siglas en ingls corresponden a las iniciales de Backus ormal Form (Forma (o Formalismo) Normal de Backus), por el nombre de su creador, Backus, o a Backus- aur Form, porque Naur le agreg posteriormente algunos detalles. Existen otras variantes del metalenguaje BNF, que se las conoce como EBNF, Extended Backus- aur Form o, en espaol, Forma (o Formalismo) Extendida de Backus-Naur. En BNF se emplea un conjunto simple y pequeo de principios para construir el metalenguaje. Para definir formalmente la sintaxis de un lenguaje usando BNF se pueden usar estructuras sintcticas del lenguaje que se define, llamadas smbolos no terminales ( T) y que se denotan empleando letras maysculas (A, C, D, etc.) o 31 Departamento de Informtica
U.N.S.L. Argentina
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase dndoles un nombre en letras minsculas entre < >, por ejemplo <frase>.
BNF emplea la concatenacin, esto significa que para representar o denotar una construccin sintctica, donde la estructura sintctica llamada X se encuentra seguida de la estructura sintctica llamada Y, se hace como XY. Los smbolos propios del lenguaje definido (que forman parte de su vocabulario o alfabeto) se conocen como smbolos terminales (T). Se usan, adems una serie de smbolos, que no pertenecen al lenguaje sino a la BNF, llamados metasmbolos y que permiten denotar otras caractersticas del lenguaje definido, y cuyo significado y utilidad veremos ms adelante a medida que sea necesario. Los metasmbolos de BNF son cuatro ::= , < , > y |. Un lenguaje se define, en BNF, expresando un conjunto de reglas, llamadas reglas de reemplazo, que tienen una parte izquierda (PI), un metasmbolo de definicin o reemplazo (::=) y una parte derecha (PD). En la PI de una reglas de reemplazo tiene que haber por lo menos un NT. Por ejemplo, la siguiente regla: Parte Izquierda Parte Derecha
<frase> ::= <sujeto> <verbo> <objeto>

donde <frase> es la PI de la regla; y la concatenacin de <sujeto> <verbo> <objeto> es la PD. El metasmbolo | se usa para separar alternativas en la parte derecha de una regla de reemplazo. Por ejemplo, <identificacion> := <nombre> <apellido> |<trato> <nombre> <apellido> significa que una identificacin consiste de un nombre seguido de un apellido o comienza por el trato que se la da a la persona (por ej. Sr., Sra., Dr., etc.), seguido de su nombre y de su apellido. Las reglas de reemplazo son llamadas as porque permiten que, por ejemplo, dadas dos reglas de reemplazo de un lenguaje dado, a las que llamamos y , si en la PD de la regla se encuentra un smbolo no terminal que aparece en la PI de la regla , entonces se puede reemplazar, en la PD de , este smbolo no terminal que est tambin en la PI de , por lo que aparece en la PD de . Por ejemplo, dadas las siguientes reglas: (1) <frase> ::= <sujeto> <verbo> <objeto> (2) <sujeto> ::= <articulo> <nombre> en la PD de la regla (1) se puede reemplazar <sujeto> por la concatenacin de <articulo> <nombre>, que es la PD de la regla (2) donde se define <sujeto>. Partiendo de un smbolo no terminal y aplicando las reglas de reemplazo pueden generarse cadenas (o frases) que pertenecen al lenguaje, es decir frases correctamente formadas de acuerdo a la sintaxis expresada por medio de la BNF. Asimismo, puede controlarse si una cadena (o frase) pertenece al lenguaje, es decir si no tiene errores sintcticos. Cuando esto se hace mecanicamente, por ejemplo con un programa, se le llama automta. Ejemplo: La siguiente BNF da la gramtica para un lenguaje para expresiones aritmticas simples. (1) <expresin aritmtica> (2) (3) <trmino> (4) (5) (6) <factor> (7) (8) (9) <var-o-const> (10) (11) <variable> (12) <constante> (13) (14) <dgito> ::= <trmino> | <trmino> <expresin aritmtica> ::= <factor> | <factor> + <trmino>| <factor> - <trmino> ::= <var-o-const> | <var-o-const> * <factor> | <var-o-const> / <factor> ::= <variable> | <constante> ::= x | y | z | w ::= <dgito> | <dgito> <constante> ::= 0 | 1| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
El smbolo no terminal distinguido, a partir del cual se derivarn todas las cadenas de este lenguaje, es
U.N.S.L. Argentina
32
<expresin aritmtica>; los nicos smbolos terminales son 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, -, *, /, x, y, z, w. El lenguaje que genera esta gramtica, es decir las cadenas de smbolos que pueden producirse con la gramtica, son expresiones aritmticas que involucran slo las operaciones de suma (+), resta (-), producto (*) y divisin (/), sin parntesis y que involucran slo nmeros naturales y/o las variables x, y, z y w. As, por ejemplo, aplicando las reglas de produccin o reemplazo (cuyo nmero encontramos sobre las flechas) podemos derivar la expresin aritmtica 12 + x*y de la siguiente manera: <expresin aritmtica> 1 <trmino> 4<factor> + <trmino> 6 <var-o-const>+ <trmino> 10 <constante>+ <trmino> 13 <dgito> <constante>+ <trmino> 12 <dgito> <dgito> + <trmino> 14 1<dgito> + <trmino> 14 12 + <trmino> 3 12 + <factor> 7 12 + <var-o-const> * <factor> 9 12 + <variable> * <factor> 6 12 + <variable> * <var-o-const> 9 12 + <variable> * <variable> 11 12 + x * <variable> 11 12 + x * y Existen muchas variantes de EBNF. Nosotros describiremos, brevemente, la utilizada en el libro Pascal, Manual del Usuario e Informe [K. Jensen y N. Wirth]. En ella, los no terminales se representan como secuencias de smbolos, los terminales entre y el metasmbolo de reemplazo es =. Aparece el punto (.) como un metasmbolo para indicar el final de cada regla. Por ejemplo, la siguiente EBNF permite generar nmeros naturales. natural = digit | digit natural . digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" . Tambin introduce nuevos metasmbolos como {}, que indica que lo que est encerrado entra dichas llaves puede repetirse un nmero indefinido de veces, inclusive cero. Por ejemplo, las reglas siguientes generan lo mismo que las dos anteriores: natural = digit {digit}. digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" . Asimismo se pueden usar los metasmbolos [ y ] para indicar que lo que se encuentra adentro es opcional, es decir, puede estar como no estar. Por ejemplo las siguientes reglas permiten generar nmeros enteros con o sin signo: entero = [-] natural. natural = digit {digit}. digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" .
4.3 La estructura general de un programa en Pascal

De acuerdo a la EBNF empleada en el libro Pascal, Manual del Usuario e Informe [K. Jensen y N. Wirth], cualquier programa sintcticamente correcto en Pascal, debe poder derivarse del no terminal Programa. Programa = EncabezamientoDePrograma ; Bloque .. Bloque = ParteDeDefinicinDeDatos ParteDeDeclaracinDeProcedimientosYFunciones ParteDeEnunciados. ParteDeDefinicinDeDatos = ParteDeDefinicinDeConstantes ParteDeDefinicinDeTipos ParteDeDefinicinDeVariables. ParteDeEnunciados = EnunciadoCompuesto .. EnunciadoCompuesto = begin SecunciaDeEnunciados end. SecunciaDeEnunciados = Enunciado {; Enunciado}. Enunciado = EnunciadoSimple | EnunciadoEstructurado. En la Tabla 1 se representa la estructura general de un programa Pascal, de acuerdo a lo que su EBNF define.
U.N.S.L. Argentina
33
Tabla 4.1. Las distintas partes de un programa en Pascal Encabezamiento de Programa Ejemplo: program prog ; Parte de Definicin de Ejemplo: const n = 100; Constantes Parte de Definiciones y Parte de Definicin de Tipos de Ejemplo: type color=(verde, azul, rojo); Declaraciones de Datos Datos Parte de Declaracin de Ejemplo: var i : integer; c : char; Variables Ejemplo: Parte de Declaracin de Funciones y Procedimientos
function f(x: char; y: integer): boolean; begin if (x=a) and (y>0) then f:=true else f:=false end; procedure p(x: char; y: integer; var b: boolean); begin if (x=a) and (y>0) then b:=true else b:=false end;
Bloque Sentencia Simple Parte de Enunciados o Sentencias

begin
Sentencia de Asignacin Sentencia de Invocacin o Llamada de Procedimiento Sentencia Vaca Sentencia Compuesta Sentencia de Iteracin Sentencia de Seleccin
Ejemplo:
i := i + 1;
Ejemplos:
writeln(hola); p(t, 5, c);
Ejemplo: Ejemplo:
begin
sentencia {; sentencia }
end.
sentencia {; sentencia }
end
Sentencia Estructurada
Ejemplo:
while condicin do
sentencia Ejemplo: if condicin then sentencia else sentencia
4.4 Programacin y datos

Un dato es la representacin dentro de la computadora de algn aspecto de la realidad. Estos sirven para ser procesados y producir los resultados, los que a su vez pueden ser otros datos. Si los datos son la representacin de aspectos de la realidad, y dado que hay distintos aspectos de la realidad, estos deben poder reflejar esa diversidad. Para esto existen los tipos de datos, como veremos en la seccin siguiente. Los datos sern procesados por la computadora y sobre ellos se efectuarn operaciones por medio de operadores. Los operadores, entonces, denotan, y definen, las operaciones que pueden efectuarse sobre los datos. Por ejemplo, el operador de suma (que, generalmente, se denota con el smbolo +) define la operacin de la suma sobre datos de tipo entero, que es el tipo de dato que representa a los nmeros enteros. Un dato puede representarse por medio de una constante o literal, que es, como su nombre lo indica, un valor que se mantiene sin cambio alguno, es decir es invariable o constante. Por ejemplo, 114 es la constante que representa al nmero entero ciento catorce. Como dato adicional pinsese que el nmero ciento catorce lo representamos con la constante 114, que no es ms que la concatenacin de los smbolos 1, 1, 4, que son los que representan los nmeros uno, uno y cuatro. Sin
U.N.S.L. Argentina
34
embargo, CXIV 1110010 tambin representan el mismo nmero, aunque con otros smbolos. Tambin se representan los datos por medio de variables, que son, como su nombre lo indica elementos sintcticos que representan o contienen, en cada momento de la ejecucin, uno de los posibles valores de un tipo de dato. Las variables se denotan por medio de identificadores, que son nombres que se dan a las mismas y que usamos para referirnos a ellas dentro del programa. En consecuencia, podemos visualizar una variable como un lugar de la memoria de la computadora, con un tipo de dato asociado y un nombre (dado por su identificador), en el que pueden almacenarse cualquiera de los valores del tipo de dato asociado a la variable. Por ejemplo, peso podra ser el nombre (el identificador) de una variable que puede almacenar valores de tipo real (nmeros reales). Es una buena tcnica de programacin definir y conocer los datos que constituirn tanto la entrada como la salida, as como los intermedios, de un programa. Es as como muchos lenguajes de programacin exigen estas definiciones y declaraciones antes del programa que los procesar.
4.5 Tipos de datos

Un tipo de dato es un conjunto de valores posibles que comparten las mismas caractersticas y operadores. Por ejemplo, un tipo de dato muy empleado es el tipo entero que representa a los nmeros enteros, otro tipo de dato es real que representa a los nmeros reales, que para conservar la equivalencia con la matemtica incluye a los valores enteros. Otro tipo de dato es el llamado tipo carcter que agrupa a los smbolos empleados en la escritura: las letras del abecedario, donde se distinguen las maysculas de las minsculas, los smbolos que representan los nmeros del cero al nueve y varios smbolos de puntuacin (. , ; : etc.). Tambin la representacin de los valores lgicos de verdad (VERDADERO y FALSO por ejemplo) es un tipo de dato. Hay muchos otros, dependiendo esto del lenguaje de programacin. En el lenguaje de programacin Pascal, los datos los podemos clasificar como se ve en la Tabla 4.2. Tabla 4.2. Los Datos en Pascal Booleano (boolean) Carcter (char) Pre-definidos Ordinal Entero (integer) Enumerado (Escalar) Subrango de un Tipo Ordinal Real (real) Arreglo (array) Registro (record) Conjunto (set) Archivo (file)
Simple
Tipo de Dato
Estructurado o Compuesto
Puntero (Pointer)
Tipo Pointer
En general podemos decir que el tipo pointer (que en castellano puede traducirse como puntero) en la mayor parte de los lenguajes de programacin, y en el Pascal en particular, es exactamente lo que su nombre indica: un puntero, es decir algn dispositivo provisto por el compilador para apuntar a algo. Generalmente lo apuntado es un valor, o mejor dicho un lugar en la memoria de la computadora, donde puede almacenarse un valor. Una variable de tipo puntero no contiene otra cosa que la direccin (tambin podemos decir la referencia) de tal lugar. En Pascal, una variable de tipo pointer slo apunta a una clase de valores. Es decir que cada variable de tipo pointer est siempre asociado a un tipo de dato al cual puede apuntar. Por supuesto que puede haber muchas
U.N.S.L. Argentina
35
variables de tipo pointer y cada una podr apuntar a distintos tipos de datos si as se requiere, (o a los mismos, claro est!). Los tipos de datos pointer son considerados dinmicos por oposicin a los otros tipos de datos que se consideran estticos. Esto hace referencia al hecho que, por ejemplo, una variable de tipo integer (entero) en Pascal, cuando es declarada, reserva un lugar donde almacenar un valor de tipo integer, el cual puede ser cambiado cada vez que se asigne a la variable. Este lugar existir en la memoria mientras exista el mbito de validez de la variable (recordar que el mbito de validez tiene una directa relacin con los mdulos, ver Captulo 5). Por el contrario, una variable de tipo pointer a integer, por ejemplo, podr crearse y destruirse tantas veces como sea necesario, durante la ejecucin del programa, es decir, dinmicamente, podr asignrsele y desasignrsele memoria. As, reconocemos que el tipo pointer toma valores que son punteros a posibles valores de un tipo dado (estndar o declarado, en Pascal), o un valor particular llamado nil que indica que la variable no apunta a nada. Para esto el tipo pointer tiene asociado las operaciones de: Creacin de un lugar en la memoria, para guardar un valor del tipo apuntado. Esta operacin en Pascal es un procedimiento (procedure) estndar llamado new (que en ingls quiere decir nuevo), y que asigna el lugar suficiente para almacenar valores del tipo apuntado; Devolucin de un lugar antes creado. Esta operacin en Pascal es un procedure estndar llamado dispose (que en ingls quiere decir disponga), y que dispone o devuelve, para ser usado en otra cosa, el lugar anteriormente destinado a guardar valores del tipo apuntado;
Las variables de tipo pointer, al igual que con cualquier otro tipo de dato, puden ser asignadas siempre que el tipo de la parte derecha de la asignacin sea el mismo tipo del de la parte izquierda. En particular, tambin se les puede asignar el valor nil. Siendo que una variable de tipo pointer puede referirse a dos valores distintos: el apuntado y el que apunta, es necesario saber cundo usamos uno y el otro. En Pascal, esto se consigue a travs del uso del operador ^, el cual nos sirve para recuperar el valor apuntado por una variable de tipo pointer. El mismo smbolo es usado en Pascal para indicar cuando una variable es declarada de tipo puntero. As, la declaracin de variables de tipo pointer, en Pascal, se hace anteponiendo el smbolo ^ al identificador del tipo de dato al que la variable apunta. Por ejemplo, supongamos las siguientes declaraciones: var Punt1aInt, Punt2aInt : înteger; Punt1aChar, Punt2aChar : ^char; UnInt : integer; UnChar : char; Las variables Punt1aInt, Punt2aInt pueden tomar valores de tipo puntero a valores de tipo integer, mientras que Punt1aChar, Punt2aChar pueden tomar valores de tipo puntero a valores de tipo char. Ntese la diferencia de los valores que estas variables toman con las variables UnInt y UnChar que pueden tomar valores de tipo integer y character respectivamente. Inicialmente, despus de su declaracin, como ocurre con todas las variables en Pascal, las variables de tipo pointer, tienen un valor indefinido. El estado de estas variables puede verse en la Figura 4.1. Para usar las variables Punt1aInt, Punt2aInt, Punt1aChar y Punt2aChar habr que ordenar al compilador que reserve un lugar para guardar los valores del tipo correspondiente. En particular, en el caso de Punt1aInt un lugar para un dato de tipo integer al que esta variable apuntar. Eso se hace empleando el procedimiento estndar new: new(Punt1aInt);
U.N.S.L. Argentina
36

variables Memoria de la mquina ? ... ? ? ? ? ? ? ... ? ? ? ? ... ?
Punt1aInt Punt2aInt Punt1aChar Punt2aChar UnChar UnInt
Figura 4.1. Las variables Punt1aInt, Punt2aInt, Punt1aChar y Punt2aChar todas de tipo pointer aunque punteros a distintos tipos (integer y char) han sido declaradas y tienen valores indefinidos. Las variables UnChar y UnInt tambin han sido declaradas y el compilador reserv un lugar para sus valores.
Ahora Punt1aInt apunta a un lugar que puede almacenar valores de tipo integer, tal como se ve en la Figura 4.2.
variables Memoria de la mquina ? ... ? ? ? ? ? ... ? ? ? ? ... ?
Figura 4.2. Para la variable Punt1aInt se le ha ordenado al compilador que le reserve un lugar para almacenar valores de tipo integer. El valor que tiene la variable Punt1aInt es el de puntero a un lugar para guardar un valor entero. En el lugar para almacenar un entero no se sabe qu hay, no se ha asignado nada todava.
lugar reservado para guardar valores de tipo integer
Para asignar un valor de tipo integer a ese lugar se usa el smbolo ^ despus del identificador de la variable pointer, como en el ejemplo siguiente: Punt1aInt^ := 45; El efecto de esta asignacin es que el valor 45 es almacenado en el lugar de memoria apuntado por Punt1aInt. El estado de las variables, luego de la ejecucin de esa sentencia puede verse en la Figura 4.3.
U.N.S.L. Argentina
37

variables Memoria de la mquina ? ... ? ? ? ? ? ... ? ? ? 45 ... ?
Figura 4.3. Al lugar apuntado por la variable Punt1aInt se le ha asignado el valor 45, de tipo integer, el que es almacenado en el lugar reservado por el compilador para eso.
Si lo que se quiere es asignar el valor puntero que tiene la variable pointer Punt1aInt a la variable Punt2aInt esto se hace: Punt2aInt := Punt1aInt; Ahora la variable Punt2aInt (que inicialmente tena un valor indefinido) apunta al mismo valor de tipo integer (en este ejemplo 45) al que apunta Punt1aInt. Esto tiene como consecuencia lo que se ve en la Figura 4.4.
variables Memoria de la mquina ? ...
? ? ? ? ... ? ? ? 45 ... ?
Figura 4.4. A la variable Punt2aInt se le ha asignado el valor, de tipo pointer a integer, que tiene la variable Punt1aInt. Este es almacenado en el lugar reservado por el compilador para la variable Punt2aInt. Ahora ambas variables pointer apuntan al mismo lugar para almacenar un valor entero.
Si se quiere que Punt2aInt apunte a un lugar nuevo, distinto del que se encuentra apuntando, habr que hacer: new(Punt2aInt); El estado de las variables, luego de la ejecucin de esa sentencia, puede verse en la Figura 4.5.
U.N.S.L. Argentina
38

? ? ? ? ... ? ? ?
lugar reservado para guardar valores de tipo integer lugar reservado para guardar valores de tipo integer
Figura 4.5. Para la variable Punt2aInt se le ha ordenado al compilador que le reserve un lugar para almacenar valores de tipo integer. El valor que tiene la variable Punt2aInt es el de puntero a un lugar para guardar un entero. En el lugar para guardar un entero no se sabe qu hay ya que no se ha asignado nada todava.
45 ... ?
Si ahora hacemos: Punt2aInt^ := 77; la variable Punt2aInt ahora apunta al valor 77 de tipo integer. Cmo quedan las variables, luego de la ejecucin de esa sentencia, puede verse en la Figura 4.6.
? ? ? ? ... ? ? 77
Figura 4.6. Al lugar apuntado por la variable Punt2aInt se le ha asignado el valor 77 de tipo integer. Este valor se almacena en el lugar para guardar un integer reservado oportunamente por el compilador cuando se ejecut new(Punt2aInt).
45 ... ?
Si ahora ejecutamos: Punt2aInt^:= Punt1aInt^; ambas variables, apuntarn a sus respectivos lugares para guardar integers, pero ambos lugares tendrn el mismo valor: 45. Las variables, luego de la ejecucin de esa sentencia, quedan como puede verse en la Figura 4.7. Obsrvese la diferencia de esa sentencia con la de asignar los valores punteros (Punt2aInt Punt1aInt;), cuya consecuencia es la que se muestra en la Figura 4.4.
U.N.S.L. Argentina
:=
39

? ? ? ? ... ? ? 45
Figura 4.7. Al lugar apuntado por la variable Punt2aInt se le ha asignado el valor de tipo integer apuntado por la variable Punt1aInt. Este valor se guarda, en el lugar, para guardar un integer, reservado oportunamente por el compilador cuando se hizo new(Punt2aInt).
45 ... ?
Por supuesto, no se puede hacer Punt2aInt := Punt1aInt^; ya que esto significa asignar valores de tipos distintos. En efecto, en esa sentencia Punt2aInt es de tipo înteger, mientras que Punt1aInt^ es de tipo integer. Claramente, tampoco se puede hacer Punt2aInt^:= Punt1aInt; por las mismas razones: no se pueden mezclar tipos en las asignaciones en Pascal. S puede hacerse: UnInt := Punt1aInt^;
Esto deja las variables como se ve en la Figura 4.8.

? ? ? 45 ... ? ? 45
Figura 4.8. A la variable UnInt se le ha asignado el valor 45, de tipo integer apuntado por la variable Punt1aInt. Este valor se guarda, en el lugar para guardar un valor de tipo integer, reservado oportunamente por el compilador, cuando se declar la variable UnInt.
45 ... ?
Si se ejecutan las siguientes sentencias: new(Punt1aChar); Punt1aChar^:= w; las variables quedan como se muestra en la Figura 4.9.
U.N.S.L. Argentina
40

? ? 45 ... ?
lugar reservado para guardar valores de tipo char lugar reservado para guardar valores de tipo integer lugar reservado para guardar valores de tipo integer
w
45
Figura 4.9. A la variable Punt1aChar se le ha dado un lugar para guardar un char. Luego a ese lugar, se le ha asignado el valor w de tipo char. Este valor se guarda, en el lugar, que es apuntado por la variable Punt1aChar.
45 ... ?
No se puede hacer Punt1aChar:= Punt1aInt; ya que, si bien ambos son de tipo pointer, apuntan a tipos de datos distintos, uno a char y el otro a integer, y en Pascal, los pointers a tipos de datos distintos, se los considera de tipos distintos. S puede hacerse: Punt2aChar:= Punt1aChar; UnChar:= Punt2aChar^; esto deja las variables como se ve en la Figura 4.10.
w
45 ... ?
lugar reservado para guardar valores de tipo char lugar reservado para guardar valores de tipo integer lugar reservado para guardar valores de tipo integer
w
45
45 ... ?
Figura 4.10. A la variable Punt2aChar se le ha asignado el mismo valor puntero que tiene Punt1aChar. Luego se ha asignado lo apuntado por Punt2aChar, que es un char a la variable UnChar de tipo char. El mismo efecto se hubiese logrado asignando Punt1aChar a UnChar ya que ambas variables apuntan al mismo lugar y en consecuencia al mismo valor almacenado.
4.6 Estructuras de programacin

A lo largo del tiempo, los lenguajes que implementan el paradigma de programacin imperativa, han ido
U.N.S.L. Argentina
41
incorporando no solo los principios de dicha programacin sino tambin elementos metodolgicos que ayudan a no cometer errores, an cuando no a evitarlos totalmente. No todos los lenguajes tienen incorporados algunos de estos elementos metodolgicos que pertenecen a lo que se ha dado en llamar programacin estructurada. As, la programacin estructurada podra ser vista como un subconjunto de la programacin imperativa. Muchos de los principios de programacin estructurada coinciden con principios generales de resolucin de problemas. Otros son consecuencia de la necesidad de evitar errores que la estructura sintctica de algunos lenguajes puede llevar a cometer al programador. As, por ejemplo, est el principio que dice que los datos deben definirse antes de empezar a utilizarlos (hay lenguajes que obligan, sintcticamente, a hacerlo); o el principio que el programa debe ejecutarse en el mismo orden en que se lea, evitando saltos que alteren el flujo normal de ejecucin y de lectura del programa. Este ltimo principio responde al hecho que muchos lenguajes de programacin tienen incorporadas rdenes o sentencias de bifurfacin, que permiten que la ejecucin del programa se traslade, salte, haga una bifurcacin a otro sector del mismo y, en consecuencia, la ejecucin del programa no siga el orden de lectura del texto del mismo, sino otro que puede llegar a resultar difcil de seguir y entender para un programador que quiere saber, leyendo el programa, qu hace este. A raiz de esto, Edsger W. Dijkstra public, en 1968, un trabajo que di origen a la programacin estructurada. En el se propone el uso de tres estructuras de control tratando de reducir al mnimo el uso de las sentencias de bifurcacin (por ejemplo la sentencia goto en Pascal o en C). Las estructuras de control tradicionales de la programacin estructurada son la secuencia, la seleccin, y la iteracin. Los lenguajes de programacin imperativos tienen las estructuras sintcticas necesarias para implementar todas las estructuras de control. Asimismo, todos los lenguajes imperativos cuentan, con la sentencia de asignacin, que es una accin bsica de la programacin imperativa, la cual permite cambiar los valores de lugares en la memoria de la computadora denotados cada uno por un identificador de variable. Cabe notar que los lenguajes imperativos, como por ejemplo Pascal, C, FORTRAN, COBOL, Assembler (Ensamblador), etc. permiten el uso de otras sentencias para entrada/salida, de invocacin de mdulos, entre otras. Las estructuras sintcticas de programacin a las que hacemos referencia en esta seccin tienen que ver con las estructuras de las acciones y no de los datos. Estas acciones se estructuran en los lenguajes de programacin por medio de elementos sintcticos llamados frases, sentencias o enunciados, cada una de las cuales es una orden a ejecutar. Es decir que encontraremos, en la mayor parte de los lenguajes imperativos, una estructura sintctica para construir sentencias, frases o enunciados para la seleccin, para la iteracin, para la secuencia y otra para la asignacin. La mayor parte de los lenguajes de programacin permiten no slo las sentencias simples, donde, como ya dijimos, cada sentencia equivale a una orden, sino tambin sentencias compuestas, que son sentencias que incluyen una o ms sentencias simples. A esto se lo conoce tambin como bloque de sentencias o simplemente bloque.
Asignacin
Emplear un dato o una informacin, cuyo valor cambia, implica usar una variable, que en computacin equivale a darle un nombre a un lugar en la memoria, donde se almacenar el valor que se necesite. Esto en contrapartida con el uso de constantes o literales que son justamente valores que no cambian. La accin de la asignacin es la que permite dar, asignar, un valor a una variable. La asignacin requiere que haya un elemento capaz de almacenar la informacin o el dato asignado. Este elemento es en general una variable. El valor que se asigna, al menos en los lenguajes fuertemente tipados como el Pascal y otros, debe ser del mismo tipo que el elemento sintctico que lo recibe. En algunos casos, hay asignaciones que se aceptan que sean de tipos distintos, aunque compatibles, por ejemplo los enteros y los reales. As, las sentencias de asignacin permiten que una misma variable contenga diferentes valores en distintos momentos durante la ejecucin de un programa. En Pascal, el operador de asignacin es :=. Asumiendo las siguientes declaraciones de variables y constantes en Pascal: const k= -400; var r: real; i: integer; algunos ejemplos de asignaciones vlidas son los siguientes:
U.N.S.L. Argentina
42
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase r := 1000.56; i := k*2; r:= i+5;
Secuencia
Es de hacer notar que la estructura de control secuencia aprovecha el orden de lectura tradicional de los idiomas occidentales es decir de izquierda a derecha y de arriba hacia abajo para implementarse. Es por eso que esta estructura no tiene una forma sintctica explcita y decimos que ella es implcita. La ejecucin de las sentencias se hace en un orden dado, en forma secuencial, es decir una despus de la otra, y no se ejecuta la segunda hasta que la primera haya terminado de ejecutarse, y as sucesivamente. Esta secuencia sigue el orden normal de lectura de izquierda a derecha y de arriba a abajo. En consecuencia, la estructura de secuencia de la programacin estructurada se efecta respetando la normal ejecucin secuencial que todos los lenguajes de programacin tienen, sin emplear sentencias de salto. Es decir que el orden de lectura de un programa es idntico con el orden de ejecucin del mismo. O por lo menos eso es lo que se espera.
Condiciones
Las condiciones juegan un papel fundamental en las estructuras de programacin y son imprescindibles para poder efectuar programas y para la implementacin de las estructuras de seleccin y de iteracin. Las condiciones nos permiten hacer preguntas o evaluar el estado de los datos empleados en un programa y de acuerdo al resultado de esa evaluacin poder tomar decisiones sobre las acciones a desarrollarse. En efecto, en un programa y para resolver un problema, no todas las acciones deben ejecutarse, algunas solo se ejecutarn si ciertas condiciones estn dadas, si se satisfacen una o ms condiciones. Es decir que para ejecutar algunas acciones podrn ponerse condiciones para ello. Estas condiciones solo pueden satisfacerse o no, lo que quiere decir que las respuestas posibles a las preguntas sobre el estado de los datos pueden ser solo dos: si o no; o tambin podra decirse verdadero (true, en ingls), o falso (false, en ingls), o tambin, ya que las computadoras se manejan con el sistema de numeracin binario, 0 o 1. Es por ello que, a las condiciones en computacin, se les puede aplicar el clculo proposicional o la llamada lgebra de Boole. Las condiciones son llamadas expresiones condicionales, o expresiones lgicas, o expresiones booleanas. Una condicin, una expresin lgica, estar compuesta de operandos, que son las variables, constantes, y otros elementos sintcticos que representen datos, cuyo estado se quiere conocer; y operadores, que son los que permiten hacer la pregunta sobre el estado de los operandos. Los operadores ms comunes implementados en la mayora de los lenguajes de programacin son por un lado los operadores relacionales, que como su nombre lo indica son los que comparan, preguntan, ponen en relacin, el estado de dos operandos; por ejemplo igual, que pregunta si dos operandos son iguales; mayor, menor, distinto, etc.; por otro lado tenemos los operadores lgicos, que son los que implementan las conectivas lgicas ms comunes: y (interseccin lgica, and en ingls),; o (disyuncin lgica, or en ingls),; no (negacin, not en ingls). La implementacin de los operadores en los lenguajes de programacin depende de los tipos de datos que estos tengan. Una expresin lgica debe evaluarse para conocer su resultado, lo mismo que una expresin aritmtica: a+1, debe evaluarse para conocer su resultado, es decir hay que operar con el operando + ; y dar un valor determinado a la variable a para obtener el resultado de a+1. Lo mismo sucede con las expresiones lgicas. Para conocer el valor de a>1, es decir para saber si la expresin a>1 evala, toma, el valor verdadero o el valor falso, habr que operar con el operador relacional > y dar un valor a la variable a.
Seleccin
La accin o sentencia de seleccin emplea una expresin condicional (expresin lgica) para decidir si una sentencia (simple o compuesta) se ejecutar o no. Si la expresin condicional al ser evaluada, resulta verdadera la sentencia (simple o compuesta) se ejecutar, sino, si la expresin condicional al ser evaluada, resulta falsa la
U.N.S.L. Argentina
43
sentencia no se ejecutar. En ambos casos, ya sea que se ejecuten o no, la o las sentencias controladas por la seleccin, se contina ejecutando la secuencia establecida: es decir que se ejecuta la sentencia que sigue en el orden de ejecucin a la sentencia de seleccin. La mayor parte de los lenguajes de programacin implementan la sentencia de seleccin permitiendo que si la expresin lgica resulta falsa se ejecute otra u otras sentencias por esa alternativa. Es decir que si la expresin lgica es verdadera se ejecutan una o ms sentencias, sino, si es falsa, se ejecutan otra u otras sentencias. En cualquiera de los dos casos, una vez finalizada la ejecucin de la seleccin, se contina ejecutando la sentencia que sigue en el orden secuencial a la sentencia de seleccin. En general podemos decir que una sentencia de seleccin, en la mayor parte de los lenguajes de programacin imperativos tiene la siguiente forma: si condicin entonces sentencia-1 sino sentencia-2 finsi Donde sentencia-1 puede ser una sentencia simple o compuesta y es la que se ejecuta si condicin evala a verdadero. A su vez, sentencia-2 puede ser una sentencia simple o compuesta y es la que se ejecuta si condicin evala a falso. sentencia-1 y sentencia-2 se conocen como ramas: la primera como rama del verdadero y la segunda como rama del falso o del sino. Muchos lenguajes de programacin permiten que la rama del falso sea opcional, es decir que puede estar presente o no. En ese caso el formato sera: si condicin entonces sentencia-1 finsi si condicin-1 entonces si condicin-2 Aqu estaba entonces sentencia-2-1 sentencia-1 sino sentencia-2-2 finsi sino sentencia-2 finsi Figura 4.11. Sentencias de seleccin anidadas Es de hacer notar que una sentencia de seleccin se ejecuta siempre, al menos para evaluar la condicin. Dependiendo del resultado de la evaluacin de la condicin se ejecutar una de las dos ramas, si tiene dos ramas; sino de acuerdo con el resultado de la evaluacin de la condicin podr ejecutarse o no la rama del verdadero.
Las sentencias de seleccin pueden anidarse. Esto significa que tanto sentencia-1 como sentencia-2 pueden a su vez contener sentencias de seleccin. Un ejemplo posible sera el de la Figura 4.11 donde sentencia-1 ha sido reemplazada con una sentencia condicional, la que a su vez tiene dos sentencias sentencia-2-1 y sentencia-2-2. El lenguaje Pascal acepta los dos tipos de variantes de sentencias de seleccin: la seleccin de rama vaca y la seleccin con dos ramas. Los siguientes son ejemplos de sentencias de seleccin vlidas: if (a=1) and b then a:=a+1; En esta seleccin de rama vaca, si la variable a vale 1 y b es true entonces se ejecutar la asignacin a a, caso contrario se seguir con la ejecucin de la sentencia siguiente al if. if (a = 1) and b then begin a:=a+1; b:= false; end; Ac slo se ejecutar la sentencia compuesta (todas las sentencias entre begin y end) en la rama del verdadero si la expresin condicional (a = 1) and b evala a verdadero, en caso contrario se seguir con la sentencia siguiente al if.
U.N.S.L. Argentina
44
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase if (a = 1) and b then begin a:=a+1; b:= false; end else a:=0;
Este ejemplo muestra una seleccin con dos ramas. Si la expresin (a = 1) and b es verdadera entonces se ejecutar la sentencia compuesta sino la sentencia de la rama del falso, que en este ejemplo es una sentencia simple (una asignacin) pero podra haber sido una compuesta. Existe una generalizacin de la sentencia de seleccin, que muchos lenguajes de programacin tienen, que es una sentencia de seleccin mltiple en donde dependiendo del valor de una expresin se ejecuta una de las alternativas de un grupo de alternativas dadas. Pascal permite el uso de la sentencia case para selecciones mltiples. Ver pgina 43 del libro Pascal, Manual del Usuario e Informe [K. Jensen y N. Wirth] para su explicacin.
Iteracin
Iterar es repetir. La accin o sentencia de iteracin es la que permite repetir la ejecucin de una o ms sentencias. Es la que permite comandar la repeticin de una o ms acciones tantas veces como sea necesario. La iteracin se conoce tambin bajo otros nombres: ciclo, bucle (espaolizacin del francs boucle que significa aro o rulo), o en ingls loop. En esta repeticin, cada vez que se ejecuta la o las sentencias comandadas por la iteracin, se dice que se pasa por el ciclo (o bucle, o loop), o se hace un ciclo (o bucle, o loop), o se ejecuta un ciclo (o bucle, o loop). Una iteracin tiene dos partes: la condicin que controla la repeticin y el bloque de la iteracin. Condicin Controla las veces que se ejecuta el Bloque de Iteracin Decimos que la condicin es la parte de la iteracin que controla la iteracin porque es la que nos dice cuntas veces (o hasta cuando) se har la repeticin. Llamamos el cuerpo o bloque de iteracin a la o las sentencias cuya ejecucin es controlada por la condicin.. As, diremos que es
Figura 4.12. Las partes de la iteracin el cuerpo de la iteracin el que se ejecuta repetidamente.
Generalmente, toda iteracin, antes de ejecutarse, necesita de algn tipo de inicializacin. A algunas variables, que forman parte tanto de la condicin como del bloque de iteracin, debe asignrseles un valor antes de comenzar a ejecutar la iteracin en s misma. Por lo general, esto debe hacerse en forma explcita justo antes de la iteracin, sin embargo, algunas veces, las variables vienen de antes con los valores correctos y necesarios. La condicin que comanda la iteracin es una expresin lgica, que sirve para controlar la cantidad de repeticiones, es decir las veces que se va a ejecutar el cuerpo de la iteracin. En efecto, cuando se desea repetir una o ms acciones un nmero determinado de veces y no indefinidamente, debe darse el nmero de veces o lo que equivale a lo mismo, debe darse la condicin para que se desarrolle la repeticin, o la condicin para que se detenga la repeticin. En el primer caso diremos que la iteracin ejecutar el bloque de iteracin mientras la condicin sea verdadera (o falsa, depende como se decida implementar la iteracin); y en el segundo caso, diremos que la iteracin ejecutar el bloque de iteracin hasta que la condicin sea verdadera (o falsa, depende como se decida implementar la iteracin). Si la ejecucin del bloque de la iteracin no se realiza, la iteracin termina y se contina con la ejecucin secuencial, es decir que se ejecuta la sentencia que sigue, en el orden secuencial, a la sentencia de iteracin. Si la ejecucin del bloque de la iteracin se realiza, al fin de dicha ejecucin, se volver a realizar la evaluacin de la expresin lgica, y as hasta que la condicin evale a un valor de verdad que sea el que controle el fin de la iteracin. Cada vez que se va a ejecutar el bloque de iteracin, se evaluar la expresin condicional, y de acuerdo con el resultado de esta evaluacin se proceder a realizar, o no, dicha ejecucin. La evaluacin de la condicin puede
U.N.S.L. Argentina
45
hacerse antes de ejecutar el bloque de iteracin o despus de ejecutarlo. Esto es significativo para la primera vez que se ejecuta la iteracin. En efecto, si la primera vez que se ejecuta la iteracin se debe primero evaluar la condicin podra resultar que siendo esta falsa (por ejemplo, si ese es el caso de finalizacin) no se ejecute nunca el bloque de iteracin. Pero si por el contrario, se evala la condicin despus de ejecutar el bloque de iteracin, an cuando la condicin sea falsa se habr ejecutado, al menos una vez, el bloque de iteracin. Esto tiene importancia para determinar cuntas veces puede llegar a ejecutarse el bloque de la iteracin. En efecto, si se evala la condicin antes de ejecutar el bloque de la iteracin, diremos que el bloque puede ejecutarse cero o ms veces (algunas veces se dice, aunque no sea del todo correcto, que la iteracin puede ejecutarse cero o ms veces), esto es as ya que al evaluar la condicin por primera vez podra ser que esta evaluara al valor que implica el fin de la iteracin y en consecuencia el bloque de la iteracin no se ejecutara. Por el contrario, si se evala la condicin despus de ejecutar el bloque de la iteracin, diremos que el bloque de la iteracin puede ejecutarse una o ms veces (algunas veces se dice, aunque no sea del todo correcto, que la iteracin puede ejecutarse una o ms veces). En efecto, al evaluar la condicin despus de la primera ejecucin del bloque podra ser que esta evaluara al valor que implica el fin de la iteracin, sin embargo el bloque de la iteracin ya se ejecut una vez. La iteracin se controla con una expresin lgica, esta es la encargada de determinar el fin de la misma, es decir cundo terminar la repeticin de la ejecucin del bloque de la iteracin. Una vez evaluada la expresin lgica, si esta toma un valor que implica la continuacin de la repeticin, slo podr cambiar su valor si dentro del bloque de la iteracin una o ms variables, que forman parte tambin de la expresin lgica, cambian su valor, haciendo que, a su vez, cambie el valor de la expresin lgica. A partir de esto, podemos deducir algunos principios elementales, que si bien no son suficientes, son necesarios para que la repeticin termine: a) Debe haber al menos una variable en la expresin lgica que controla la iteracin. Por ejemplo, en una iteracin que se ejecuta mientras su condicin es verdadera, si la expresin lgica que controla la iteracin es, por ejemplo, 1=1, esta expresin lgica (uno es igual a uno) ser siempre verdadera. La repeticin no se detendr jams (a menos que se desenchufe la computadora o alguna otra operacin similar!).
b) Al menos una de las variables que forman parte de la expresin lgica que controla la iteracin, debe ser modificada dentro del bloque de la iteracin. Es decir que dentro del bloque de la iteracin debe haber una o ms sentencias que modifiquen una o ms variables que forman parte de la condicin para que el valor de verdad que tome la condicin pueda variar. Por otro lado existen otras consideraciones que son importantes para el funcionamiento correcto, o mejor dicho para que la iteracin haga lo que se pretende de ella: a) Es conveniente establecer claramente no slo cul es la condicin que controla la iteracin, sino tambin la negacin de dicha condicin, que es la condicin en la que quedan las variables de la condicin cuando la iteracin ha terminado. Esto es importante ya que muchas veces, al terminar la iteracin podemos encontrarnos con valores inesperados en las variables que estaban en la condicin de la iteracin, ya sea porque han sido cambiados inadvertidamente o porque asumamos que tendran otros valores al terminar la iteracin.
b) Es importante conocer los valores en que se encuentran todas las variables, de la condicin y del bloque, antes de iniciarse la iteracin y una vez terminada la misma, y muchas veces tambin es importante conocer los valores de las variables cada vez que se ejecuta el bloque de iteracin. Pascal cuenta con tres variantes de sentencias de repeticin: la sentencia while, la sentencia repeat y la sentencia for. En general, si conocemos de antemano el nmero de veces que se debe ejecutar la iteracin, podemos usar el for; de lo contrario, lo usual es usar while o repeat. Sin embargo, las sentencias while y repeat son ms generales que la sentencia for ya que el efecto de una sentencia for siempre puede ser logrado por medio de una while. La sentencia de repeticin while tiene la siguiente forma: while expresin do sentencia; donde sentencia puede ser una sentencia simple o un bloque de sentencias. Aqu, sentencia se repetir mientras
U.N.S.L. Argentina
46
la condicin dada en expresin sea verdadera. Por ejemplo, el siguiente programa calcula la suma de los primeros n nmeros naturales, incluido el 0. program ejemploWhile; var suma, n, n1: integer; begin write('Ingrese un numero natural:'); readln(n); suma := 0; n1 := n; {conserva el valor inicial de n} while n > 0 do begin suma := suma + n; n := n-1; end; writeln('La suma de los ', n1, ' primeros numeros naturales es ', suma); end. La sentencia de repeticin repeat en Pascal tiene la siguiente forma: repeat sentencia until condicin; donde sentencia puede ser una sentencia simple o una compuesta (bloque de sentencias). sentencia se ejecuta al menos una vez y la condicin se evalu luego de cada ejecucin de sentencia. Esto se repite hasta que condicin sea verdadera. El ejemplo siguiente muestra al mismo programa de arriba pero ahora usando la sentencia repeat: program ejemploRepeat; var suma, n, n1: integer; begin write('Ingrese un numero natural:'); readln(n); suma := 0; n1 := n; {conserva el valor inicial de n} repeat begin suma := suma + n; n := n-1; end; until n = 0; writeln('La suma de los ', n1, ' primeros numeros naturales es ', suma); end. Una sentencia de repeticin for tiene una de las siguientes dos formas: for variable := expresin1 to expresion2 do sentencia; for variable := expresin1 downto expresion2 do sentencia; Al igual que en las otras variantes de sentencias de interacin, sentencia puede ser una sentencia simple o una compuesta (bloque de sentencias entre begin y end). Ac, sentencia se repetir un nmero de veces comandado por variable, que es conocida como la variable de control de la iteracin. Esta variable no puede ser alterada dentro del cuerpo de la iteracin. Inicialmente, la variable de control toma el valor dado por expresin1 repitindose sentencia hasta que la 47 Departamento de Informtica
U.N.S.L. Argentina
variable de control sea mayor (en el caso del to) o menor (en el caso del downto) al valor dado en expresion2. Es decir, una vez que a variable se le asigna el valor de expresin1, a continuacin se evala si es mayor (o menor, en el caso del downto) al valor de expresin2. Si la respuesta es no, entonces se ejecuta sentencia y luego se incrementa (en el caso del for-to) o decrementa (en el caso del for-downto) en 1 el valor de la variable de control y se repite el ciclo. Cuando la variable de control supera (o es menor, en downto) el valor dado en expresin2, la iteracin termina. Notemos que el cuerpo de la repeticin (sentencia) podra no ejecutarse nunca; por ejemplo en la sentencia de repeticin for i:=5 to 4 do j:=j+1; Los ejemplos siguientes muestra al mismo programa de arriba pero ahora usando la sentencia for-to y for-downto, respectivamente: program ejemploForTo; var suma, n, i: integer; begin write('Ingrese un numero natural:'); readln(n); suma := 0; for i:= 1 to n do suma := suma + i; writeln('La suma de los ', n, ' primeros numeros naturales es ', suma); end. program ejemploForDownto; var suma, n, i: integer; begin write('Ingrese un numero natural:'); readln(n); suma := 0; for i:= n downto 1 do suma := suma + i; writeln('La suma de los ', n, ' primeros numeros naturales es ', suma); end.
U.N.S.L. Argentina
48
Modularidad
CAPTULO 5 MODULARIDAD
Ya hemos dicho que un principio ampliamente difundido e importante para resolver problemas es el de dividir para reinar, es decir separar el problema en partes, en problemas ms chicos, para poder intentar enfrentarlos y resolverlos en un tamao ms accesible. Este principio tiene una directa aplicacin en los lenguajes de programacin a travs de estructuras de los mismos que reciben distintos nombres: mdulos, subprogramas, subrutinas, procedimientos, funciones y otros ms. En todos los casos los principios generales y elementales que los gobiernan son los mismos, an cuando algunos tengan caractersticas distintas y mayores o menores prestaciones. Todas ellas permiten separar un programa en partes ms pequeas y reusar pedazos, o mdulos, de programa ya escritos para resolver problemas similares. Los mdulos de programa tienen dos partes bien diferenciadas: la definicin del mdulo y la invocacin, o llamada (call, en ingls), del mdulo. La definicin o declaracin es la parte del mdulo que dice que es lo que el mismo har, es decir sus efectos, cuando sea invocado, es decir cuando se ejecute. La invocacin o llamada es cuando se quiere usar el mdulo (aqu es cuando, en tiempo de ejecucin del programa, se ejecutarn las acciones comprendidas en el mdulo).
EncabezamientoDePrograma ParteDeDeclaracinDeRtulos
ParteDeDefinicinDeConstantes
ParteDeDefinicinDeTipos ParteDeDeclaracin DeVariables ParteDeDeclaracinDeFunciones yProcedimientos
En sta parte es donde se declaran (se dice qu hace y cmo lo hace) los mdulos (procedimientos o funciones) en un programa Pascal.
En sta parte es donde se invocan (se ejecutan) los mdulos (procedure o function) en un programa Pascal. Aunque tambin pueden invocarse dentro de la declaracin de un mdulo.
Parte DeEnunciados
Figura 5. 1. Las partes de un programa Pascal. La penltima caja corresponde a la parte donde se declaran todos los mdulos (funciones y procedimientos) del programa, los que pueden invocarse ah mismo y en la ltima parte de enunciados. Para cada mdulo, por supuesto, hay una sola definicin ya que slo una vez puede decirse qu es lo que se har, pero puede haber ms de una invocacin ya que una solucin puede usarse tantas veces como sea necesario. Por supuesto que podra no usarse nunca, es decir no invocarse nunca, pero entonces, para qu se defini?
U.N.S.L. Argentina
49
Modularidad
As en Pascal los mdulos, que se llaman procedimientos (procedure) y funciones (function) se declaran en la parte de declaracin de procedimientos y funciones del programa. En la Figura 5.1 se puede ver la estructura general de un programa Pascal donde se muestra en qu parte se declaran los Mdulos y en qu parte se llaman o invocan. Las formas generales para la declaracin de los procedimientos y las funciones en Pascal son las siguientes respectivamente: procedure identificador(listaDeParametrosFormales); { encabezado } bloque; function identificador(listaDeParametrosFormales): tipo; { encabezado } bloque; donde identificador es el nombre que le damos al mdulo y que usaremos en la invocacin al mismo. La listaDeParametrosFormales es una lista separada por comas con los nombres de sus parmetros formales, la cual puede estar vaca, es decir, un mdulo podra no tener parmetros. All tambin deber especificarse el tipo de cada uno de los parmetros y, como veremos en la seccin siguiente, la forma de pasaje empleada (por valor o constante o por direccin o variable) para cada uno de los parmetros. En el caso de las funciones, adems, en el encabezado del mdulo, se debe especificar cul es el tipo del resultado, que indica cul es el tipo de los valores que la funcin puede devolver como resultado. A continuacin del encabezado viene el bloque o cuerpo del mdulo. Ac el bloque, al igual que en el programa principal, se compone de una parte de definiciones y declaraciones de datos (tipos, constantes y variables), una parte para las declaraciones de mdulos (es decir, podemos definir mdulos anidados) y una parte de enunciados o sentencias. El ejemplo siguiente muestra la declaracin de la funcin multiplica que calcula el producto de dos nmeros naturales m y n por sumas sucesivas: function multiplica(m, n: integer): integer; var i, resul: integer; begin resul := 0; i:=1; while i <= n do begin resul := resul + m; i:= i+1; end; multiplica := resul; end; En la parte de las sentencias de una funcin en Pascal, siempre debe haber una asignacin al identificador usado para identificar la funcin (en el ejemplo multiplica) para retornar el resultado. La invocacin de un mdulo puede hacerse de varias maneras, dependiendo del lenguaje. Esta invocacin se hace, generalmente, empleando el nombre del mdulo junto con los parmetros actuales (si los tuviera). Por otro lado, diremos que en general los mdulos pueden invocarse en el lugar donde va una sentencia o una expresin. En el caso del Pascal, los procedimientos se invocan como una sentencia ms dentro de un programa. Una vez invocado el mdulo y ejecutado, se contina con la sentencia que sigue a la invocacin. Las funciones por su parte son invocadas dentro de una expresin, cuyo tipo corresponde al tipo de declarado para la funcin; algunos ejemplos de invocacin de la funcin multiplica son los siguientes: var a, b, r: integer; a := 5; b := 10; writeln(el resultado de , a, x, b, =,multiplica(a, b)); r:= a + multiplica(33, 23) + 1000;
U.N.S.L. Argentina
50
Modularidad
5.1 Parmetros
Un mdulo, generalmente, realizar alguna tarea empleando datos que le son provistos. Estos datos se le dan al mdulo para ser procesados, en el momento de su ejecucin. Hay varias formas de proveerle los datos que el mdulo necesita durante su ejecucin. Una de las formas ms usuales es a travs del uso de parmetros. En la definicin del mdulo dichos datos concretos no existen. Estamos hablando de variables que tomarn un valor cuando el mdulo sea invocado. Estas variables se conocen como parmetros formales. Al ser invocado el mdulo, habr que darle los valores reales con los que trabajar. Estos valores los tomarn los parmetros formales. En la invocacin del mdulo estos valores se conocen como parmetros reales o actuales. Se habla as de pasarle, al mdulo, los parmetros reales, es decir los datos concretos que el mdulo deber procesar. Algunos languajes llaman argumentos a los parmetros. Otros reservan argumentos para los parmetros formales y parmetros para los parmetros reales.
Pasaje de parmetros
La forma en que se realiza la asociacin entre los parmetros formales y los reales se lo conoce como pasaje de parmetros. Los parmetros pueden ser pasados al mdulo de muchas maneras. Dos de las ms comunes o usuales son el pasaje que se llama por valor o constante y el que se llama por variable o direccin o referencia. En el pasaje por valor, el dato que se pasa al mdulo es una copia del dato. Es decir, el valor del parmetro real es copiado en el parmetro formal, de ah que se denomine por valor. Todo cambio que se haga al parmetro formal dentro del mdulo no se ver reflejado en el parmetro real. En el pasaje por variable sera equivalente a pasar la variable donde se encuentra el dato y no el dato mismo. Se puede decir que lo que se pasa es la direccin del parmetro real. En consecuencia, todo cambio que se haga sobre el parmetro formal se ver reflejado en el parmetro real. Es por esta razn que cuando la declaracin de un parmetro formal es hecha por direccin o variable, el correspondiente parmetro actual no puede ser una constante, debe ser siempre una variable. Una imagen que puede evocarse para distinguir ambos mtodos de pasaje de parmetros es la que equivale a decir que, si uno tiene un cuaderno con notas tiene dos formas de pasarle esas notas a un compaero: le da una fotocopia de las notas (ste es el pasaje por valor o constante) o le da el cuaderno mismo (pasaje por variable). Pero claro, en ste ltimo caso, si el compaero no cuida el cuaderno puede ser que ste termine escrito con otras cosas, manchado o inclusive se pierda!
5.2 mbitos de validez

Hay lenguajes que tratan los mdulos como programas y permiten la definicin, dentro del mismo, de otros mdulos, variables, etc., que le son propias y no pueden ser empleadas por otros mdulos o por el programa principal. Estos mdulos, variables, etc., tienen como mbito de validez, o de existencia, la del mdulo donde han sido definidos. Tambin se dice que son locales al mdulo, por oposicin a los que se definen en el programa principal que se los llama globales.
Ejemplo de uso de procedimientos, funciones, con sus parmetros

En los ejemplos que siguen las operaciones ejemplificadas se hace sobre nmeros naturales. Sin embargo en el cdigo de los programas el control de las entradas (que realmente sean naturales) no se hace. Esto es para hacer ms legible el programa. En la Figura 5.2 vemos un programa en Pascal que multiplica dos nmeros naturales empleando la suma. El programa de la Figura 5.3 hace m , pero en este caso lo hace empleando la multiplicacin.
n
U.N.S.L. Argentina
51
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase Como puede verse en la Figura 5.3, lo que se hace dentro de la iteracin es multiplicar r con m.
Modularidad
Si se quiere que la exponenciacin se haga con multiplicaciones que a su vez se hacen con sumas, entonces, como se ve en la Figura 5.3, sera interesante que la iteracin del programa multiplica_1, apareciese dentro de la iteracin del programa potencia_1. Es decir que esa iteracin, que multiplica con sumas, debera reemplazar a la multiplicacin m*r. Esto, tambin, podra hacerse empleando un mdulo. En la Figura 5.4, puede verse un nuevo programa, multiplica_2, el que es una modificacin de multiplica_1, para emplear un mdulo, en este caso el procedimiento (procedure) mul_1. Puede observarse que los parmetros formales de mul_1 (m, n) tienen el mismo identificador (mismo nombre) que las variables globales (m, n); esto no causa ningn inconveniente ya que los parmetros formales de un mdulo (en este caso un procedure en Pascal), son locales al mdulo, y en consecuencia distintas de las variables fuera del mdulo. Por supuesto que de esto se encarga de implementarlo el compilador. Tambin podemos observar que el mdulo mul_1 emplea la variable r, que es una variable global del programa, y que la misma es empleada para devolver el resultado de la multiplicacin.
program multiplica_1; var m,n,r: integer; begin { del programa principal } readln(m, n); r:= 0; while m > 0 do begin r:= r + n; m:= m - 1; end; writeln(r); end. { del programa principal } Figura 5.2 Programa que multiplica dos naturales empleando la suma.
Ahora este procedimiento mul_1 puede emplearse para hacer un nuevo programa de exponenciacin, que llamamos potencia_2, que se muestra en la Figura 5.5. Lo que hemos hecho ha sido copiar el trozo de programa que contiene el procedure mul_1 en multiplica_2 y pegarlo en el nuevo programa de exponenciacin potencia_2. program potencia_1; var m,n,r: integer; begin { del programa principal } readln(m, n); r:= 0; r:= 1; while m > 0 do while n > 0 do begin r:= r + n; begin m:= m 1; r:= m * r; end n:= n 1; Iteracin del programa multiplica_1 end; writeln(r); end. { del programa principal } Figura 5.3. Programa que hace mn (m y n son naturales) empleando la multiplicacin. program multiplica_2; var m,n,r: integer; procedure mul_1(m, n: integer); begin { de mul_1 } r:= 0; while m > 0 do begin r:= r + n; m:= m 1; end; end; { de mul_1 } begin { del programa principal } readln(m, n); mul_1(m, n); writeln(r); end. { del programa principal }
Figura 5.4. Programa que multiplica dos naturales empleando la suma en un mdulo mul_1.
U.N.S.L. Argentina
52
Modularidad
program potencia_2; var m,n,r: integer; procedure mul_1(m, n: integer); begin { de mul_1 } r:= 0; while m > 0 do begin r:= r + n; m:= m 1; end end; { de mul_1 } begin { del programa principal } readln(m, n); r:= 1; while n > 0 do begin mul_1(m, r); n:= n 1; end; writeln(r); end. { del programa principal } Figura 5.5. Programa que hace mn (m y n son naturales) empleando la multiplicacin con la suma.
Tabla 5.2. Una ejecucin de potencia_2 Parmetros formales de Programa Principal potencia_2 mul_1 m n r m n readln(m, n) 3 2 ? r:= 1 3 2 1 1 iteracin PP 3 2 1 mul_1(m, r) 3 2 1 invocacin 3 1 r:= 0 0 3 1 0 1 interacin 3 1 1 r:= r + n 3 1 1 m:= m 1 2 1 1 2 interacin 2 1 2 r:= r + n 2 1 2 m:= m 1 1 1 2 3 interacin 1 1 3 r:= r + n 1 1 3 m:= m 1 0 1 n:= n 1 3 1 3 2 interacin PP 3 1 3 mul_1(m, r) 3 1 3 invocacin 3 3 r:= 0 0 3 3 0 1 interacin 3 3 3 r:= r + n 3 3 3 m:= m 1 2 3 3 2 interacin 2 3 6 r:= r + n 2 3 6 m:= m 1 1 3 6 3 interacin 1 3 9 r:= r + n 1 3 9 m:= m 1 0 1 n:= n 1 3 0 9
Veamos que en el programa potencia_2 la variable global r se emplea como variable auxiliar para devolver el resultado final de la exponenciacin y el resultado de la multiplicacin en el procedure mul_1. Siendo que dicha variable es inicializada en cada iteracin de multiplicacin, que es empleada a su vez, por la iteracin de la exponenciacin, se podra pensar que potencia_2 tiene un error serio y que no entrega un resultado correcto mn. Sin embargo este no es el caso. La sutileza de lo que en realidad sucede puede constatarse, por ejemplo, realizando una ejecucin paso a paso del programa. Esto muestra que los potenciales errores que puedan crearse a partir del uso de variables globales pueden ser difciles de detectar. En la Tabla 5.2 mostramos los valores de una ejecucin posible del programa. Dado que el programa multiplica_2 emplea una variable global (r), esto le quita generalidad, ya que obliga a declarar tal variable si queremos emplear el mdulo mul_1. Para que eso no sea necesario, podemos modificar el programa multiplica_2 y el correspondiente mdulo (procedure mul_2) para devolver el resultado en un parmetro pasado por direccin/variable. Por supuesto este cambio es incorporado, tambin, en el programa de exponenciacin. Ambos programas pueden verse en las Figuras 5.6 y 5.7.
U.N.S.L. Argentina
53
Modularidad
program multiplica_3; var m,n,r: integer; procedure mul_2(m, n: integer; var r: integer); begin { de mul_2 } r:= 0; while m > 0 do begin r:= r + n; m:= m - 1; end end; { de mul_2 } begin { del programa principal } readln(m, n); mul_2(m, n, r); writeln(r); readln; end. { del programa principal }
Figura 5.6. Programa que multiplica dos naturales empleando la suma en un mdulo mul_2.
program potencia_3; var m,n,r: integer; procedure mul_2(x, y: integer; var r: integer); begin { de mul_2 } r:= 0; while y > 0 do begin r:= r + x; y:= y - 1; end end; { de mul_2 } begin { del programa principal } readln(m, n); r:= 1; while n > 0 do begin mul_2(m, r, r); n:= n - 1; end; writeln(r); readln; end. { del programa principal }
Figura 5.7. Programa que hace mn (m y n son naturales) empleando la multiplicacin con la suma.
Otro ejemplo de uso de procedimientos, funciones, con sus parmetros

Ejemplo 1
El programa que simula una calculadora (calcul_1), lo empleamos aqu para ejemplificar el uso de mdulos (procedimientos y funciones en Pascal) y de parmetros.
{ simula una calculadora } program calcul_1; var a : integer; { primer numero } b : integer; { segundo numero } r : integer; { resultado } op : char; { operacion } s : char; { 'e' = encendida, otra = apagada; } { * programa principal * } begin readln(s); { enciende = 'e' o apaga = otro; la calculadora } while s = 'e' do { itera mientras la calculadora esta en 'e' begin readln(a); { entra el primer numero } readln(op); { entra la operacion } readln(b); { entra el segundo numero } if op = '+' { es suma ? } then r := a + b; { calcula el resultado y lo guarda en r if op = '-' { es resta ? } then r := a - b; { calcula el resultado y lo guarda en r if op = '*' { es multiplicacion ? } then r := a * b; { calcula el resultado y lo guarda en r if op = '%' { es division ? } then r := a div b; { calcula el resultado y lo guarda en writeln(r); { muestra el resultado } readln(s); { prende o apaga la calculadora } end; { de la iteracion } end.
= encendida }
} } } r }
U.N.S.L. Argentina
54
Modularidad
Ejemplo 2
En el segundo ejemplo, calcul_2, el programa es similar al primero (calcul_1), salvo que en este ejemplo, (calcul_2), los operandos (a y b) son entrados empleando un mdulo, en este caso una funcin (entrarOp). La funcin no cambia mucho en el programa, slo la llamada. { simula una calculadora, lee operandos usando un modulo que usa el read } program calcul_2; var a : integer; { primer operando } b : integer; { segundo operando } r : integer; { resultado } op : char; { operacion } s : char; { 'e' = encendida, otra = apagada; } { entra el operando usando read, no hay mucha diferencia con el programa anterior!!! } function entrarOp : integer; var x: integer; begin readln(x); entrarOp:= x end; { de entrarOp } begin { * programa principal * } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); while s = 'e' do { itera mientras la calculadora esta en 'e' = encendida } begin { entra el primer operando. La llamada es la misma es la misma que en el programa anterior } writeln(Primer Operando ? ); a:= entrarOp; writeln(Operacin ? ); readln(op); { entra la operacion } { entra el segundo operando. La llamada es la misma es la misma que en el programa anterior } writeln(Segundo Operando ? ); b:= entrarOp; if op = '+' { es suma ? } then r := a + b; { calcula el resultado y lo guarda en r } if op = '-' { es resta ? } then r := a - b; { calcula el resultado y lo guarda en r } if op = '*' { es multiplicacion ? } then r := a * b; { calcula el resultado y lo guarda en r } if op = '%' { es division ? } then r := a div b; { calcula el resultado y lo guarda en r } writeln(Resultado: , r); { muestra el resultado } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); end; { de la iteracion } end.
Ejemplo 3
Veamos ahora una versin algo diferente del mismo programa de la calculadora. Nuevamente los operandos (a y b) son entrados empleando un mdulo, en este caso una funcin, pero ahora la funcin permite entrar el nmero correspondiente como una cadena de caracteres. La forma de convertir la cadena de caracteres a un nmero es empleando una variable (cad2) comn a los dos mdulos (leerCad y cadenaaNat), que se encuentran definidos dentro de la funcin (entrarOp), que sirve para entrar los operandos. El procedimiento leerCad lee la cadena de caracteres, que deben ser supuestamente caracteres entre 0..9, hasta que se entren n caracteres o hasta que se entre un *. Pone el dgito ms significativo en la posicin uno del arreglo que soporta (almacena) a la cadena. La funcin cadenaaNat convierte la cadena de caracteres, que deben ser supuestamente caracteres entre 0..9, en un nmero natural. Lo hace suponiendo que el dgito ms significativo est en la posicin uno del arreglo que soporta (almacena) a la cadena, que los dgitos estn consecutivos y que si hay menos de n dgitos lo que sigue
U.N.S.L. Argentina
55
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase son *.
Modularidad
En la Figura 5.2 se puede ver un ejemplo grfico de mbitos de existencia de constantes, tipos, variables y mdulos del programa calcul_3. { simula calculadora, lee operandos usando un modulo que acepta una cadena } program calcul_3; const mxCad = 5; { largo de la cadena de caracteres para el nmero } type cadenaNum = array[1..mxCad] of char; var a : integer; { primer operando } b : integer; { segundo operando } r : integer; { resultado } op : char; { operacion } s : char; { 'e' = encendida, otra = apagada; } { x elevado a y } function elev(x, y: integer) : integer; var r: integer; begin if y >= 0 then begin r:= 1; while y > 0 do begin r:= r * x; y:= y - 1 end; elev:= r end else begin writeln(error: exponente negativo); elev:= -1 end end; { de elev } { entra el operando como una cadena de caracteres y no como un nmero entero} function entrarOp : integer; var cad2: cadenaNum; { lee una cadena de caracteres '0'..'9', y lo deja en la variable cad2, que es global dentro de entrarOp, NO del programa principal. Modifica, en consecuencia a la variable cad2, lo cual no es muy buena prctica de programacin } procedure leerCad; var i: integer; c: char; begin { de leerCad } i:= 1; while i <= mxCad do begin cad2[i]:= *; i:= i + 1 end; i:= 1; c:= 0; { para entrar en la iteracin } while (i <= mxCad) and (c <> *) do begin readln(c); { aqu habria que controlar que c = 0..9 o *}
U.N.S.L. Argentina
56
Modularidad
cad2[i]:= c; i:= i + 1; end; end; { de leerCad } { convierte una cadena de caracteres '0'..'9', en un nmero natural y lo devuelve. Toma la cadena de la variable cad2 } function cadenaaNat : integer; var i, e, x: integer; begin { de cadenaaNat - version 1} i:= mxCad; e:= 0; x:= 0; while i >= 1 do begin if cad2[i] <> * then begin x:= x + (ord(cad2[i]) - ord(0)) * elev(10,e); e:= e + 1 end; i:= i - 1 end; cadenaaNat:= x end; { de cadenaaNat } begin { de entrarOp } { lee una cadena de caracteres en cad2, porque es una variable declarada en entrarOp } leerCad; { convierte la cadena cad2 en un natural, y lo devuelve a entrarOp entrarOp:= cadenaaNat end; { de entrarOp } begin { * programa principal * } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); while s = 'e' do { itera mientras la calculadora esta en 'e' = encendida } begin {entra 1er operando. La llamada es la misma que en el programa anterior } writeln(Primer Operando ? ); a:= entrarOp; writeln(Operacin ? ); readln(op); { entra la operacion } { entra el segundo operando. La llamada es la misma que en program anterior } writeln(Segundo Operando ? ); b:= entrarOp; if op = '+' { es suma ? } then r := a + b; { calcula el resultado y lo guarda en r } if op = '-' { es resta ? } then r := a - b; { calcula el resultado y lo guarda en r } if op = '*' { es multiplicacion ? } then r := a * b; { calcula el resultado y lo guarda en r } if op = '%' { es division ? } then r := a div b; { calcula el resultado y lo guarda en r } writeln(Resultado: , r); { muestra el resultado } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); end; { de la iteracion } end.
U.N.S.L. Argentina
57
Modularidad
Figura 5.2. Ejemplo de mbitos de existencia de variables y mdulos, en el programa calcul3
Variables globales del programa. Todos los mdulos del programa pueden emplearlas, as como ser usadas en la parte de sentencias del programa.
program calcul_3; const mxCad = 5; type cadenaNum = array[1..mxCad] of char; var a : integer; { primer operando } b : integer; { segundo operando } r : integer; { resultado } op : char; { operacion } s : char;
function elev(x, y: integer) : integer; var r: integer; begin { de elev } { sentencias de elev ) end; { de elev }
function entrarOp : integer; var cad2: cadenaNum; procedure leerCad; var i: integer; c: char; begin { de leerCad } { sentencias de leerCad ) end; { de leerCad }
Mdulos definidos dentro del programa. Todos los otros mdulos del programa pueden invocarlos, as como ser invocados en la parte de sentencias del programa.
Estos dos mdulos estn declarados dentro de ste otro mdulo. Por lo tanto slo pueden ser vistos dentro de se mdulo.
function cadenaaNat : integer; var i, e, x: integer; begin { de cadenaaNat} { sentencias de cadenaaNat ) end; { de cadenaaNat } begin { de entrarOp } leerCad; entrarOp:= cadenaaNat end; { de entrarOp }
begin { * programa principal * } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); while s = 'e' do begin writeln(Primer Operando ? ); a:= entrarOp; writeln(Operacin ? ); readln(op); { entra la operacion } writeln(Segundo Operando ? ); b:= entrarOp; . . . end { de la iteracin} . . . end.
Esta variable es local al mdulo en el que esta declarada y slo puede ser vista dentro del msmo, ya sea en la parte de sentencias o por los otros dos mdulos declarados dentro de l.
U.N.S.L. Argentina
58
Modularidad
Ejemplo 4
Otra forma de hacer el programa de la calculadora es el que se muestra en el programa calcul_4. Tambin aqu los operandos (a y b) son entrados empleando un mdulo, que es una funcin, y la funcin permite entrar el nmero como una cadena de caracteres, pero ahora no emplea una variable comn a los mdulos definidos dentro de entrarOp sino que se emplean parmetros. En un caso el pasaje de parmetros se hace por variable o direccin (leerCad) y en el otro por constante o valor (cadenaaNat). { simula calculadora, lee operandos usando un modulo que acepta una cadena } program calcul_4; const mxCad = 5; { largo de la cadena de caracteres para el nmero } type cadenaNum = array[1..mxCad] of char; var a : integer; { primer operando } b : integer; { segundo operando } r : integer; { resultado } op : char; { operacion } s : char; { 'e' = encendida, otra = apagada; } { x elevado a y } function elev(x, y: integer) : integer; var r: integer; begin if y >= 0 then begin r:= 1; while y > 0 do begin r:= r * x; y:= y - 1 end; elev:= r end else begin writeln(error: exponente negativo); elev:= -1 end end; { de elev } { entra el operando como una cadena de caracteres y no como un entero } function entrarOp : integer; var cad2: cadenaNum; { lee una cadena de caracteres '0'..'9', y la deja en el parmetro formal cad, pero como cad pasa por variable o direccin, el parmetro real se modificar} procedure leerCad (var cad: cadenaNum); var i: integer; c: char; begin { de leerCad } i:= 1; while i <= mxCad do begin cad[i]:= *; i:= i + 1 end; i:= 1; c:= 0; { para entrar en la iteracin } while (i <= mxCad) and (c <> *) do
U.N.S.L. Argentina
59
Modularidad
begin readln(c); { aqu habria que controlar que c = 0..9 o *} cad[i]:= c; i:= i + 1; end; end; { de leerCad } { convierte una cadena de caracteres '0'..'9', en un nmero natural } function cadenaaNat (cad: cadenaNum): integer; var i, e, x: integer; begin { de cadenaaNat - version 2 } i:= mxCad; while (i >= 1) and (cad[i] = *) do i:= i - 1; e:= 0; x:= 0; while i >= 1 do begin x:= x + (ord(cad[i]) - ord(0)) * elev(10,e); e:= e + 1; i:= i - 1 end; cadenaaNat:= x end; { de cadenaaNat } begin { de entrarOp } { lee una cadena de caracteres en cad2, porque pasa por variable } leerCad(cad2); { convierte la cadena cad2 en un natural, y lo devuelve a entrarOp} entrarOp:= cadenaaNat(cad2) end; { de entrarOp } begin { * programa principal * } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); while s = 'e' do { itera mientras la calculadora esta en 'e' = encendida } begin { entra el primer operando. La llamada es la misma es la misma que en program anterior } writeln(Primer Operando ? ); a:= entrarOp; writeln(Operacin ? ); readln(op); { entra la operacion } { entra el segundo operando. La llamada es la misma es la misma que en program anterior } writeln(Segundo Operando ? ); b:= entrarOp; if op = '+' { es suma ? } then r := a + b; { calcula el resultado y lo guarda en r } if op = '-' { es resta ? } then r := a - b; { calcula el resultado y lo guarda en r } if op = '*' { es multiplicacion ? } then r := a * b; { calcula el resultado y lo guarda en r } if op = '%' { es division ? } then r := a div b; { calcula el resultado y lo guarda en r } writeln(Resultado: , r); { muestra el resultado } writeln(Sigue ? (si ==> e; no ==> otro)); readln(s); end; { de la iteracion } end.
U.N.S.L. Argentina
60
Estructuras de Datos
CAPTULO 6 ESTRUCTURAS DE DATOS

6.1 Introduccin
Emplear un dato o una informacin, cuyo valor cambia, implica usar una variable, que en computacin equivale a darle un nombre a un lugar, donde se almacenar el valor que se necesite. Esto en contrapartida con el uso de constantes que son justamente valores que no cambian. Hablamos en este caso de un valor, de un tipo dado, por vez. Sin embargo ms de una vez ser necesario conservar ms de un valor. Esto es fcil de realizar empleando variables para cada uno de los valores que sean necesarios. Por otro lado, hay veces que estos datos, por alguna razn, tienen una unidad conceptual y conviene mantenerlos juntos y no separados en variables distintas. Por ejemplo todos los datos que corresponden a una persona: edad, estado civil, nombre y apellido, direccin, documento de identidad, etc. Estos valores, estos datos, debern, entonces, ser agrupados en una unidad, en un conjunto, que llamaremos estructura. Una estructura de datos o de informacin es un conjunto de cosas, de valores, que se agrupan por alguna razn. Este agrupamiento lleva implcito un almacenamiento de cada uno de los componentes de la estructura. Por otro lado la estructura de datos puede ser potencial. Es decir puede haber una planificacin de cmo un conjunto de datos se agruparn, an cuando todava no haya ningn valor para guardar. En general hablaremos de estructura de informacin o de datos indistintamente. Llamaremos elementos de la estructura a cada uno de sus componentes. A cada uno de los datos que forman parte de ella. Una estructura de datos presupone un conjunto de elementos y tiene, por lo menos potencialmente, la posibilidad de tener ms de un elemento, de lo contrario no podra hablarse de estructura. As entonces, cuando se tiene una estructura de datos que puede tener ms de un elemento, surgen distintos interrogantes sobre la estructura y su contenido (sus elementos): (a) Cmo se incorpora un nuevo elemento a la estructura. (b) Cmo se elimina o cambia un elemento que ya est en la estructura. (c) Cmo se busca un elemento, que ya est en la estructura, ya sea para conocerlo o inspeccionarlo, para eliminarlo de la estructura o para buscarle un lugar a uno nuevo. Estos tres aspectos tienen que ver con las operaciones que pueden hacerse sobre la estructura de datos. (d) Cmo se guardan los elementos en la estructura, es decir en qu orden se encuentran unos con respecto a los otros. (e) Cuntos elementos se pueden guardar, esto tiene que ver con la capacidad de almacenamiento de la estructura. (f) Cmo se identifica o selecciona a los distintos elementos de la estructura. Es necesario poder distinguir, sin ambigedad, cada uno de los elementos de la estructura. Llamamos a esto el selector de la estructura. (g) Qu tipo de los datos pueden guardarse en la estructura, esto es el tipo de datos de los elementos de la estructura. A este tipo de dato le llamaremos tipo de dato base de la estructura. Estas caractersticas no siempre se encuentran todas presentes en los lenguajes de programacin. Algunos lenguajes tienen algunas de ellas otros otras. Tampoco todos los lenguajes de programacin tienen la capacidad de administrar todas las estructuras de datos que presentamos en ste captulo. Esta presentacin es una abstraccin de las principales estructuras de datos y sus caractersticas.
U.N.S.L. Argentina
61
6.2 Capacidad
Una estructura de datos tiene una capacidad para almacenar elementos. La misma puede ser tericamente infinita aunque en la prctica esto no ser as. Cuando la capacidad es finita la misma puede ser dinmica o esttica. As hablaremos de estructuras de datos dinmicas y estructuras de datos estticas dependiendo del tipo de capacidad que las mismas tengan.
Capacidad dinmica
Cuando hablamos de capacidad dinmica es cuando la capacidad de la estructura, para almacenar elementos, crece o disminuye de acuerdo con las incorporaciones o eliminaciones, respectivamente, de elementos. Si bien la estructura crece con las inserciones y disminuye con las supresiones, tiene un lmite mximo a su crecimiento, lo que est dado por la finitud de la capacidad de la estructura.
Capacidad esttica
Esta implica que la capacidad de la estructura es constante ya sea que se incorporen o saquen elementos de la misma. Es decir que la estructura tiene un nmero fijo y determinado de elementos y la cantidad de los mismos no vara con las inserciones y supresiones.
6.3 Operaciones
Distinguiremos tres operaciones fundamentales que pueden realizarse sobre una estructura de datos y sus elementos: COLOCAR un elemento nuevo en la estructura. Para el caso de las estructuras estticas, como esto no implica que la misma crece, hablaremos entonces de una asignacin de un valor a un elemento de la estructura. Para el caso de las estructuras dinmicas esto implica que la cantidad de elementos de la misma aumenta, hablaremos, entonces, de una insercin. SACAR, de la estructura, un elemento ya existente en ella. Para el caso de las estructuras estticas esto no implica que la misma disminuye, hablaremos entonces de una asignacin que se har sobre un valor ya existente, haciendo que ste ltimo desaparezca. Para el caso de las estructuras dinmicas esto implica que la cantidad de elementos de la misma disminuye, hablaremos, entonces, de una supresin. I SPECCIO AR la estructura, para conocer el valor que tienen sus elementos. Esto puede hacerse con uno o ms elementos, eventualmente todos ellos y puede hacerse de a uno o muchos (todos) en forma sistemtica. La inspeccin se hace de a un elemento por vez, no puede hacerse simultneamente con ms de un elemento. La inspeccin de los elementos NO modifica no el valor contenido en los mismos ni el tamao de las estructuras. Se dice que la inspeccin (o lectura del valor contenido en un elemento) no es destructiva. En realidad para las estructuras estticas no existe una diferencia notable entre las operaciones de colocar y sacar, simplemente se trata de cambiar un valor de un elemento por otro valor. En el caso de las estructuras dinmicas, como stas crecen con las inserciones y disminuyen con las supresiones, pueden estar, en algn momento, vacas (por ejemplo si se han suprimido todos sus elementos o cuando no se ha insertado ninguno). Para estos casos ser til conocer si la estructura tiene al menos un elemento o est vaca. Esto se realiza por medio de una pregunta a la estructura para saber si est vaca o no, o lo que es lo mismo si tiene al menos un
U.N.S.L. Argentina
62
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase elemento o no.
Esta pregunta es en realidad un PREDICADO lgico, aplicado sobre la estructura dinmica, que devuelve verdadero o falso, a la pregunta de si la estructura est vaca.
6.4 Orden de los elementos

Cualquiera sea la estructura sta tendr un orden, es decir sus elementos estarn guardados en la estructura en un orden dado, an cuando no parezca as. Siendo que sus elementos estarn almacenados debern tener algn orden. Entendiendo por orden una relacin de un elemento con todos los otros. Segn el Diccionario orden es: Colocacin de las cosas en el lugar que les corresponde o Concierto, buena disposicin de las cosas entre s o Serie o sucesin de las cosas. Muchas veces el orden de los elementos de una estructura es propio de la estructura en s misma, otras veces, por encima del orden que la misma estructura impone, existe un orden que surge del manejo que de la estructura y sus elementos se haga. Por ejemplo en una cola frente a una ventanilla para ser atendido el orden es, normalmente y si no hay colados!, el primero en llegar a la cola es el primero que es atendido. Sin embargo por encima de ste orden la cola podra haber sido ordenada alfabticamente de acuerdo con los apellidos de las personas en la misma. Todava sera atendido el primero que se encuentra en la cola, sin embargo, sta (la cola) habra sido reconstituida, hecha de nuevo, para poder ordenarla alfabticamente. De la cola original, se habra hecho otra poniendo primero en ella al que le correspondiese alfabticamente estar primero. En esta nueva cola, ordenada alfabticamente, habra ingresado primero, y sera atendido primero, el que le corresponda estar primero alfabticamente. Diremos que, para el caso de los elementos de las estructuras de datos, el orden puede ser Cronolgico y Cronolgico. o
Cronolgico
Cuando hablamos de orden cronolgico es que queremos hacer referencia de alguna manera al tiempo. En efecto, en ste caso, el tiempo juega un papel en la forma que los elementos de las estructuras de datos se ordenan unos con otros. Este orden puede reconocerse que es impuesto, en algunas estructuras de datos, por la estructura misma. El orden cronolgico, a su vez, puede ser: De llegada a la estructura, es decir que los elementos se encuentran ordenados de acuerdo al tiempo, al momento en el tiempo, en el que ingresaron a la estructura. De salida de la estructura, es decir que los elementos se encuentran ordenados de acuerdo al tiempo, al momento en el tiempo, en que se encuentran listos para salir de la estructura. De recorrida o inspeccin de la estructura, es decir que los elementos se encuentran ordenados de acuerdo al momento en que son encontrados cuando se recorre o inspecciona la estructura.
o cronolgico
En este orden el tiempo no juega un papel significativo. Los elementos se encuentran ordenados sin ninguna referencia a alguno de los tipos de orden mencionados en la seccin anterior, es decir que no se encuentran ordenados con relacin al tiempo. Pueden encontrarse ordenados por algn otro criterio. Por ejemplo ordenados alfabticamente, siguiendo el orden de los naturales, etc. Este orden puede reconocerse que no es impuesto en las estructuras de datos por la estructura misma, sino que es impuesto por la manipulacin que se haga de la estructura y de sus elementos.
U.N.S.L. Argentina
63
6.5 Selector de los elementos

El selector de una estructura sirve para seleccionar, elegir, identificar, a cada uno de los elementos de la estructura para poder realizar alguna operacin sobre ellos: cambiarlo, inspeccionarlo, eliminarlo, etc. El selector debe ser unvoco, es decir no puede permitirse que dentro de una estructura exista la posibilidad de ambigedad en la eleccin de un elemento. Cada elemento debe estar unvocamente identificado. Para ello el selector debe tener tantos identificadores como elementos pueda tener la estructura o el orden de los elementos debe permitir identificarlos sin ambigedades. Los selectores pueden ser explcitos o implcitos. Decimos que el selector es explcito cuando cada elemento de la estructura debe ser identificado con un selector o con un valor del selector. En este caso decimos que el selector tiene un tipo de dato. Este tipo de dato del selector puede ser estndar a la estructura (por ejemplo los nmeros naturales) o puede necesitar de una definicin explcita. Decimos que el selector es implcito cuando no es necesario definir, tener un tipo de dato, para el selector o ste no tiene un tipo dado (por ejemplo los naturales). En este caso podemos hacer referencia a los elementos a partir de su posicin, de su ordenamiento, dentro de la estructura. Decimos que implcitamente, sin necesidad de ninguna referencia explcita, hacemos referencia a los elementos de la estructura.
6.6 Tipo base

Las estructuras de datos pueden almacenar elementos o datos y estos pertenecern a un tipo de dato. Sin embargo una estructura puede almacenar no solo valores de un tipo de dato sino de distintos tipos de datos. Adems los elementos de la estructura pueden ser valores simples o elementales (tales como el tipo char o entero, etc.) o tambin podran ser de tipo compuesto, es decir que los elementos de una estructura de datos pueden a su vez ser estructuras de datos. Entonces el tipo de dato base de una estructura, que es el tipo de dato de sus elementos puede ser: (a) Simple: los elementos no son a su vez estructuras de datos. (b) Compuestos: los elementos son a su vez estructuras de datos. A su vez, el tipo de dato base de una estructura, que es el tipo de dato de sus elementos, tambin puede ser: (1) Homogneo: los elementos son todos del mismo tipo. Es decir que los valores, que se almacenan en los elementos de la estructura, pertenecen a un nico tipo de dato. (2) Heterogneo: los elementos pueden no ser todos del mismo tipo. Es decir que los valores, que se almacenan en los elementos de la estructura, pueden pertenecer a diversos tipos de dato.
U.N.S.L. Argentina
64
Arreglos y Registros
CAPTULO 7 ESTRUCTURAS DE DATOS: ARREGLOS Y REGISTROS

7.1 Arreglos
En un arreglo, array en ingls, sus elementos permiten almacenar valores que son todos del mismo tipo, que es llamado tipo base del arreglo. Que sean del mismo tipo no quiere decir que tengan el mismo valor. En efecto, an cuando los elementos puedan guardar valores del mismo tipo no necesariamente tendrn el mismo valor: depender de lo que se quiera almacenar. Una de las principales caractersticas de esta estructura es que sus elementos se encuentran contiguos, es decir uno al lado del otro, y se accede a ellos a travs de lo que se llama un ndice. Por estar contiguos se los puede contar a partir de uno que puede sealarse como el primero. El ndice sirve, entonces, para sealar, seleccionar, o indicar (o indexar) a los distintos elementos, y es el selector de los elementos del arreglo. El arreglo tiene un selector explcito. Es posible, tambin, debido a la disposicin de los elementos, acceder, inspeccionar uno cualquiera de ellos empleando el ndice, sin necesidad de acceder a otros antes. Siempre se sabe donde se encuentra un elemento con relacin a los otros, por lo que el ndice que lo identifica es siempre el mismo y se puede calcular. El tipo del ndice debe tener la particularidad de que sus valores sean correlativos (secuenciales), es decir una relacin bi-unvoca con un sub-conjunto de los naturales.
Orden cronolgico
Por las caractersticas de esta estructura, no puede reconocerse un orden cronolgico de llegada, salida, recorrida o inspeccin. Sin embargo, dada las caractersticas de un arreglo y del tipo del ndice, siempre puede reconocerse un elemento que es el primero: aquel cuyo valor de ndice es el menor; y uno que es el ltimo: aquel cuyo valor de ndice es el mayor. En consecuencia si accedemos al arreglo siguiendo la secuencia de valores del ndice podremos hablar de un acceso, de una inspeccin cronolgica del primero al ltimo.
Capacidad
La capacidad de un arreglo es esttica, no crece y disminuye con las inserciones y supresiones. Es decir que, en general, no es posible agregar elementos sino almacenar nuevos valores en los elementos ya existentes. En consecuencia hablaremos de asignaciones de valores a los elementos.
Operaciones
Las operaciones que pueden realizarse son las de ASIG AR un nuevo valor en un lugar sealado por el ndice y la de I SPECCIO AR una posicin del arreglo en un lugar sealado por el ndice.
ndice valores de los elementos primero
Representacin grfica
Figura 7.1 Veamos, por ejemplo, un arreglo, que se muestra en la Figura
U.N.S.L. Argentina
ltimo
65
Arreglos y Registros
7.1, cuyo tipo base es el carcter (los valores almacenados en el mismo sern los que formen parte del conjunto de valores asociados al tipo carcter), es decir un arreglo de caracteres, cuyo ndice son enteros entre 2 y 5.
7.2 Registros
En un registro almacenamos elementos, que no son, necesariamente, todos del mismo tipo, aunque podran serlo, y obviamente, pueden no tener necesariamente el mismo valor. Debido a este almacenamiento de datos, cuyos tipos pueden ser distintos uno de otros, cada uno de los elementos de esta estructura, que se conocen con el nombre genrico de campos, es identificado con un nombre, que es el selector, que sirve justamente para seleccionar el campo (elemento) de la estructura que se desea. El registro tiene, entonces, un selector explcito. Es posible, acceder, inspeccionar uno cualquiera de los elementos empleando su nombre (selector), sin necesidad de acceder a otros antes.
Orden cronolgico
Por las caractersticas de esta estructura, no puede reconocerse un orden cronolgico de llegada, salida, recorrida o inspeccin.
Capacidad
La capacidad de un registro es esttica, es decir que no crece con las inserciones ni disminuye con las supresiones. No es posible agregar elementos sino almacenar nuevos valores en los elementos ya existentes. En consecuencia hablaremos de asignaciones de valores a los elementos (campos).
Operaciones
Las operaciones que pueden realizarse son las de asignar un nuevo valor en un lugar sealado por el nombre de campo (selector) y la de inspeccionar una posicin del arreglo en un lugar sealado por el nombre de campo (selector).
Un registro compuesto de tres campos de tipos distintos: entero, carcter y real. Al campo para valores enteros lo llamamos ent; al campo para valores caracteres lo llamamos car y al campo para valores reales lo llamamos reales.
campos nombres valores ent 127 car W reales 2,54 Figura 7.2
U.N.S.L. Argentina
66
Pilas y Filas
CAPTULO 8 ESTRUCTURAS DE DATOS: PILAS Y FILAS

8.1 Pilas
En una pila almacenamos elementos, que son todos del mismo tipo, aun cuando, obviamente, puedan no tener necesariamente el mismo valor. La pila es una estructura que es fcilmente identificable ya que comparte muchas de las caractersticas de las pilas que se encuentran en la vida de todos los das: una pila de libros, una pila de platos, etc.
Orden cronolgico
El orden de llegada, insercin, de los elementos, es inverso al de salida, supresin, de los mismos. Es decir que el primer elemento insertado ser el ltimo en ser suprimido. Esto es as si se piensa en una pila de platos, el primero que se apil es el que est abajo de todo en la pila, en la base de la pila y es el que solo se podr sacar despus de sacar, antes, todos los que estn sobre l, es decir el que saldr ltimo de la pila. Por el contrario el ltimo que se apil, es el que est en el tope de la pila y el primero que se podr sacar de la misma. Este orden de los elementos de una pila puede expresarse a travs de las siglas de las operaciones y su orden, de la siguiente manera: Ultimo Entrado Primero Afuera (UEPA) o en Ingls: Last In First Out (LIFO)
Capacidad
La capacidad de las pilas es dinmica, es decir que las pilas crecen con las inserciones y disminuyen con las supresiones.
Operaciones
Se pueden realizar las operaciones de: Insercin en el TOPE, solamente, de la pila, es decir sobre el ltimo elemento ingresado. En Ingls esta operacin es conocida con el nombre de PUSH. Supresin del TOPE, solamente, de la pila, es decir del ltimo elemento ingresado. En Ingls esta operacin es conocida con el nombre de POP. Inspeccin del TOPE, solamente, de la pila, es decir del ltimo elemento ingresado. Es importante remarcar el hecho que en la pila solo puede operarse sobre el elemento que se encuentra en el tope de la misma, es decir aqul que ingres ltimo y que es el
U.N.S.L. Argentina
Ejemplo de una pila de carctercaracterescaracteres

tope
Z Y T R
base
F Figura 8.1
67
Pilas y Filas
primero que se encuentra disponible para salir. La pila tiene, entonces, un selector implcito, ya que es el elemento que se encuentra en el tope sobre el que se puede operar. No hay necesidad de ninguna referencia al elemento, ya que las operaciones se hacen sobre una posicin de la pila: el tope.
Por supuesto la representacin grfica puede hacerse como se desee, verticalmente en el papel, con el TOPE arriba o abajo; horizontalmente en el papel, con el TOPE a la derecha o a la izquierda; o inclusive oblicuamente. En el caso de la Figura 8.1, la pila est representada verticalmente, con el TOPE arriba.
8.2 Filas o colas

En una fila o cola almacenamos elementos, que son todos del mismo tipo, aun cuando, obviamente, puedan no tener necesariamente el mismo valor. La fila es una estructura que es fcilmente identificable ya que comparte muchas de las caractersticas de las filas o colas que se encuentran en la vida de todos los das: por ejemplo una cola de personas esperando el colectivo, etc.
Orden Cronolgico
El de llegada (insercin) es igual al de salida (supresin). Es decir que el primer elemento insertado ser, tambin, el primero en ser suprimido. Esto es as, si pensamos en una cola de personas esperando, para ser atendidas, frente a una ventanilla de un cajero en un banco (siempre y cuando las personas sean respetuosas del orden y no salten lugares en la cola!). La primera persona en llegar (insercin) ser la que est primera en la cola y ser la primera en ser atendida (supresin). De ah que en las filas o colas sea posible hablar de un primer y un ltimo elemento ya que tanto las inserciones como las supresiones coinciden en determinar cul es el primero y cul el ltimo. Este orden de los elementos de una fila puede expresarse a travs de las siglas de las operaciones y su orden, de la siguiente manera: Primero Entrado Primero Afuera (PEPA) o en Ingls: First In First Out (FIFO)
Capacidad
La capacidad de las colas es dinmica, es decir que las filas crecen, con las inserciones y disminuyen con las supresiones.
Operaciones
Se pueden realizar las operaciones de: Insercin, despus del ltimo elemento ingresado. Supresin, del primer elemento ingresado. Inspeccin, del primer elemento ingresado. Es importante remarcar el hecho que en las filas slo puede suprimirse e inspeccionarse el primer elemento ingresado y solo se inserta un nuevo elemento despus del ltimo elemento ingresado. La fila tiene dos selectores implcitos, ya que es el elemento que se encuentra en el primer lugar de la misma
U.N.S.L. Argentina
68
Pilas y Filas
sobre el que se puede operar para eliminarlo o inspeccionarlo y se inserta despus del elemento que se encuentra en el ltimo lugar. No hay necesidad de ninguna referencia a un elemento, ya que las operaciones se hacen sobre alguna posicin de la fila: o el primero o despus del ltimo.
La fila, de la Figura 8.2, est representada grficamente de derecha a izquierda, en este caso el orden de llegada (insercin) de los elementos fue: F, R, T, Y, Z; es decir Ejemplo de una fila de F fue el primero en llegar carctercaracterescaracteres (insertado) y Z el ltimo en llegar (insertado). Consecuentemente F ser el primero en salir (suprimido) y Z ser el ltimo en salir (suprimido).
Por supuesto la representacin grfica puede hacerse como se Figura 8.2 desee, verticalmente en el papel, con el PRIMERO arriba o abajo; horizontalmente en el papel, con el PRIMERO a la derecha o a la izquierda; o inclusive oblicuamente.
ltimo
primero
U.N.S.L. Argentina
69
Listas
CAPTULO 9 ESTRUCTURAS DE DATOS: LISTAS U I Y BIDIRECCIO ALES

9.1 Listas uni-direccionales
Composicin de los elementos
Los elementos de una lista uni-direccional constan de dos partes: Variable de Informacin Propiamente Dicha, (VIPD) que es donde se almacena la informacin que corresponde a cada elemento, que son todas del mismo tipo, aun cuando, obviamente, puedan no tener necesariamente el mismo valor. Puntero al elemento siguiente. El puntero puede no apuntar a un elemento cuando no lo haya (caso del ltimo elemento). Cuando un puntero no apunta a un elemento se dice que su valor es nil.
Orden cronolgico
No hay un orden cronolgico ni para la entrada (insercin) de elementos ni para la salida (supresin) de los elementos. S lo hay para la inspeccin de los mismos, ste va del primer elemento al ltimo. Este orden est dado por los punteros de cada elemento que apuntan, cada uno, al elemento que le sigue, para ello se cuenta con un acceso inicial que apunta a un elemento de la lista, el cual puede reconocerse como el primero.
Capacidad
La capacidad de la listas uni-direccionales es dinmica, es decir que crece con las inserciones y disminuye con las supresiones.
Operaciones
Se pueden realizar las operaciones de: Insercin, en cualquier lugar de la estructura. Supresin, de cualquier elemento que se encuentre en la estructura. Inspeccin, de cualquier elemento que se encuentre en la estructura. En todos los casos, sin embargo, el acceso es secuencial, es decir del primero al ltimo. Quiere decir que, por ejemplo, para acceder (inspeccionar) el quinto elemento, a partir del primero, debe pasarse por los cuatro elementos anteriores. Esto suponiendo que la lista tiene al menos cinco elementos. Las listas, uni-direccionales, tienen asociado un cursor que permite marcar, sealar, un elemento. Este elemento, as marcado ser el elemento corriente, aquel que puede inspeccionarse, suprimirse, o donde, entre el anterior y el corriente, podr insertarse uno nuevo. Un cursor es bsicamente un puntero externo a la lista que toma un valor puntero (inclusive nil) lo que le permite apuntar a un elemento de la lista. Podemos decir que el cursor de una lista es el selector implcito de la misma.
U.N.S.L. Argentina
70
Listas
La lista de la figura est representada grficamente de izquierda a derecha. primero y ltimo hacen referencia al acceso o inspeccin de los elementos de la lista, considerado desde el acceso inicial. Por supuesto la representacin grfica puede hacerse como se desee, verticalmente en el papel, con el PRIMERO arriba o abajo; horizontalmente en el papel, con el PRIMERO a la derecha o a la izquierda; o inclusive
Ejemplo de una lista uni-direccional de carctercaracterescaracteres con su Cursor VIPDs de cada elemento
primero
cursor
ltimo
E
nil
Acceso a la estructura
punteros al prximo elemento
Figura 9.1
oblicuamente.
9.2 Listas bi-direccionales

Composicin de los elementos
Los elementos de una lista bi-direccional constan de tres partes: Variable de Informacin Propiamente Dicha, (VIPD) que es donde se almacena la informacin que corresponde a cada elemento, que son todas del mismo tipo, aun cuando, obviamente, puedan no tener necesariamente el mismo valor. Puntero al elemento siguiente, este puede 'apuntar' a ningn elemento cuando no hay un elemento al que apuntar (caso del ltimo elemento). Este puntero se conoce como puntero adelante o en Ingls forward pointer. Puntero al elemento anterior, este puede 'apuntar' a ningn elemento cuando no hay un elemento al que apuntar (caso del primer elemento). Este puntero se conoce como puntero atrs o en Ingls backward pointer. Recuerde que, como ya dijimos para las listas uni-direccionales, cuando un puntero no apunta a un elemento se dice que su valor es nil.
U.N.S.L. Argentina
71
Listas
Orden cronolgico
No hay un orden cronolgico ni para la entrada (insercin) de elementos ni para la salida (supresin) de los elementos. Si la hay para la inspeccin de los mismos, esta va del primer elemento al ltimo o del ltimo al primero. Este orden est dado por los punteros de cada elemento que apuntan cada uno al elemento que le sigue y al anterior. Igual que en el caso de las listas uni-direccionales se cuenta con un acceso inicial que apunta a un elemento de la lista. Es por ello que se puede reconocer un elemento como el primero: es aquel que es apuntado por el acceso a la lista.
Capacidad
La capacidad de las listas bi-direccionales es dinmica, crece y disminuye con las inserciones y supresiones, respectivamente.
Operaciones
Se pueden realizar las operaciones de: Insercin, en cualquier lugar de la estructura. Supresin, de cualquier elemento que se encuentre en la estructura. Inspeccin, de cualquier elemento que se encuentre en la estructura, o de todos. En todos los casos, sin embargo, el acceso es secuencial, es decir del primero al ltimo y del ltimo al primero. Quiere decir que, por ejemplo, para acceder (inspeccionar) al octavo elemento, a partir del primero, debe pasarse por los siete elementos anteriores. Para ir al cuarto elemento, a partir del ltimo, debe pasarse por todos los elementos de la lista que estn entre el ltimo y el cuarto elemento (esto, suponiendo que la lista tiene ocho elementos, significa que habr que pasar por los elementos ocho, siete, seis y cinco). Las listas, bi-direccionales, tienen asociado un cursor que permite marcar, sealar, un elemento. Este elemento, as marcado ser el elemento corriente, aquel que puede inspeccionarse, suprimirse, o donde, entre el anterior y el corriente, podr insertarse uno nuevo. Un cursor es bsicamente un puntero externo a la lista que toma un valor puntero (inclusive nil) lo que le permite apuntar a un elemento de la lista. Podemos decir que el cursor de una lista es el selector implcito de la misma.
La lista, de la figura, est representada grficamente de izquierda a derecha. Primero y ltimo hacen referencia al acceso o inspeccin de los elementos de la lista, considerado desde el acceso inicial.
U.N.S.L. Argentina
72
Listas
Por supuesto la representacin grfica puede hacerse como se desee, verticalmente en el papel, con el PRIMERO
Acceso a la estructura
Ejemplo de una lista bi-direccional de carctercaracterescaracteres

punteros al elemento anterior
cursor
nil ltimo nil
Z
primero
VIPDs de cada elemento
punteros al prximo elemento
Figura 9.2
arriba o abajo; horizontalmente en el papel, con el PRIMERO a la derecha o a la izquierda; o inclusive oblicuamente.
9.3 Generalidad de las listas

Las listas, uni y bi-direccionales, son estructuras de datos, que por las escasas restricciones impuestas a las mismas, frente a las otras estructuras, permiten emplearlas fcilmente para representar con ellas cualquier otra estructura. Por ejemplo diremos que una pila no es ms que una lista con restricciones en las operaciones de insercin, supresin e inspeccin que en lugar de hacerse con cualquier elemento solo se hacen con el primero. Esto no quiere decir que no puedan representarse unas estructuras con otras (por ejemplo filas empleando pilas) sino que las listas permiten realizar esto ms fcilmente.
U.N.S.L. Argentina
73
Listas
Tabla 9.1. Caractersticas de las Estructuras de Datos
Caractersticas Capacidad Tipo Base Selector
Arreglo
Esttica
Estructura Registro Pila

Esttica Dinmica
Fila
Dinmica
Lista
Dinmica
Homogneo Heterogneo Homogneo Homogneo Homogneo Explcito. Explcito. Nombre de ndice Campo Implcito (tope) Implcito Implcito. (primero y Cursor ltimo) Si FIFO Si, FIFO Si, FIFO Copia Insercin Supresin Si Del 1 al ltimo. No No Copia Insercin Supresin
Orden Cronolgico
No. A Inspeccin menos que se siga el orden del Entrada selector (ndice).
No No No
Si LIFO Si, LIFO Si, LIFO
Salida
Operaciones
P.ej.: P.ej.: asignacin, asignacin, Copia Inspeccin parmetro parmetro real real Entrada Asignacin Asignacin Insercin Supresin Salida
U.N.S.L. Argentina
74
Multinivel
CAPTULO 10 ESTRUCTURAS DE DATOS: ESTRUCTURAS MULTI IVEL

Las estructuras multinivel son estructuras de datos que tienen ms de un nivel, es decir que cada elemento de la misma tendr, a su vez, una estructura de datos asociada al elemento. En este caso hablaremos de niveles o de dimensiones. Las estructuras, tal como haban sido vistas hasta ahora, tenan un solo nivel. Aceptaremos que para cada elemento de la estructura puede haber, a su vez otra estructura, que sera en ese caso el segundo nivel. Este segundo nivel puede, tambin, tener asociado a l, en cada uno de sus elementos, una estructura de datos y as sucesivamente, potencialmente de una manera infinita. Este anidamiento de estructuras puede ser tan grande como lo permita el lenguaje. Potencialmente o idealmente podra ser infinito, pero ya sabemos que en la realidad esto no es as. Diremos que el primer nivel (o dimensin) es aquel que se encuentra ms afuera, es decir aquel que, partiendo de la definicin, el que tiene en cada uno de sus elementos a su vez una estructura. Este sera el segundo. El tercero (si existe) sera aquel que constituye cada uno de los elementos del segundo y as sucesivamente. El ltimo nivel (o dimensin) ser siempre un tipo de dato simple y no una estructura. Sin embargo ste ltimo nivel no lo contamos como tal. Slo contamos los niveles que son estructuras y no los que son simples. As, por ejemplo, un arreglo de caracteres tiene un nivel, los elementos de tipo simple no se consideran como un nivel.

Cada una de las estructuras de cada nivel podr ser cualquiera de las estructuras dinmicas ya vistas: pila, fila, listas uni y bi-direccionales; o de las estticas ya vistas: arreglos y registros. Las estructuras de datos de multinivel pueden ser homogneas o heterogneas. Diremos que una Estructura de Datos Multinivel es homognea cuando todos los niveles (o dimensiones) de la misma, que son a su vez Estructuras de Datos, estn constituidos por la misma Estructura de Datos. Por supuesto esta definicin no incluye el ltimo nivel, el cual ya dijimos que no es una estructura. Por otro lado una Estructura de Datos Multinivel es heterognea cuando no todos los niveles (o dimensiones) de la misma, que son a su vez Estructuras de Datos, estn constituidos por la misma Estructura de Datos. Por supuesto esta definicin no incluye el ltimo nivel, el cual ya dijimos que no es una estructura. As un arreglo que tiene como tipo base un arreglo de enteros (dos niveles ya que no contamos el tipo base del ltimo arreglo que es un tipo simple: entero) es una estructura multinivel homognea. Mientras que un arreglo que tiene como tipo base un registro (tambin dos niveles ya que no contamos el tipo base de la ltima estructura cada uno de los campos del registro que suponemos que son todos tipos simples) es una estructura multinivel heterognea.
Figura 10.1. Un arreglo de arreglos. En la primera dimensin o nivel tiene siete elementos, cada uno de los cuales es, a su vez, un arreglo de cuatro elementos. Es decir que es un arreglo con siete arreglos de cuatro elementos cada uno.
Sobre esto ltimo puede haber otros criterios tal como considerar que una variable de tipo simple tiene un slo nivel mientras que una estructura de datos cuyos elementos son de tipo simple agrega un nivel o dimensin. En nuestro caso consideramos que el tipo simple no cuenta como nivel: un arreglo cuyo tipo base es real tiene un nivel o dimensin.
U.N.S.L. Argentina
75
Multinivel
type type arreglo_2_niv_heterogeneo = arreglo_2_niv_homogeneo = array[1..10] of record array[1..10] of a: integer; array[1..10] of integer; b: char end; Ejemplo .10.1 Ejemplo 10.2
10.1 Particularidades de las estructuras de multinivel

En algunos casos ciertas estructuras de multinivel tienen nombres especiales debido a su mayor uso. As, cuando se tienen arreglos de multinivel homogneos estos se conocen como arreglos multidimensionales. Por otro lado cuando la estructura de datos no es homognea en su tipo base, como es el caso del registro, puede darse que la misma tenga algunos de sus elementos que sean a su vez estructuras de datos mientras que otros sean tipos simples. En este caso cuando hablamos de nivel nos referiremos al mayor nivel que pueda encontrarse en la estructura.
10.2 Estructuras estticas y dinmicas

Por sus caractersticas particulares existen diferencias en la manipulacin de las estructuras multinivel entre las estticas y las dinmicas. Dado que las estructuras estticas no crecen ni disminuye su tamao cuando se pone o saca un elemento en las mismas, pero lo opuesto si ocurre con las estructuras dinmicas, las operaciones tienen, como ya se ha visto, caractersticas distintas que se reflejan en la manipulacin de las estructuras de multinivel.
10.3 Operaciones
Las operaciones sobre estructuras multinivel conservan las restricciones que corresponden a cada una de las estructuras. Esto da como consecuencia que para cada nivel, el acceso al mismo, para efectuar operaciones en ese nivel, tiene las restricciones que corresponden al nivel anterior. Por ejemplo una pila de listas uni-direccionales (es decir que la pila est en el primer nivel y cada uno de sus elementos contiene una lista uni direccional, que, en consecuencia, decimos que estas listas estn en el segundo nivel) permitir acceder solo a la lista del segundo nivel, que corresponde al elemento que se encuentra en el tope de la pila del primer nivel. Para efectuar operaciones en las listas, del segundo nivel, de los otros elementos de la pila, ser necesario suprimir el tope de la pila del primer nivel cuantas veces sea necesario para llegar al elemento, de la pila del primer nivel, que contiene la lista de segundo nivel a la que se desea acceder, para as poder operar sobre la lista de segundo nivel. As en un arreglo de arreglos, un arreglo multidimensional, en este caso de dos dimensiones, para acceder a un elemento del segundo nivel ser necesario emplear un ndice para el primer nivel y otro ndice para acceder, por fin, al elemento en el segundo nivel.
U.N.S.L. Argentina
76
Implementacin de Estructuras
CAPTULO 11 IMPLEME TACI DE ESTRUCTURAS

11.1 Introduccin
En general hablaremos indistintamente de simular o implementar estructuras de datos dinmicas (pilas, filas, listas). Las estructuras de datos han sido vistas hasta ahora como una caja negra, es decir que sabamos que podan hacerse operaciones sobre ellas pero se ignoraba cul era el mecanismo que haca posible dichas manipulaciones. Puede decirse que las estructuras se definen por las manipulaciones que pueden hacerse sobre ellas. Sabemos, por ejemplo, que una pila es tal, porque las inserciones y supresiones se hacen por el tope. La simulacin o implementacin de una estructura de datos se supone que se har sobre una mquina, computadora, determinada, y lgicamente empleando un programa. Para hacer ste programa ser necesario un lenguaje y ste lenguaje tendr primitivos: estructuras de datos estndar que son las que se debern emplear para realizar la tarea de simulacin o implementacin. Obviamente si el lenguaje nos provee como primitivo la estructura que se quiere simular no habr problemas. En efecto, por ejemplo, si lo que se desea es simular un arreglo y el lenguaje elegido es el Pascal, la cosa ser fcil. De no ser as entonces habr que elegir la estructura que provea el lenguaje y que mejor se adapte a la implementacin que se desee hacer. La mayor parte de los lenguajes de programacin tienen como una estructura primitiva el arreglo, lo que permitir que el mismo sea elegido como estructura soporte, es decir como estructura que permita poner, soportar, la estructura que se intenta simular. Esta estructura es la que nos permitir almacenar los valores correspondientes a los elementos de la estructura soportada. Tenemos, entonces, dos estructuras: por un lado la estructura que queremos implementar, que es la estructura soportada y por otro lado la estructura que nos sirve para soportar la implementacin, que es la estructura soporte. Como en la mayor parte de los casos, al hacer un programa que simule una estructura no slo se deber elegir la estructura de datos que ms convenga sino que se tendr que considerar: el tiempo: de realizacin del programa. que toma el programa para ejecutarse.
el espacio: de almacenamiento de los datos. de almacenamiento del programa.
La eficiencia total del programa que simule una estructura ser un compromiso entre el tiempo y el espacio, y por supuesto de los primitivos disponibles en el lenguaje. Hay estructuras de datos que se prestan ms fcilmente para simular otras, por ejemplo la lista o el arreglo. Cuando se emplea un arreglo como estructura soporte, una accin que deber realizarse, algunas veces, sobre este es el desplazamiento. Esta es la accin de mover todos los elementos de la estructura simulada en el arreglo, un lugar, hacia un lado u otro del arreglo, es decir desde el primer elemento del arreglo hacia el ltimo o viceversa. Por supuesto que, dependiendo del sentido del desplazamiento, ya sea el primero o el ltimo elemento puede perderse. Para ilustrar los ejemplos emplearemos el lenguaje Pascal. Los nombres de variables y tipos, as como la forma de declarar los mismos son UNA de las MUCHAS formas de encarar la solucin de los problemas planteados.
U.N.S.L. Argentina
77
11.2 Administracin de los espacios libres

Desde el momento que se hace el mecanismo para que una estructura funcione, empleando otra, se presenta el problema de como emplear los espacios que tenemos disponibles en la estructura soporte para almacenar los datos que ingresarn en la estructura simulada. Sobre la estructura soporte habr espacios ocupados por los datos y habr otros espacios que estarn libres, listos para ser usados para almacenar datos correspondientes a la estructura simulada. El hecho de tener espacios libres listos para ser usados nos obliga a tener estos (que podrn ser ms de uno) organizados de alguna manera, es decir tener para los lugares libres, a su vez, una estructura de datos.
Desborde y desfonde
El DESBORDE se presenta cuando, queriendo insertar un nuevo elemento en la estructura simulada, la estructura soporte est llena y en consecuencia no puede insertarse ningn otro elemento en la estructura simulada, esto se llama overflow en ingls. El DESFONDE se presenta cuando, queriendo suprimir un elemento de la estructura simulada, la estructura simulada est vaca y en consecuencia no se puede suprimir en ella, esto se llama underflow en ingls. La condicin de lo que llamamos desfonde es propia de las estructuras dinmicas y corresponde al concepto de estructura vaca. Es decir cuando no se puede suprimir en la estructura porque sta no tiene ningn elemento. Por el contrario el concepto de desborde es propio de la implementacin de estructuras. La estructura que sirve de soporte para la estructura que se simula o soporta tiene una capacidad finita de almacenamiento. An cuando tericamente la capacidad de almacenamiento de las estructuras sea infinita esto no sucede as en la prctica. Esta limitacin de la capacidad nos obliga a controlar, en la implementacin de estructuras, el desborde. El control del desborde y el desfonde puede hacerse de varias maneras: * Empleando una variable que mantenga la cantidad de elementos que hay presentes en la estructura en todo momento. Esta variable se incrementa cada vez que se inserta y se decrementa cada vez que se suprime. La variable ser igual a la capacidad mxima, conocida, de la estructura soporte cuando haya desborde (no puede insertarse); y ser igual a cero si hay desfonde (no puede suprimirse). * Utilizando algunas de las caractersticas propias de la implementacin (punteros, marcas, etc.). Esto se indicar ms adelante en cada caso particular.
Mtodos de administracin de los espacios libres

Reconocemos dos grandes mtodos de administracin de los espacios libres en la estructura soporte: esttico y dinmico.
Administracin esttica
Cuando los espacios libres en la estructura soporte se administran estticamente esto quiere decir que, cada vez que se necesita un lugar para almacenar algo (insercin en la estructura simulada), se usa un lugar libre. Cada vez que se libera un lugar ocupado en la estructura simulada (supresin en la estructura simulada) este NO es incorporado a la estructura de los espacios libres y en consecuencia NO podr ser reusado cuando se necesite, nuevamente, un lugar para almacenar algo en la estructura simulada. Podemos comparar esto con un galpn donde se almacenan mercaderas y donde entran y salen bultos. Si inicialmente el galpn est vaco, cada vez que se desea guardar algo se ocupa un lugar. Si esto se hace con algn criterio, por ejemplo se empieza desde atrs hacia adelante y desde la derecha hacia la izquierda, el espacio se ir ocupando ordenadamente. Sin embargo cuando sale un bulto el lugar ocupado por este no es reutilizado y se sigue usando los lugares que no fueron nunca ocupados. En este mtodo la estructura que tengan los espacios libres debe permitir supresiones solamente. Supresiones cuando se le saca un espacio libre para que sea empleado para una insercin en la estructura simulada.
U.N.S.L. Argentina
78
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase Este mtodo puede tener dos variantes:
(a) Los espacios liberados, luego de ser ocupados, nunca ms son reutilizados, y en consecuencia cuando se terminaron los espacios libres iniciales la estructura simulada estar llena an cuando haya lugares libres que se liberaron luego de estar ocupados. (b) Cuando no quedan ms espacios libres puede realizarse un proceso de reordenar toda la estructura soporte recolectando los espacios que pudieron haber quedado libres para que vuelvan a ser utilizados. Esto se llama en ingls garbage collection, recoleccin de basura en espaol.
Administracin dinmica
Cuando los espacios libres en la estructura soporte se administran dinmicamente esto quiere decir que cada vez que se necesita un lugar para almacenar algo (insercin en la estructura simulada) se usa un lugar libre. Cada vez que se libera un lugar ocupado en la estructura simulada (supresin en la estructura simulada) este es incorporado a la estructura de los espacios libres y en consecuencia podr ser reusado cuando se necesite un lugar para almacenar algo en la estructura simulada. Volviendo al ejemplo del galpn donde se almacenan mercaderas y donde entran y salen bultos. Si inicialmente el galpn est vaco, cada vez que se desea guardar algo se ocupa un lugar. Si esto se hace con algn criterio, por ejemplo se empieza desde atrs hacia adelante y desde la derecha hacia la izquierda, el espacio se ir ocupando ordenadamente. Ahora cuando sale un bulto el lugar ocupado por ste es reutilizado, es decir que se lo puede volver a ocupar si es necesario. En este mtodo la estructura que tengan los espacios libres debe permitir inserciones y supresiones. Supresiones cuando se le saca un espacio libre para que sea empleado para una insercin en la estructura simulada. Inserciones cuando se incorpora un espacio libre que ha quedado libre por una supresin en la estructura simulada.
11.3 Implementacin de pilas

Una forma posible de simular pilas es empleando un arreglo (array) cuyo tipo base sea igual al de los elementos de la pila que va a simularse. Distinguimos dos mtodos: con desplazamiento y sin desplazamiento.
Con desplazamiento
En este caso se fija el tope de la pila en la posicin uno del arreglo y se hace un desplazamiento de los elementos de la pila, que estn en el arreglo, cada vez que se hace una insercin (push) o una supresin (pop). Ser necesario tener una forma de indicar donde est, en el arreglo, la base, es decir el fin, de la pila. Esto, a su vez, puede hacerse de dos maneras:
Con variable para la base

Con una variable que sirva de puntero para saber donde est, en el arreglo, la base, es decir el fin, de la pila. Esta variable se debe incrementar o decrementar cada vez que se hace una insercin o una supresin. const n = 100; Esta variable puede servir para controlar el type pila = record desfonde cuando es menor que 1, suponiendo sop : array [1..n] of char; base : 0..n que 1 es el mnimo valor del ndice del arreglo y end para el desborde cuando es mayor que n, suponiendo que n es el mximo valor del ndice del arreglo. Ejemplo 11.1. Con variable para la base. Los espacios libres se administran automticamente en forma dinmica. En efecto puede decirse que estn organizados como una pila cuyo tope toca la base de la pila simulada y sobre la que se hace una supresin, automticamente, cada vez que se inserta en la pila
U.N.S.L. Argentina
79
simulada y viceversa. La variable que indica dnde est la base de la pila simulada, indica al mismo tiempo el tope de la pila de los espacios libres.
lugares libres Estado del arreglo soporte: antes de insertar 1 S 2 G 3 Z 4 ? ... n ? despus de insertar U (push) 1 U 2 S 3 G 4 Z 5 ? ... n ?
Tope
base = 3
Nuevo Tope base := base + 1 base = 4
Sentido del desplazamiento de los elementos, para poder insertar
Figura 11.1
Insercin en una pila de carctercaracterescaracteres implementada con el mtodo de desplazamiento, con variable para la base y el tope fijo en la primera posicin del arreglo soporte.
Con una marca

En este caso emplearemos una marca que sirva para saber donde est, en el arreglo, la base, es decir el fin, de la pila. Esta marca deber ser un valor de los del tipo de los elementos de la pila que solo podr const n = 100; ser utilizado para esto y no como un valor de la marca = * ; pila simulada, lo que obliga a reducir el type pila = record conjunto de los valores posibles de los sop : array [1..n] of char; elementos en uno. Esta marca ocupa un lugar end en el arreglo, lo que tambin reduce en uno la cantidad de espacio destinado a los elementos en la estructura soporte. La marca puede servir Ejemplo 11.2. Con una marca. para el control del desfonde (est en la posicin del tope, primera posicin del arreglo); o para el desborde (est en la posicin n del arreglo). La marca deber desplazarse, junto con el resto de los elementos de la pila, cada vez que se haga una supresin o una insercin. Los espacios libres se administran automticamente en forma dinmica. En efecto puede decirse que estn organizados como una pila cuyo tope toca la base de la pila simulada y sobre la que se hace una supresin, automticamente, cada vez que se inserta en la pila simulada y viceversa.
U.N.S.L. Argentina
80
Algo similar ocurre si se fija el tope de la pila en la ltima posicin del arreglo, en lugar de la primera como se haba considerado hasta aqu. En este caso los desplazamientos tendrn un sentido inverso para las inserciones y las supresiones que el sentido que dichas operaciones tienen cuando el tope de la pila implementada se fija en el
lugares libres Estado del arreglo soporte: antes de suprimir 1 S 2 G 3 Z 4 * ... n ? despus de suprimir S (pop) 1 G 2 Z 3 * 4 ? 5 ... n ?
Tope Marca
Nuevo Tope Marca Sentido del desplazamiento de los elementos y de la marca al suprimir Figura 11.2
Supresin en una pila de carctercaracterescaracteres implementada con el mtodo de desplazamiento, con marca para la base y el tope fijo en la primera posicin del arreglo soporte.
primer elemento del arreglo.
Sin desplazamiento
En este caso se fija la base, de la pila, en la const n = 80; posicin uno del arreglo y se tiene una type pila = record variable (puntero) que apunta al tope y que se sop : array [1..n] of char; modifica incrementndola cada vez que se tope : 0..n hace una insercin (push) o decrementndola end cada vez que se hace una supresin (pop). Esta variable puede servir para controlar el Ejemplo 11.3 desfonde: cuando es menor que 1, suponiendo que 1 es el mnimo valor del ndice del arreglo y para el desborde: cuando es mayor que n, suponiendo que n es el mximo valor del ndice del arreglo. Lo mismo sucede si se fija la base de la pila en la ltima posicin del arreglo, solo que la variable que apunta al tope se modifica incrementndola cada vez que se hace una supresin (pop) o decrementndola cada vez que se hace una insercin (push).
U.N.S.L. Argentina
81
Nosotros somos los lugares libres
Y nosotros tambin somos los lugares libres
antes de la insercin 1 S 2 G 3 Z 4 ? ... ...
Estado del arreglo soporte: despus de la insercin n ? 1 S 2 G 3 Z 4 U 5 ? ... ... n ?
Yo soy la base
Y yo el tope
Yo soy la misma base
Yo soy el nuevo tope
tope = 3 Figura 11.3
tope := tope + 1 tope = 4
Insercin en una pila de carctercaracterescaracteres implementada con una variable para el tope y la base fija en la primera posicin del arreglo soporte Los espacios libres se administran automticamente en forma dinmica. En efecto puede decirse que estn organizados como una pila cuyo tope toca el tope de la pila simulada y sobre la que se hace una supresin automticamente cada vez que se inserta en la pila simulada y viceversa. La variable que indica dnde est el tope de la pila simulada, indica al mismo tiempo el tope de la pila de los espacios libres.
11.4 Implementacin de filas o colas

Una forma posible de simular filas es empleando un arreglo (array) cuyo tipo base sea igual al de los elementos de la fila que va a simularse. Tambin para esta estructura distinguimos dos mtodos: con desplazamiento y sin desplazamiento.
Con desplazamiento
En este caso se fija el primero, de la fila, en la posicin uno del arreglo y se hace un desplazamiento de los elementos de la fila, que estn en el arreglo, cada vez que se hace una supresin. Para la insercin no ser necesario realizar un desplazamiento, simplemente se inserta despus del ltimo de la fila. Ser necesario tener una forma de indicar donde est, en el arreglo, el ltimo elemento de la fila. Esto puede hacerse de dos maneras: const mx = 120; type fila = record Con variable para el ltimo s : array [1..mx] of char; ultimo : 0..mx Con una variable que sirva de puntero end para saber donde est, en el arreglo, el ltimo, (es decir el fin de la fila) la que se debe incrementar cada vez que se hace una Ejemplo 11.4. Con variable para el ltimo. insercin y que deber actualizarse (decrementndola) cuando se haga el
U.N.S.L. Argentina
82
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase desplazamiento despus de una supresin.
lugares libres
Estado del arreglo soporte:
antes de insertar 1 S 2 G 3 Z 4 ? ... ... n ?
despus de insertar 1 S 2 G 3 Z 4 U 5 ? ... ... n ?
ultimo = 3
primero primero
ultimo := ultimo + 1 ultimo = 4
Figura 11.4. Insercin en una cola de carctercaracterescaracteres implementada con variable para el ltimo y el primero fijo en la primera posicin del arreglo soporte
Esta variable puede servir para el control del desfonde cuando sea menor que 1, suponiendo que 1 es el mnimo valor del ndice del arreglo y para el desborde cuando sea mayor que n, suponiendo que n es el mximo valor del ndice del arreglo.
lugares libres Estado del arreglo soporte:
antes de suprimir 1 S 2 G 3 Z 4 ? ... ... n ?
despus de suprimir 1 G 2 Z 3 ? 4 ? ... ... n ?
ultimo = 3
primero primero
ultimo := ultimo 1 ultimo = 2
Sentido del desplazamiento de los elementos para poder suprimir.
Figura 11.5. Supresin en una cola de carctercaracterescaracteres implementada con variable para el ltimo y el primero fijo en la primera posicin del arreglo soporte.
Con una marca

Con una marca que sirva para saber donde est, en el arreglo, el ltimo, (es decir el fin de la fila). Esta marca deber ser un valor de los del tipo de los elementos de la fila que solo podr ser utilizado para esto y no como VIPD, lo que obliga a reducir el conjunto de los valores posibles de los elementos en uno.
U.N.S.L. Argentina
83
lugares libres
Estado del arreglo soporte: antes de suprimir 1 S

primero
despus de suprimir 5 ? ... ? n 1 G

Nuevo primero
2 G
3 Z
4 *
marca
2 Z
3 *
4 *
... ...
n ?
Nueva marca (duplicada por el desplzamiento)
Sentido del desplazamiento de la marca y los elementos
Figura 11.6. Supresin en una cola de carctercaracterescaracteres implementada con marca despus del ltimo y el primero fijo en la primera posicin del arreglo soporte.
Esta marca ocupa un lugar el arreglo lo que reduce en uno la cantidad de espacio destinado a los elementos en la estructura soporte. La marca puede servir para el control del desfonde (est en la posicin del primero de la fila, posicin 1 del arreglo, en este caso); o para el desborde (est en la posicin n del arreglo). La marca deber desplazarse, junto con el resto de los elementos de la fila, cada vez que se haga una supresin. Para el caso de las inserciones deber desplazarse de un lugar para liberar el espacio necesario para la insercin. Algo similar ocurre si se fija el primero de la fila en la ltima posicin del arreglo. En este caso el desplazamiento de los elementos de la fila, que estn en el arreglo, cada vez que se hace una supresin tendr un sentido distinto. La variable que sirva de puntero para saber donde est, en el arreglo, el ltimo, (es decir el fin de la fila) se deber decrementar cada vez que se hace una insercin y deber actualizarse (incrementndola) cuando se haga el desplazamiento despus de una supresin.
marca = *; n = 100; type fila = array[1..n] of char;
const
Ejemplo 11.5. Con marca.
U.N.S.L. Argentina
84
lugares libres Estado del arreglo soporte: antes de insertar 1 S 2 G primero 3 Z 4 * 5 ? ... ... n ? despus de insertar U 1 S 2 G 3 Z 4 U 5 * marca ... ? n ?
marca
primero
Sentido del desplazamiento de la marca
Figura 11.7. Insercin en una cola de carctercaracterescaracteres implementada con marca despus del ltimo y el primero fijo en la primera posicin del arreglo soporte.
En lugar de fijar el primer elemento de la fila en alguno de los extremos del arreglo que sirve como soporte, como se explic en los prrafos anteriores, puede fijarse el ltimo en alguno de los extremos y tener un puntero o una marca para el primero. En este caso el desplazamiento solo se har cuando se haga una insercin. El manejo de los espacios libres es dinmico, y los mismos se encuentran todos juntos y contiguos despus del primero (si se fij el ltimo), o despus del ltimo (si se fij el primero). Puede decirse que los espacios libres se encuentran organizados como una pila en la que se inserta (push) cada vez que se suprime un elemento de la fila y se suprime (pop) cada vez que se inserta un elemento en la fila.
Sin desplazamiento
En este mtodo el arreglo se maneja en forma circular. Se emplean dos punteros, uno para el primero de la fila y otro para el ltimo de la fila. Cada vez que se inserta se incrementa el puntero que seala al ltimo y cada vez que se suprime se incrementa el puntero que seala al primero de la fila. En el Ejemplo 11.6 puede verse una definicin posible de un tipo para una estructura soporte para una fila de caracteres, donde el arreglo se administra en forma circular. const n = 8; type fila = record f : array [0..n1] of char; p : -1..n1; {puntero del primer elemento} u : -1..n1; {puntero del ultimo elemento} c: 0..n1 { cantidad de elementos } end Ejemplo 11.6 Como estas operaciones pueden hacer que alguno de los punteros o ambos, en algn momento, lleguen a ser mayores que el tamao mximo del arreglo, la operacin de suma debe hacerse de manera tal que llegado a ese caso se vuelva a tener el valor que apunte al primer elemento del arreglo. Esto equivale a decir que la operacin de
U.N.S.L. Argentina
85
incremento se hace mdulo el mximo del arreglo y puede hacerse con una sentencia if o con el operador mod (en Pascal). Por supuesto que, en todo caso, deber tenerse en cuenta las condiciones de desborde (overflow y underflow). Estas condiciones pueden controlarse de diversas maneras: con una variable que mantenga la cantidad de elementos presentes en la fila simulada o por medio de los punteros que apuntan al primero y al ltimo. en ste ltimo caso la condicin debe ser cuidadosamente estudiada y todos los casos posibles analizados. En lugar de incrementar los punteros puede decrementrselos, manteniendo los mismos recaudos que cuando se incrementa. El manejo de los espacios libres es dinmico, y los mismos se encuentran todos juntos y contiguos entre el primero y el ltimo. Puede decirse que los espacios libres se encuentran organizados, a su vez, como una fila en la que se inserta cada vez que se suprime un elemento de la fila simulada y se suprime cada vez que se inserta un elemento en la fila simulada. Estas dos filas (la simulada y la de los espacios libres) son como dos serpientes que se muerden la cola, si se imagina que las bocas de las serpientes son el ltimo de cada fila y las colas de las serpientes el primero de cada fila. Cuando la boca de una se come un pedazo de la cola de la otra hay una insercin y una supresin, respectivamente, en cada una de las filas. Puede tambin emplearse una variable que sirva para controlar la cantidad de elementos que hay en la fila en todo momento, lo que simplifica el control de desborde y desfonde. As veamos un ejemplo de sta implementacin. Supongamos una cola de caracteres como la que se encuentra dibujada en la Figura 11.8.(a), que tiene tres elementos: S, G, Z. Esta cola podra implementarse en una variable de tipo fila como el definido en el Ejemplo 11.6. Supongamos que el estado de sta variable, luego de realizarse varias inserciones y supresiones en la cola, es el que se muestra en la Figura 11.8 (b). Si se inserta un nuevo elemento en la cola sta quedar como se puede ver en la Figura 11.8 (c). La variable que soporta sta fila quedara, entonces, como se muestra, a la derecha. en la Figura 11.8 (d).
U.N.S.L. Argentina
86
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase (a)
Una fila (cola) de carctercaracterescaracteres S, G, Z. El primero es S el ltimo es Z.
Estado del arreglo: (b) antes de insertar {p = 5 u = 7 c = 3} despus de insertar T u:=(u+1)mod n; c:=c+1; {c=4 p=5 u=0} (d)
0 ?
1 ?
2 ?
3 ?
4 ?
5 S
6 G
7 Z
0 T
1 ?
2 ?
3 ?
4 ?
5 S
6 G
7 Z
ltimo primero
Nuevo ltimo
El mismo primero
lugares libres
(c)
La fila (cola) de carctercaracterescaracteres S, G, Z, T, despus de insertar T. El primero es S el ltimo es T.
Figura 11.8
Ejemplo de insercin en una cola de carctercaracterescaracteres, implementada manejando el arreglo en forma circular Si ahora insertamos H, la cola queda como se ve en la Figura 11.9 (a), y la estructura soporte como se muestra en la Figura 11.9 (b). Si luego se hace una supresin, la cola quedar como se la de la Figura 11.9 (c), y el arreglo soporte como el de la Figura 11.9 (d)
U.N.S.L. Argentina
87
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase (a)
La fila (cola) de carctercaracterescaracteres S, G, Z, T, H. El primero es S el ltimo es H.
Estado del arreglo: (b) despus de insertar H u:=(u+1)mod n; c:=c+1; {c = 5 p = 5 u = 1} despus de suprimir p:=(p+1)mod n; c:=c-1; {c=4 p=6 u= 1} (d)
0 T
1 H
2 ?
3 ?
4 ?
5 S
6 G
7 Z
0 T
1 H
2 ?
3 ?
4 ?
5 S
6 G
7 Z
Nuevo ltimo
El mismo primero
El mismo ltimo
Un nuevo primero
lugares libres
(c)
La fila (cola) de carctercaracterescaracteres G, Z, T, H, despus de suprimir. El primero es ahora G el ltimo es H.
Figura 11.9
Ejemplo de insercin y supresin en una cola de carctercaracterescaracteres, implementada manejando el arreglo en forma circular
11.5 Implementacin de listas

Las listas son estructuras muchos ms generales que las pilas o colas. Adems de las operaciones de insercin y supresin pueden tambin ser recorridas totalmente. Por otro lado dada su mayor generalidad y flexibilidad (inserciones y supresiones de cualquier elemento) pueden servir ms fcilmente para simular otras estructuras. Algunos autores sostienen, por ejemplo, que el arreglo es una lista contigua, es decir sin punteros, estos no seran necesarios ya que el siguiente elemento est al lado del anterior. Aqu tambin hablaremos de dos mtodos: con desplazamiento y sin desplazamiento.
Con desplazamiento
Empleando un arreglo (array) cuyo tipo base sea igual al de las VIPDs de la lista que va a simularse.
U.N.S.L. Argentina
88
En este caso se fija el primero, de la lista, en la posicin uno del arreglo y se hace un desplazamiento de los elementos de la lista, que estn en el arreglo, cada vez que se hace una supresin o una insercin. Ser necesario tener una forma de indicar donde est, en el arreglo, el ltimo elemento de la lista. Esto puede hacerse de dos maneras:
Con variable para el ltimo

Con una variable que sirva de puntero para saber donde est, en el arreglo, el ltimo (es decir el fin de la lista), la que se debe incrementar cada vez que se hace una insercin y que deber actualizarse (decrementndola), cuando se haga el desplazamiento despus de una supresin. Esta variable puede servir para el control del desfonde cuando sea menor que 1; y para el desborde cuando sea mayor que n. const n = 100; type lista = record {donde se guardan los elementos} lis : array [1..n] of char; cur : 0..n {cursor de la lista}; ultimo : 0..n end Ejemplo 11.7
lugares libres
Estado del arreglo: antes de insertar 1 S 2 G 3 Z 4 ? ... ... n ?
despus de insertar U (donde indica cur) 1 S 2 U 3 G 4 Z 5 ? ... ... n ?
{ ultimo = 3, cur = 2 }
ultimo := ultimo + 1; { ultimo = 4, cur = 2}
Primero
Sentido del desplazamiento para poder insertar
Primero
Figura 11.10
Ejemplo de insercin en una lista de caracteres, implementada con desplazamiento y variable para el ltimo y el primero fijo en la primera posicin del arreglo soporte.
U.N.S.L. Argentina
89
lugares libres
Estado del arreglo: antes de suprimir 1 S 2 G 3 Z 4 ? ... ... n ?
despus de suprimir (donde indica cur) 1 S 2 Z 3 ? 4 ? ... ... n ?
{ ultimo = 3, cur = 2 }
ultimo := ultimo 1; { ultimo = 2, cur = 2}
Primero
Sentido del desplazamiento para suprimir
Primero
Figura 11.11
Ejemplo de supresin en una lista de caracteres, implementada con desplazamiento y variable para el ltimo y el primero fijo en la primera posicin del arreglo soporte.
Con una marca

Con una marca que sirva para saber dnde est, en el arreglo, el ltimo, (es decir el fin de la lista). Esta marca deber ser un valor de los del tipo de los elementos de la lista que solo podr ser utilizado para esto y no como VIPD, lo que obliga a reducir el conjunto de los valores posibles de los elementos en uno. Esta marca ocupa un lugar en el arreglo, lo que reduce en uno la cantidad de espacio destinado a los elementos en la estructura soporte. La marca puede servir para el control del desfonde (est en la posicin del primero de la lista, posicin 1 del arreglo); o para el desborde (est en la posicin n del arreglo). La marca deber desplazarse, junto con el resto de los elementos de la lista, cada vez que se haga una supresin o una insercin. const marca = *; n = 100; type lista = record {donde se guardan los elementos} lis : array [1..n] of char; cur : 0..n {cursor de la lista}; end Ejemplo 11.8 Algo similar ocurre si se fija el primero de la lista en la ltima posicin del arreglo. En este caso el desplazamiento de los elementos de la lista, que estn en el arreglo, cada vez que se hace una supresin tendr un sentido distinto. La variable que sirva de puntero para saber donde est, en el arreglo, el ltimo, (es decir el fin de la lista) se deber decrementar cada vez que se hace una insercin y deber actualizarse (incrementndola) cuando se haga el desplazamiento despus de una supresin.
U.N.S.L. Argentina
90
En lugar de fijar el primer elemento de la lista en alguno de los extremos del arreglo que sirve como soporte, como se explic en los prrafos anteriores, puede fijarse el ltimo en alguno de los extremos y tener un puntero o
lugares libres
Estado del arreglo: antes de suprimir 1 S 2 G 3 Z 4 * 5 ? ... ... n ?
despus de suprimir (donde indicaba cur) 1 G 2 Z 3 * 4 * 5 ? ... ... n ?
{ cur = 1 }
{ cur = 1}
Primero
marca
Nuevo Primero
Nueva marca
Sentido del desplazamiento de la marca y los elementos para suprimir
Figura 11.12
Ejemplo de supresin en una lista de caracteres, implementada con desplazamiento y marca despus del ltimo, y el primero fijo en la primera posicin del arreglo soporte. una marca para el primero. El desplazamiento solo se har, para todos los elementos de la lista, cuando se trata de una insercin o supresin al primero o al ltimo (dependiendo de cual se haya fijado); y parcialmente si la insercin o supresin se hace en algn elemento intermedio. Es decir que se desplazan slo aquellos elementos que cubren el lugar del suprimido o que liberan un lugar para insertar uno nuevo. El desplazamiento en estos casos se har desde el lugar que se quiere liberar (caso de la insercin), o hacia el lugar que se quiere ocupar (caso de la supresin), hasta el primero (si se fij el ltimo) o el ltimo (si se fij el primero). El manejo de los espacios libres es dinmico, y los mismos se encuentran todos juntos y contiguos despus del primero (si se fij el ltimo), o despus del ltimo (si se fij el primero). Puede decirse que los espacios libres se encuentran organizados como una pila en la que se inserta (push) cada vez que se suprime un elemento de la lista y se suprime (pop) cada vez que se inserta un elemento en la lista.
U.N.S.L. Argentina
91
lugares libres
Estado del arreglo: antes de insertar 1 S 2 G 3 Z 4 * 5 ? ... ... n ?
despus de insertar U (donde indicaba cur) 1 U 2 S 3 G { cur = 1} marca 4 Z 5 * ... ... n ?
{ cur = 1 }
Primero
marca
Nuevo Primero
Sentido del desplazamiento de la marca y los elementos para insertar
Figura 11.13
Ejemplo de insercin en una lista de caracteres, implementada con desplazamiento y marca despus del ltimo, y el primero fijo en la primera posicin del arreglo soporte.
Sin desplazamiento
En este caso debe constituirse cada elemento de la lista a ser simulada con la VIPD y el o los punteros (para las bi-direccionales habr dos).
Con arreglos separados

Se emplearan tantos arreglos como sean necesarios. Por ejemplo para simular una lista uni-direccional ser necesario contar con dos arreglos: uno para las VIPDs, cuyo tipo base ser el tipo de los elementos de la lista; y otro para los punteros cuyo tipo base ser el que sirva para indexar el arreglo reservado para los elementos, ms un valor reservado para el NIL, que no deber ser uno de los que sirva para direccionar el arreglo. Adems se necesitar una variable que apunte al lugar, en el arreglo, donde se encuentra el primer elemento de la lista. Veamos un ejemplo de definicin de un tipo en Pascal que sirva como soporte de una lista bi-direccional de caracteres.
U.N.S.L. Argentina
92
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase const n = 9; type blista = record {para guardar las VIPDs} vipd : array [1..n] of char; {punteros al siguiente elemento} ps : array [1..n] of 0..n; {punteros al elemento anterior} pa : array [1..n] of 0..n; acc : 0..n; {acceso a la lista} lib : 0..n; {acceso a los espacios libres} cur : 0..n; {cursor de la lista} curaux : 0..n {cursor auxiliar} end Ejemplo 11.9
As la posicin i-sima del arreglo de los elementos junto con la i-sima del arreglo de los punteros constituirn el elemento de la lista con sus dos componentes: VIPD y puntero al siguiente (si es uni-direccional, por supuesto). Obviamente el valor que se guarde en el i-simo elemento del arreglo reservado para los punteros ser la posicin en el arreglo de los elementos (y de los punteros!!) donde se encuentra el elemento de la lista que sigue (al i-simo). La variable que apunte al primer lugar de la lista tendr el valor de la posicin de ambos arreglos (que es la misma!!!) donde se encuentra el primer elemento de la lista (que no es necesariamente el primero del arreglo!!!). La variable que sirve como cursor auxiliar tiene el propsito de apuntar al elemento anterior al apuntado por el cursor. Esto permite trabajar sin problemas, tanto en las supresiones como en las inserciones, para enganchar los punteros. Cosa que puede hacerse fcilmente en las listas bi-direccionales (porque existe un puntero atrs) pero que resulta ms difcil en las uni-direccionales. De no existir, para re-acomodar los punteros, ser necesario recorrer la lista (en las uni-direccionales, por lo menos), desde el principio, para encontrar al elemento anterior al que apunta el cursor (que es el que se quiere eliminar o donde se quiere insertar). En la Figura 11.14 se muestra una lista bi-direccional. Para cada elemento aparecen los valores correspondientes, tanto para los elementos como para los punteros, suponiendo una implementacin empleando varios arreglos, como la del Ejemplo 11.9. El estado de la lista, as como el de los arreglos, no es necesariamente el inicial sino uno, de los tantos posibles, luego que se haya operado, haciendo inserciones y supresiones, con la lista. En la Figura 11.15 se muestra el estado de los arreglos, antes y despus de una supresin. Antes corresponde a la lista de la Figura 11.14.
U.N.S.L. Argentina
93
cur (cursor) nil

pa pa
4 0 7 4 6 nil 7
Z
4
T
6
ps
G
1
S
0
acc (acceso)
Figura 11.14
Ejemplo de una lista bi-direccional de caracteres con los valores de los campos de punteros, ps (siguiente), pa (anterior), acc (acceso) y cur (cursor) de la estructura soporte del Ejemplo 5.9, indicados al lado de las flechas que sirven de punteros en el grfico.
Estado de los arreglos: antes de suprimir 1 vipd S ps pa 0 6 2 ? 8 ? 3 ? 2 ? 4 T 6 7
despus de suprimir en donde indicaba cur (los lugares con ? no interesa que valor tengan) 5 ? 3 ? 6 G 1 4 7 Z 4 0 8 ? 9 ? 9 ? 0 ? 1 S 0 6 2 ? 8 ? 3 ? 2 ? 4 T 5 7 5 ? 3 ? 6 G 1 7 7 Z 6 0 8 ? 9 ? 9 ? 0 ?
{ acc = 7, cur = 4, lib = 5 }
{ acc = 7, cur = 6, lib = 4 } Figura 11.15
Despus de la supresin, la lista queda como se muestra en la Figura 11.16.
U.N.S.L. Argentina
94
La Figura 11.17 muestra el estado del arreglo antes (tal como haba quedado, la lista, en la Figura 11.16) y despus de una insercin.
nil
pa
cur nil 6
7 acc
Z
6
G
1
ps
S
0
Figura 11.16
Estado de los arreglos: antes de insertar 1 vipd S ps pa 0 6 2 ? 8 ? 3 ? 2 ? 4 T 5 7
despus de insertar en donde indicaba cur (los lugares con ? no interesa que valor tengan) 5 ? 3 ? 6 G 1 7 7 Z 6 0 8 ? 9 ? 9 ? 0 ? 1 S 0 6 2 ? 8 ? 3 ? 2 ? 4 U 6 7 5 ? 3 ? 6 G 1 4 7 Z 4 0 8 ? 9 ? 9 ? 0 ?
{ acc = 7, cur = 6, lib = 4 }
{ acc = 7, cur = 4, lib = 5 } Figura 11.17
La Figura 11.18 muestra como queda la lista luego de la insercin mostrada en la Figura 11.17. Los espacios libres pueden ser administrados de las dos maneras mencionadas en la seccin Mtodos de administracin de los espacios libres, es decir esttica o dinmica. En ambos casos ser necesario tenerlos organizados en alguna estructura que permita emplearlos cada vez que se quiere insertar en la estructura simulada, y para el caso del manejo dinmico dicha estructura (de los espacios libres) tendr que permitir insertar cuando se suprima en la lista simulada. Cuando el manejo sea dinmico los espacios libres tendrn que estar organizados como una lista (es decir con punteros), ya que no necesariamente, luego de varias inserciones y supresiones, estarn contiguos en el arreglo. Esta lista, de espacios libres, sin embargo, puede comportarse como una pila ya que las respectivas inserciones (cuando se suprime en la lista simulada) y supresiones (cuando se inserta en la lista simulada) pueden hacerse en el primer lugar de la misma.
U.N.S.L. Argentina
95
nil 4 0 7 4 6
cur (cursor)
nil
Z 7 4 acc (acceso)
U 6
G 1
S 0
Figura 11.18
Adems se necesitar una variable que apunte al lugar, en el arreglo, donde se encuentra el primer elemento de la estructura de los espacios libres (acceso a la lista de espacios libres). Cmo seran los procedimientos y funciones que implementan las operaciones posibles sobre una lista definida con la estructura soporte del Ejemplo 11.9? La condicin de lista vaca es fcil: si el acceso es igual a cero, que equivale a nil, entonces no hay nada en la lista. La condicin de lista llena, o mejor dicho, de cundo no hay ms lugar en la estructura soporte para seguir insertando, es tambin sencilla: si la estructura de los espacios libres est vaca no hay lugar para insertar. Cundo est vaca sta estructura? Cuando el acceso a ella es igual a cero, que equivale a nil. Cundo el cursor est fuera de la estructura (oos = true)? Esto es cuando el cursor es igual a cero, que equivale a nil. Cmo se hace avanzar el cursor? Esto es asignar al cursor el valor del puntero al siguiente del elemento apuntado por el cursor. Es decir hacer cur := ps[cur]. Por qu? Porque hay que hacer que cur tome el valor del puntero al siguiente (ps), para que apunte justamente al siguiente elemento. Este valor se encuentra en el arreglo ps, en la posicin apuntada por cur. Para insertar hay que conseguir un lugar libre. Esto se hace usando el acceso a la estructura de los espacios libres. Como el nuevo elemento se inserta entre dos elementos existentes o en el primer lugar (que equivale a insertarlo entre el acceso y el primer elemento) o despus del ltimo, hay que controlar de qu caso se trata. Si es entre dos elementos habr que hacer que el elemento anterior (el que es apuntado por el cursor auxiliar) apunte al nuevo y el nuevo apunte al corriente (que es apuntado por el cursor), y luego hacer que el cursor apunte al nuevo. Para suprimir hay que hacer que el puntero al siguiente (ps), del elemento anterior al apuntado por el cursor (que est apuntado por el cursor auxiliar curaux), apunte al elemento apuntado por el puntero al siguiente (ps) del elemento apuntado por el cursor (cur). Luego, hacer que el cursor (cur) apunte al elemento apuntado por el puntero al siguiente (ps) del elemento al que cur apunta (esto se parece bastante a la operacin de avanzar el cursor). Tambin en este caso habr que tener en cuenta los casos especiales (si los hay!): primero, ltimo, etc.
Con un solo arreglo

Este caso es posible cuando puede emplearse el tipo registro, u otra estructura similar, por ejemplo el record del
U.N.S.L. Argentina
96
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase Pascal.
El arreglo tendr como tipo base un registro cuyos campos debern ser las distintas partes de cada uno de los elementos de la lista: VIPD y puntero o punteros (cuando se trate de una lista bi-direccional). Veamos un ejemplo de definicin de un tipo en Pascal que sirva como soporte de una lista bi-direccional de caracteres: const n = 10; type blista = record lis : array [1..n] of record vipd : char; ps : 0..n; pa : 0..n end; acc, lib, cur, curaux : 0..n end Ejemplo 11.10 El manejo y administracin, tanto de la lista simulada como de los espacios libres, se realizar de la misma manera que en el caso de varios arreglos, tal como fue explicado en la seccin Mtodos de administracin de los espacios libres. Obviamente la referencia a los elementos y al puntero (o a los punteros para las bi-direccionales) ser en el registro y no en los arreglos.
U.N.S.L. Argentina
97
Recursividad
CAPTULO 12 RECURSIVIDAD
12.1 ociones generales
Hasta ahora se han visto tres estructuras fundamentales de programacin: secuencia (o concatenacin), seleccin, e iteracin. Vamos a introducir ahora una cuarta que guarda poca relacin con las anteriores, y de la cual puede decirse, quizs, que no sea realmente una estructura sino ms bien una metodologa de resolucin de algunos problemas particulares. Nos referimos a la recursividad o recursin. Podemos decir que esta tcnica es otra forma de realizar repeticiones. Ya hemos visto que las repeticiones las hacemos por medio de iteraciones. Ahora veremos que tambin pueden hacerse empleando recursin. En general llamaremos recursin a la tcnica empleada en definir una funcin en trminos de s misma. En los lenguajes de programacin hablaremos de mdulos, que por supuesto incluyen a las funciones, y tambin a los procedimientos (por ejemplo en Pascal), las subrutinas, los subprogramas, etc. Nosotros distinguiremos, para la definicin de una funcin recursiva (o mdulo) dos partes: 1. Definicin circular del mdulo que le permite definirse en trminos de s mismo. Ejemplo: n! = f (n) f : 0
f (n) = f (n 1) n se debe conocer (n 1) para n! y (n 1)! = f (n 1) = f (n 2) (n 1) 2. Valor del dominio conocido. Esto es cuando, para uno o ms valores del dominio del mdulo o funcin, se conoce el valor que toma el mismo. Siguiendo con el ejemplo anterior diremos, por ejemplo, que f (0) = 1, entonces tendremos: n! = f (n) f : 0 si n 0
f (n) = f (n 1) n f (0) = 1
Como toda repeticin la recursin tambin puede ser finita o infinita, dependiendo de la condicin que la controla. En este caso la condicin es el valor o valores del dominio conocido que permite que la recursin termine. Decimos que: recursin es la tcnica que consiste en definir un objeto en trminos de s mismo y que: (a) existe una frmula circular que define el objeto por l mismo. (b) aplicando reiteradamente esa frmula se llega a uno o varios puntos del dominio del objeto donde el valor del mismo es conocido. El objeto del cual hace referencia la definicin del prrafo anterior es generalmente una funcin. En el mbito de los lenguajes de programacin, como ya lo hemos dicho ms arriba, ello se extiende tambin a los procedimientos (procedures), por ejemplo en el caso del Pascal y de otros lenguajes que permiten el uso (y definicin por supuesto!) de, no slo funciones, sino tambin procedimientos, subrutinas, subprogramas, etc.. En algunos casos la definicin circular (o frmula circular) es suficiente para definir algo que es necesario hacerlo en forma repetitiva. El valor (o valores) conocidos se presupone o an cuando no sea conocido (y entonces podra decirse que la definicin es infinita) no es estrictamente necesario para lo que se pretende definir. Esto es
U.N.S.L. Argentina
98
Recursividad
muy comn en Matemtica y en algunas otras aplicaciones de Informtica. Cuando la definicin circular es usada de esta manera puede ser que se llame definicin recursiva. Un ejemplo de esto podra ser la definicin circular (o para el caso recursiva) de los nmeros enteros. function factorial (n : integer) : integer ; begin if n > 0 then factorial := n * factorial(n 1) else factorial := 1 end Ejemplo 12.1 En el Ejemplo 12.1 damos una definicin de un function en Pascal que calcula el factorial de un nmero entero. Vemos que en la rama del then existe, en la asignacin a factorial una invocacin (factorial(n 1)) a la funcin. Esta es la invocacin que hace que factorial sea una funcin definida en forma circular. El valor del dominio conocido es el cero: Vase en el ejemplo que para n = 0 entonces factorial = 1. La funcin factorial est, entonces, definida recursivamente: tiene una definicin circular y al menos un valor del dominio conocido. Supongamos, ahora, que dicha funcin es invocada en un programa de la siguiente manera: writeln(factorial(2)); Puede verse en la Figura 12.1 que se realizan tres llamadas de la funcin, antes que se obtenga un valor para factorial (punto del dominio conocido) y puedan calcularse los valores correspondientes a las llamadas anteriores. Nmero de invocaciones n factorial En efecto, en la primera llamada, siendo n > 0 debe llamarse nuevamente a factorial con el valor n 1 (n = 2, entonces n 1 = 1); en el segundo llamado, siendo n > 0 (n = 1, n 1 = 0) debe llamarse nuevamente a factorial con el valor n 1, y es entonces, en el tercer llamado, que siendo n = 0, factorial = 1, podr ahora, calcularse, yendo hacia atrs, los distintos valores de la expresin.
1 2 3
2 0 1
Figura 12.1
2 factorial (1)
1 1 factorial (0)
Esto, que el compilador se encarga de implementar, implica suspender el clculo de la funcin hasta tanto se obtenga un valor conocido para la funcin (en el caso del Ejemplo 12.1 cuando n = 0, entonces factorial toma el valor 1) y volver a invocar la funcin mientras no se tenga un valor. En el Ejemplo 12.1, si n > 0 entonces se invoca nuevamente factorial.
12.2 Profundidad
Las invocaciones recursivas de mdulos traen aparejadas, en la mayor parte de los lenguajes de programacin, un uso bastante importante de memoria. Esto es as ya que cada invocacin de un mdulo, especialmente cuando esta es realizada dentro de otro mdulo (lo que, claro, incluye las invocaciones recursivas), implica una suspensin del flujo del programa para saltar a la ejecucin de las sentencias del mdulo invocado. Este salto implica un retorno a la sentencia siguiente a la de invocacin para continuar con la ejecucin interrumpida. El retorno debe ser hecho de manera ordenada, es decir que, por ejemplo, las variables deben continuar con el valor que ellas tenan antes de la invocacin. Para esto generalmente se emplea una pila, a la que se la denomina usualmente pila de ejecucin o stack de ejecucin (execution stack en ingls) en donde se va guardando toda la informacin del estado de ejecucin de cada mdulo invocado. A este conjunto de datos, entre los que se encuentra por ejemplo la direccin de retorno (el lugar del programa donde se encuentra la sentencia siguiente a la invocacin), las variables locales y los parmetros del mdulo, se lo llama registro de activacin. Cada vez que se invoca un mdulo se coloca en el tope de la pila su correspondiente registro de activacin, el
U.N.S.L. Argentina
99
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase cual es suprimido del tope al alcanzar el fin del mdulo y retornar el control al mdulo invocante.
Recursividad
Tales activaciones de los mdulo pueden anidarse hasta cualquier nivel (en particular en forma recursiva). Todo ello nos lleva al concepto de profundidad de la recursin que es la cantidad mxima de registros de activacin del mdulo recursivo que se van a encontrar simultneamente en la pila de ejecucin. Cuando la recursin es lineal, como por ejemplo en el caso de la funcin factorial, la profundidad de la recursin coincide con la cantidad de veces que la funcin o procedimiento es invocada para un conjunto de argumentos dados. (En el caso del Ejemplo 12.1 y para n = 2 la funcin es invocada tres veces, es decir diremos que la profundidad es n+1). Esto es as para el caso en que haya una sola invocacin en el mdulo recursivo. Si hay ms de una invocacin, es decir, la recursin no es lineal, como es el caso del ejemplo de la sucesin de Fibonacci, entonces diremos que la profundidad coincide con la longitud de la rama del rbol de invocaciones ms larga + 1 (ver Figura 12.2). Es por esto que la profundidad debe ser razonable y finita. Finita porque es condicin que el programa termine y razonable porque de lo contrario la recursin puede hacerse bastante lenta y tomar un tiempo excesivamente largo en terminar, peor an, puede llegar a desbordar la pila de ejecucin. Para ello vase el Ejemplo 12.2 y la profundidad para m = 2 y n = 3; ello permitir darse una idea de cmo la recursividad puede ocultar la cantidad de veces que un mdulo, puede ejecutarse. function a (n, m : begin if m = 0 then a := else if n then else end integer) : integer ;
n + 1 = 0 a := a(m 1, 1) a := a(m 1, a(m, n 1))
Ejemplo 12.2. Profundidad de la recursin.
12.3 Recursividad. Ejemplos

Veamos algunos otros ejemplos de definiciones recursivas que contemplen otros aspectos de la recursin tales como el hecho de que para la definicin recursiva deba hacerse ms de una invocacin dentro de la definicin, como sucede con el Ejemplo 12.2.
Sucesin de Fibonacci
Fibonacci, o ms correctamente Leonardo de Pisa o Leonardo Pisano, naci en Pisa, Italia, alrededor de 1175. Hijo de Guglielmo Bonacci, comenz quizs a usar el nombre Fibonacci como una abreviatura de filius Bonacci, hijo de Bonacci. Debido a que su padre tena contactos comerciales con el norte de frica, Fibonacci creci con una educacin influenciada por la cultura de los Moros, especialmente su matemtica. Estos a su vez haban sido influenciados por la cultura Hind que utilizaban la notacin posicional decimal (empleada hoy en da) con los smbolos arbigos, especialmente el cero. Fibonacci introdujo esta matemtica, incluida la forma, o algoritmos, de realizar las operaciones elementales, en la Europa de esa poca, que todava utilizaba el sistema romano de numeracin. En su libro Liber abbaci (Libro del baco o Libro del Clculo), no solo introdujo el sistema hindarbigo de numeracin y clculo, sino tambin el problema de los conejos como una forma de los lectores del libro de practicar las operaciones introducidas. Este problema puede resumirse as: Si un par de conejos son puestos en un campo, y si los conejos toman un mes en madurar, y si luego producen un nuevo par de conejos cada mes a partir de ese momento, cuntos pares de conejos habr en doce meses? Se supone que los conejos no mueren ni se escapan. Este problema da origen a la sucesin de nmeros: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
U.N.S.L. Argentina
100
Recursividad
Como toda sucesin, los trminos de la misma se denominan empleando los nmeros ordinales (1, 2, , etc.). As la sucesin puede verse: Trmino Valor 1 0 2 1 3 1 4 2 5 3 6 5 7 8 8 13 9 21 10 34 11 55 12 89
El matemtico francs Edouard Lucas (1842-1891), le dio el nombre de nmeros de Fibonacci a esta sucesin, adems de descubrir importantes propiedades de la misma.
f (5)
Cada trmino de la sucesin se calcula sumando los dos anteriores, salvo los dos primeros, que son 0 y 1 respectivamente.
f (3)
f (4)
Cualquier trmino n (n > 0) de esta sucesin puede calcularse por medio de una definicin recursiva: n=1, f (1) = 0 El primer trmino de la sucesin es el 0 n=2, f (2) = 1 El segundo trmino de la sucesin es el 1
f (3)
f (2)
f (2)
+ f (1)
f (2)
+ f (1)
n > 2 , f (n) = f (n 1) + f (n 2) El tercer trmino y los sucesivos se calculan. Obsrvese que esta definicin recursiva, en la parte de la definicin circular, tiene dos llamadas a la funcin, en lugar de una como la definicin de la factorial, por ejemplo. Hay adems dos valores
Figura 12.2. rbol de llamadas para el quinto trmino de la sucesin de Fibonacci
conocidos del dominio: 1 y 2. Estas dos llamadas implican que para calcular f(n), primero se debe calcular el valor de f (n 1) y luego el de f (n 2) . Pero ambas invocaciones, a su vez, tienen que realizar el clculo de f ((n 1) 1) + f ((n 1) 2), y de f ((n 2) 1) + f ((n 2) 2), y as sucesivamente, en cada caso. Estas dos llamadas pueden verse representadas como una estructura de rbol como se ve en la Figura 12.2, (el rbol est al revs, con la raz arriba y las ramas hacia abajo). Las hojas finales del rbol son los valores del dominio conocido, 1 y 2, que devuelven 0 y 1 respectivamente.
Esto nos lleva a que la definicin de la funcin, en Pascal, debe tener dos condiciones: una para 0 y otra para 1.
function f (n: integer): integer; begin if (n = 1) then f:= 0 else if (n = 2) then f:= 1 else f:= f(n 1) + f(n 2) end; { de f }
Ejemplo 12.3. Solucin recursiva en Pascal para la sucesin de Fibonacci. El Ejemplo 12.3 muestra una definicin de una funcin en Pascal para calcular un trmino de la sucesin de Fibonacci teniendo en cuenta la definicin recursiva dada ms arriba. Hay que hacer notar que, por razones de simplicidad y para mantener coherencia con la definicin dada ms arriba, la funcin del ejemplo no controla que el parmetro n sea mayor que cero.
U.N.S.L. Argentina
101
Recursividad
Torres de Hanoi
Un ejemplo de solucin recursiva de un problema es el del juego llamado Torres de Hanoi, inventado por el matemtico francs Edouard Lucas y que se venda como un juego ya a fines del siglo XIX. Aparentemente Lucas
B (a)
C
Figura 12.3.
1 2 3 A
B (b)
se inspir en una leyenda oriental que deca que un grupo de monjes deban mover una pila de sesenta y cuatro discos de oro de un poste a otro. De acuerdo con la leyenda Pilas cuando terminen su tarea tanto el templo como el mundo se Paso Mov. A (origen) B (auxiliar) C (destino) terminan tambin. El juego consiste en pasar una torre o pila 1 de objetos de un lugar a otro, respetando las siguientes inicio 2 reglas: (a) slo puede emplearse un lugar auxiliar, (adems 1 2 1 AB del original de partida y el del destino); (b) slo puede A moverse un objeto por vez; (c) no puede nunca apilarse un 2 1 2 C objeto encima de otro ms pequeo. Generalmente se 1 representa tal como el juego se vende: los objetos son discos 3 BC 2 con un agujero en el medio y tres clavijas montadas cada Figura 12.4. Torre o pila con dos elementos. una sobre una base, que representan las pilas (la de partida u origen, la de llegada o destino y la auxiliar), como se ve en la Figura 12.3(a), donde hay tres discos en la clavija de origen. Nosotros podemos representarlo como tres pilas de nmeros naturales como se ve en la Figura 12.3(b). Dems estar decir que el tamao de los objetos est en relacin directa con los nmeros naturales. Cul es la solucin del problema? Una forma de encarar esto es suponer el caso ms simple: si se trata de pasar un solo nmero esto es fcil: se pasa y terminamos, ya que no queda nada por pasar ni en la pila de origen (A), ni en la auxiliar (B).
Pilas A (origen) B (auxiliar) 1 inicio 2 3 2 1 3 2 3 2 1 3 3 2 1 4 2 5 1 2 Paso C (destino) Mov.
1 1
AC A B CB
Compliquemos ms el caso a tratar: si hay dos nmeros a pasar, entonces: 1 pasamos el que est en el tope de A (pila de origen) a B (pila auxiliar), 2 luego el nuevo tope de A a C (pila de destino), y por fin 3 el que estaba en B a C y terminamos ya que no queda nada por pasar ni en la pila de origen (A), ni en la auxiliar (B). Estos pasos pueden verse en la Figura 12.4. Esto nos permite deducir que para pasar dos elementos son necesarios tres movimientos.
Si hay tres nmeros a pasar, podemos ver la sucesin de pasos en la Figura 12.5. Vemos que la solucin para tres 3 AC elementos consiste en aplicar la solucin para dos 3 B A elementos, antes de pasar el tercer elemento. Se pasa del origen a la auxiliar todos los elementos menos uno. Esto 2 6 1 BC sucede en los primeros tres pasos. Hay que notar que para 3 ello se emplean dos pilas: la auxiliar y la destino. Luego, el 1 ltimo elemento que queda en el origen se pasa al destino, 7 2 AC paso 4. Por ltimo se pasan los elementos que estn en la 3 pila auxiliar al destino, son los pasos 5 a 7. Para esta Figura 12.5. Torre o pila con tres elementos. operacin se utilizan las pilas origen y auxiliar. Para esta ltima etapa hay que utilizar, ahora, el origen como auxiliar, considerando a la auxiliar como origen.
U.N.S.L. Argentina
102
A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase En el Ejemplo 12.4 puede verse el mdulo en Pascal que emplea la solucin recursiva. Se supone que las declaraciones previas de los tipos y otros mdulos all empleados para administrar las pilas (copy, insert, supres, etc.) ya han sido declarados previamente y pueden ser empleados. Adems de las tres pilas empleamos un parmetro ms (n) para indicar la cantidad de elementos a pasar. Puede verse que la solucin consiste en mover primero todos los elementos, menos uno, de la pila original (orig) a la auxiliar (aux), cualquiera sea la cantidad de elementos, esta es la primera sentencia de invocacin del procedure hanoi: hanoi(n-1; orig; aux; dst). Luego, cuando queda un solo elemento, se mueve a la pila de destino (dst), esta es la segunda sentencia de invocacin del procedure hanoi: hanoi(1; orig; dst; aux)
Recursividad
procedure hanoi(n: integer; var orig, dst, aux: pila) var c: vipd; begin if (n = 1) then begin copy(orig, c); supres(orig); insert(dst, c) end else { n <> 1 } begin hanoi (n - 1; orig; aux; dst); hanoi (1; orig; dst; aux); hanoi (n - 1; aux; dst; orig) end end; { de hanoi }
Ejemplo 12.4. Solucin recursiva en Pascal Por fin se mueven todos los elementos de la pila auxiliar a la de destino, que es la tercera sentencia de invocacin del procedure hanoi: hanoi(n-1; aux; dst; orig) Es claro que, cada una de estas sentencias de invocacin del procedure hanoi, implican, a su vez, el llamado de ellas mismas en cada una. Salvo la segunda sentencia de invocacin ya que como su primer parmetro es 1, y ese es el punto de parada, all termina la recursin: es el caso de mover un solo elemento.
12.4 Recursividad directa e indirecta

Hasta ahora hemos visto slo lo que llamamos recursividad directa: un mdulo (en Pascal un procedimiento o una funcin) que se llama a s mismo, como en los ejemplos anteriores. Existe tambin la recursividad indirecta que es aquella que se produce cuando un mdulo A llama a otro B, y ste a A, como en el Ejemplo 12.5, dnde los mdulos son funciones. La recursividad indirecta plantea un problema sintctico en el lenguaje Pascal, y en otros lenguajes con similares caractersticas, es decir aquellos que tienen el principio de definir o declarar antes de usar; ya que en ellos un mdulo debe definirse antes de que el mismo sea invocado. Como puede verse en el Ejemplo 12.5 ello es imposible ya que estamos ante un caso de que fue antes: si el huevo o la gallina, cul definimos primero a o b? Una solucin podra ser prohibir el uso de recursividad indirecta, pero en Pascal ello no es as; la solucin consiste en emplear una sentencia a la que se la denomina forward reference o forward solamente (depende del compilador) que permite indicar que una funcin o procedimiento ser declarado ms adelante y entonces podr ser empleado (invocado) antes de su declaracin completa. Esto se ilustra en el Ejemplo 12.5; vase que la function b inicialmente slo tiene declarado su encabezamiento, luego sigue la declaracin de la function a, que a su vez invoca a b, y despus l a declaracin de b; que a su vez, tambin invoca a a.
U.N.S.L. Argentina
103
Recursividad
Es cierto que, como sucede en la mayor parte de los casos, la recursividad se materializa en mquinas que no son en s mismas recursivas y que a lo sumo permiten realizarla con ms o menos facilidad. La mayor parte de los problemas que pueden ser solucionados en forma recursiva aceptan, en consecuencia, una solucin iterativa. La eleccin de una solucin recursiva o iterativa depender entonces de las caractersticas particulares del problema as como de los medios que se cuentan para materializar la solucin. Generalmente la solucin recursiva es ms lenta que una iterativa, sin embargo la primera, cuando el problema en s es recursivo, es mucho ms directa. Ejemplo 12.5. Otro ejemplo de recursividad indirecta.
program recur_ind; type FT = 0..1; function b (x : FT) : boolean; forward; function a(x : FT) : boolean; begin if b(x) then begin writeln('a - true'); a := false; end else begin writeln('a - false'); a := true; end; end; { de a } function b(x : FT) : boolean; { parametros y tipo ya declarados en forward} begin if x = 1 then begin writeln('b - true'); b := true end else begin writeln('b - false'); b := a(x) end; end; { de b } var g1: FT; g2: boolean; begin { programa principal } readln(g1); if b(g1) then writeln('b(false)'); readln(); end.
El Ejemplo 12.5 muestra el programa completo de un posible uso de la recursividad indirecta. Se recomienda al lector que lea atentamente el ejemplo y. si es posible, lo compile y ejecute. Se ver que dicho programa tiene un error sutil, puede descubrir cul es el error? Puede repararlo?
12.5 Ventajas e inconvenientes

La recursividad tiene ventajas e inconvenientes. Entre las primeras podemos citar la posibilidad de que nos permite definir un conjunto infinito de objetos por una sentencia finita y en consecuencia ello puede trasladarse a un programa recursivo finito aunque el mismo no tenga repeticiones explcitas. Los algoritmos o soluciones recursivas son tiles cuando la definicin es recursiva (definicin del problema: datos o algoritmo). Por otro lado la recursividad oculta, y algunas veces en forma muy efectiva, no ya slo el nmero de veces que algo se ejecuta (ver Ejemplo 12.2) sino que, particularmente en el caso de la recursividad indirecta, oculta la existencia de repeticiones en el programa. En ese sentido la recursividad no contribuye a hacer equivalentes las estructuras esttica y dinmica de un programa, sino todo lo contrario. Nos permite, sin embargo, (particularmente cuando existe una definicin recursiva), soluciones cortas desde el punto de vista del texto del programa y adaptadas directa y fcilmente a partir de la definicin del problema y su algoritmo de solucin.
12.6 Datos recursivos

Un caso particular de soluciones recursivas es cuando los datos a tratar admiten, o mejor aun, tienen, una definicin recursiva. En dicho caso el procesamiento por medio de un programa se presta fcilmente a una solucin recursiva. El caso de listas de elementos (los cuales pueden o no ser a su vez, listas) es un ejemplo de datos que pueden definirse recursivamente y en consecuencia ser tratados de la misma manera. As, dados: e que denota un elemento de lista, donde e tiene la forma (vipd, puntero); que denota la lista vaca. Podemos definir una lista L, en forma recursiva, diciendo que: L=
U.N.S.L. Argentina
L=eL Departamento de Informtica
104
Recursividad
En general, al implementar una lista se hace que cuando L = , entonces puntero = nil, y la lista termina. La misma definicin en Pascal nos dara lo que puede verse en el Ejemplo 12.7, donde se define una lista de caracteres y cuya representacin grfica, para una lista dada, podra ser aquella de la Figura 12.6.
Figura 12.6. Una lista de los caracteres z, x, a, u. Viendo la definicin de los datos del Ejemplo 12.7 parece natural (parece, no?) tratar una lista as definida de manera recursiva, an cuando en la definicin no aparezca explcitamente el valor del dominio conocido que implcitamente decimos que es el valor nil del tipo de dato pointer. As, si se tratase de recorrer la lista imprimiendo sus elementos una solucin podra ser la del Ejemplo 12.8, donde se supone la definicin del Ejemplo 12.7, y si suponiendo seguimos y decimos que la lista de la Figura 12.6 es la que se encuentra en memoria para ser recorrida, el resultado sera: z x a u. Por supuesto ello implica declaraciones tales como var acceso : L; as como la invocacin a recorre(acceso); con el puntero al primer elemento de la lista (acceso) como parmetro real. Que pasara si en la definicin del Ejemplo 12.8 se intercambian las sentencias que se encuentran dentro del bloque del then, es decir si en lugar de que la secuencia sea: write(p^.vipd); recorre(p^.puntero) fuese: recorre(p^.puntero); write(p^.vipd)? El resultado sera: u a x z . Porqu? Porque en el primer caso (el del Ejemplo 12.8) primero se ejecuta el write y luego la invocacin recursiva, mientras que en el segundo caso primero se ejecuta la invocacin recursiva y hasta que esta no termine (es decir que no se llegue al fin de la lista) no se ejecuta el write, que al ejecutarse por primera vez toma el ltimo elemento de la lista y es all donde termina la ejecucin de la ltima invocacin y al retornar toma el penltimo elemento y as sucesivamente hasta el primero. type L = ê; e = record vipd : char; puntero : L end procedure recorre(p: L); begin if p <> nil then begin write(p^.vipd); recorre(p^.puntero) end end Ejemplo 12.8. Recorree una lista recursivamente
Ejemplo 12.7. Definicin recursiva de una lista de caracteres.
En este caso decimos que el valor del dominio conocido para los datos es el nil. Es as, entonces que el procedure recorre tiene a nil como valor conocido para el pointer y es donde termina.
12.7 Implementacin de listas con datos recursivos

Sabemos que la implementacin de una lista, para funcionar, necesita de cosas tales como cursores, acceso, etc. Una definicin recursiva de una lista unidireccional de caracteres, que contemple estos casos, podra ser la que se muestra en el Ejemplo 12.9. Por supuesto no es necesario tener puntero a los espacios libres ya que de eso se encarga el Pascal a travs del tipo pointer. Cmo seran los otros procedimientos y funciones que implementan las operaciones posibles sobre una lista definida como en el Ejemplo 12.9? La condicin de lista vaca es fcil: si el acceso (acc) es igual a nil entonces no hay nada en la lista.
U.N.S.L. Argentina
105
Recursividad
La condicin de lista llena, o mejor dicho de cundo no hay ms lugar en la estructura soporte para seguir insertando, es cosa ahora de quien administra los espacios libres: el compilador Pascal a travs del tipo pointer. Debemos interrogar al compilador para saber si tiene especio libre para poder hacer una insercin. Esto es algo que es, en general, propio de cada compilador; por ejemplo en el compilador Borland Pascal for Windows, versin 7.0, las funciones GetFreeSpace o MemAvail, sirven para ste propsito. Cundo est el cursor fuera de la estructura (oos = true)? Esto sucede cuando el cursor (cur) es igual a nil. Cmo se hace avanzar el cursor? Esto se hace asignando al cursor el valor del puntero al siguiente del elemento apuntado por el cursor. Es decir hay que hacer cur := cur^.ps Por qu? Porque hay que hacer que cur tome el valor del puntero al siguiente (ps), para que apunte justamente al siguiente elemento. Como cur es una variable de tipo pointer, que apunta a un record de tipo unnodo, y ps tambin, basta asignar el valor de ps a cur. type unnodo = ^nodo; Para insertar hay que conseguir un nodo = record lugar libre, pidindoselo al vipd: char; administrador de los espacios libres: el ps : unnodo compilador Pascal, siendo que ste es end; el encargado a travs del tipo pointer ulista = record que estamos empleando. Esto se hace {acceso a la lista} usando el procedimiento estndar new. acc : unnodo; Como el nuevo elemento se inserta {cursor de la lista} entre dos elementos existentes o en el cur : unnodo; primer lugar (que equivale a insertarlo {cursor auxiliar de la lista} entre el acceso y el primer elemento) curaux : unnodo o despus del ltimo, hay que controlar end; de qu caso se trata. Ejemplo 12.9 Si es entre dos elementos habr que hacer que el elemento anterior (el que es apuntado por el cursor auxiliar curaux) apunte al nuevo y el nuevo apunte al corriente (que es apuntado por el cursor, cur), y luego hacer que el cursor apunte al nuevo. Una solucin es emplear una variable auxiliar para poder hacer todo esto. Para suprimir hay que hacer que el puntero al siguiente ps, del elemento anterior al apuntado por el cursor (que est apuntado por el cursor auxiliar curaux), apunte al elemento apuntado por el puntero al siguiente (ps) del elemento apuntado por el cursor (cur). Luego, hacer que el cursor (cur) apunte al elemento apuntado por el puntero al siguiente (ps) del elemento al que cur apunta (esto se parece bastante a la operacin de avanzar el cursor).
12.8 Casos particulares de recursin

Al emplear recursin se plantean algunos problemas que no pueden resolverse solamente con las definiciones de recursin como las hemos visto hasta ahora. Muchas veces las soluciones a estos problemas son provistas por estructuras propias de algunos lenguajes. En otros casos deben ser resueltos, si es posible, con las estructuras existentes del lenguaje empleado. Es importante, sin embargo poder reconocerlos para poder plantear su solucin. Veamos algunos de estos casos. Es de hacer notar que los ejemplos dados para ilustrar los distintos casos, a menos que se diga lo contrario, hacen uso de la definicin dada en el Ejemplo 12.9.
Inicializacin de la recursin
Muchas veces al programar y cuando debe emplearse una repeticin, es necesario realizar tareas previas, una sola vez. Por ejemplo la inicializacin de variables con algn valor especial inicial, etc. En la mayor parte de los lenguajes de programacin es imposible realizar esto dentro de la definicin recursiva, ya que estas deben realizarse una sola vez, antes de empezar la recursin. Si estas acciones estn dentro de la definicin se ejecutarn cada vez que el mdulo sea invocado.
U.N.S.L. Argentina
106
Recursividad
A menos que el lenguaje empleado provea algn mecanismo de inicializacin previa a la recursin esto puede resolverse de varias maneras: a) Poniendo, dentro del mdulo recursivo, una condicin que slo tenga efecto, sea verdadera, por ejemplo, en la primera invocacin y falsa en las subsiguientes. La condicin controla la ejecucin de las acciones que deben ser hechas una sola vez antes de que se realice efectivamente la recursin. Esta solucin no es muy buena ya que implica que dicha condicin ser evaluada cada vez que el mdulo sea invocado en cada ejecucin de la recursin. Adems el mdulo deber invocarse con un parmetro que permita evaluar la condicin. b) Pasando uno o ms parmetros con los valores iniciales necesarios. Esto permite inicializar el mdulo con distintos valores cada vez que es invocado, pero no es bueno cuando la inicializacin es siempre la misma, ya que agrega parmetros innecesarios. c) Empleando una o ms variables globales, que son inicializadas antes de la invocacin por primera vez al mdulo, fuera de este. Esta no es una buena solucin ya que implica que el mdulo tiene efectos secundarios que pueden pasar desapercibidos. d) Declarando un mdulo que envuelva al mdulo recursivo, es decir declarando el mdulo recursivo dentro de este otro mdulo, que es donde se realizan las tareas previas que sean necesarias y el primer llamado al mdulo recursivo. Por supuesto que este mdulo envolvente no es recursivo. Esta solucin no es posible cuando lo que se desea es poder inicializar el mdulo con distintos valores en cada invocacin. En este ltimo caso se deber emplear la solucin mencionada anteriormente de pasar estos valores iniciales por medio de parmetros al mdulo envolvente.
Actualizacin de valores entre llamadas

Algunas soluciones recursivas implican la necesidad de mantener, de una invocacin a otra, e inclusive de pasar de una llamada a otra, un valor (Ej. impresin y pasar nmero de pgina). Algunas soluciones posibles para este caso son: a) Pasar por direccin uno o ms parmetros, de acuerdo con las necesidades. Esto implica que el mdulo deber invocarse la primera vez con el o los parmetros con algn valor inicial razonable. Puede ser que se requiera que el mdulo tenga como parmetro el o los valores iniciales deseados. Es decir que de alguna manera el usuario del mdulo (quien lo invoca por primera vez) se encuentra involucrado con la forma en que el mdulo trabaja y debe pasar el o los valores iniciales deseados. Si por el contrario no se desea que el usuario del mdulo pase estos valores ya que los mismos son constantes (por ejemplo siempre hay que empezar de cero o uno, etc.) entonces, una solucin para esto es envolver al mdulo recursivo, declarndolo dentro de otro mdulo que es el que da a dichos parmetros sus valores iniciales e invoca al mdulo recursivo. Por supuesto que el mdulo que envuelve al recursivo no es recursivo. b) Usar una o ms, de acuerdo con las necesidades, variables de tipo esttica (hay lenguajes que permiten declarar una variable como esttica, es decir propia del mdulo, pero que mantiene su valor de una invocacin a otra del mdulo). c) Usar una o ms, de acuerdo con las necesidades, variables globales. Esta no es una buena solucin ya que implica que el mdulo tiene efectos secundarios que pueden pasar desapercibidos. Por ejemplo si tenemos las siguientes declaraciones: var c: char; lista: ulista; y queremos construir un mdulo recursivo que cuente cuantas ocurrencias del carcter que se encuentra en c hay en lista, ser necesario recorrer la lista desde el principio al fin contando cuantos caracteres iguales a c hay. La condicin de fin de la recursin ser el fin de la lista, pero entre invocacin e invocacin deberemos mantener el valor del contador que cuenta las ocurrencias de c. En el Ejemplo 12.10 damos una posible solucin. Vemos que la funcin contar tiene definida dentro de ella la funcin cuenta, que es la que tiene la solucin recursiva. La funcin contar es la que invoca a la funcin
U.N.S.L. Argentina
107
Recursividad
cuenta, inicializando tanto la lista (haciendo reset de ella) como el contador al invocar a la funcin cuenta con cero para el parmetro correspondiente al contador cont.
function contar(lis: ulista; c: char): integer; var x: integer; function cuenta(lis: ulista; var cont: integer; c: char): integer; var cc: char; begin { de cuenta } if oos(lis) then cuenta:= cont else begin copy(lis, cc); if c = cc then cont:= cont + 1; forward(lis); cuenta:= cuenta(lis, cont, c) end end; { de cuenta } begin { de contar } reset(lis); x:= 0; contar:= cuenta(lis, x, c) end; { de contar }
Ejemplo 12.10. Solucin recursiva en Pascal para contar ocurrencias, de un carcter dado, en una lista.
Recursin anidada
Cuando el problema a resolver requiere que la solucin tenga repeticiones anidadas, ya sea una o ms, este anidamiento debe reflejarse en la solucin recursiva. En este caso la solucin recursiva implica que debern definirse tantos mdulos recursivos como anidamientos sean necesarios. Un ejemplo es cuando se desea saber si en una lista de caracteres existe una lista determinada. Esta segunda lista puede ser de igual o distinta longitud. Por ejemplo si tenemos las siguientes declaraciones: var Lista_1, Lista_2: ulista; y queremos saber a travs de un mdulo que devolver true si la cadena de caracteres Lista_1 se encuentra dentro de la cadena de caracteres Lista_2. Para hacer esto hay que comparar las listas carcter a carcter empezando desde el primer carcter de Lista_2 y hasta el fin de Lista_1. Si no hubo completa igualdad entonces debe avanzarse un carcter en Lista_2 y volver a realizar la comparacin Esta comparacin debe hacerse hasta el fin de Lista_2. Como puede verse hay dos repeticiones: la primera es para cada uno de los elementos de Lista_2, la segunda es la que se hace para comparar los elementos de ambas listas. Esta segunda repeticin se hace cada vez que se hace una ejecucin de la primera repeticin. En el Ejemplo 12.11 puede verse una posible solucin. All vemos que buscar_cad no es recursiva y slo sirve como envoltorio para la invocacin de busca_en_Lis_2 que es la primera repeticin, la que a su vez invoca a compara que es la segundad repeticin. Para cada ejecucin de busca_en_Lis_2 se harn tantas de compara hasta que esta termine, que ser cuando llegue al fin de Lista_1 o cuando alguno de los elementos de ambas listas no sean iguales.
U.N.S.L. Argentina
108

function buscar_cad(Lis_1, Lis_2: ulista): boolean; function busca_en_Lis_2(Lis_1, Lis_2: ulista): boolean; function compara(Lis_1, Lis_2: ulista): boolean; var c1, c2: char; begin { de compara} if oos(Lis_1) then compara:= true else if oos(Lis_2) then compara:= false else begin copy(Lis_1, c1); copy(Lis_2, c2); if c1 = c2 then begin forward(Lis_1); forward(Lis_2); compara:= compara(Lis_1, Lis_2) end else compara:= false end end; { de compara } begin { de busca_en_Lis_2 } if (not oos(Lis_2)) then begin if compara(Lis_1, Lis_2) then busca_en_Lis_2:= true else if oos(Lis_2) then busca_en_Lis_2:= false else begin reset(Lis_1); forward(Lis_2); busca_en_Lis_2:= busca_en_Lis_2(Lis_1, Lis_2) end else busca_cad_1:= false end; { de busca_en_Lis_2 } begin { de buscar_cad } reset(Lis_1); reset(Lis_2); buscar_cad:= busca_en_Lis_2(Lis_1, Lis_2) end; { de buscar_cad }
Recursividad
Ejemplo 12.11. Solucin recursiva en Pascal para buscar la cadena de chars Lis_1 en la cadena de chars Lis_2.
U.N.S.L. Argentina
109
Apndice A - Tabla ASCII
AP DICE A
TABLA ASCII (AMERICA STA
Valor decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 Carcter NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI NUL DC1 DC2 DC3 DC4 NAK SYN ETB (CAN) (EM) (SUB) (ESC) Cursor derecha (FS) Cursor izquierda (GS) Cursor arriba (RS) Cursor abajo (US) Valor decimal 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 52 54 55 56 57 58 59 60 61 62 63
DARD CODE FOR I FORMATIO

Carcter Espacio (SP) ! # $ % & ( ) * + , . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? 110 Valor decimal 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 Carcter @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _
TERCHA GE)
Carcter a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
Valor decimal 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
U.N.S.L. Argentina
Apndice B: Extensiones al Pascal
AP DICE B EXTE SIO ES AL LE GUAJE PASCAL PARA EL MA EJO DE ESTRUCTURAS DE DATOS DI MICAS
Introduccin
Para poder manejar las estructuras de datos existen implementaciones en la mayor parte de los lenguajes de programacin, por ejemplo en el Pascal. Sin embargo la mayor parte de estos lenguajes de programacin solo implementan una sola de las estructuras de datos estticas: el arreglo. La generalidad de sta estructura y su fcil implementacin ya que las memorias de las computadoras ms comunes estn construidas como un arreglo, hacen que el arreglo sea la estructura de datos ms comnmente encontrada en los lenguajes de programacin corrientes. El Pascal no es excepcin, an cuando agrega, adems, el registro como estructura provista como estndar. Queda para los usuarios de estos lenguajes de programacin la tarea de implementar, con la ayuda del arreglo y del registro (cuando se provee), las otras estructuras, particularmente las dinmicas. Para facilitar la manipulacin de estructuras dinmicas presentamos aqu una extensin al lenguaje Pascal para manejo de estructuras de datos dinmicas. Para ello ser necesario prever tres aspectos relacionados con dicha manipulacin: Las declaraciones de los tipos de datos correspondientes y de las variables que podrn ser manipuladas en el programa, porque as lo exige la estructura de programacin del lenguaje Pascal. Los operadores que permitirn realizar las operaciones de insercin, supresin e inspeccin (que llamaremos copia) sobre las variables declaradas. Es de hacer notar que debern incluirse las operaciones que pueden realizarse sobre los cursores asociados a las listas uni y bi-direccionales, que permitan recorrer las mismas, para lo que ser necesario ingresar a ella para poder avanzar desde el primer elemento al ltimo, o en el caso de las bi-direccionales poder, tambin, retroceder, desde el ltimo al primero. Los predicados lgicos necesarios para conocer el estado en que se encuentra una estructura dada: si est o no vaca; y porque se trata de una implementacin en el mundo real, donde las cosas no son infinitas, poder saber si existe lugar o no (diremos, aunque no sea estrictamente correcto, que queremos saber si est llena la estructura) para poder insertar. Tambin necesitaremos saber la posicin donde se encuentra el cursor asociado a una lista, es decir, si al avanzar o retroceder (en las listas bi-direccionales) se encuentra todava en la lista o ha quedado fuera de la misma.
Como programar usando las extensiones

Para poder realizar programas empleando estructuras dinmicas (pilas, filas y listas) hay que poner, en el mismo directorio en que se realiza el programa, las unidades en Pascal (especialmente en Free Pascal) tda.ppw y tda.ow. En el programa hay que poner la sentencia <uses TDA;> adems de las otras unidades que se deseen emplear. La sintaxis correspondiente es la que se encuentra a continuacin. Por ejemplo: program prb_tda; uses TDA, crt; var p1, p2: stack_of_int; ... end.
U.N.S.L. Argentina
111
A. DASSO NTRODUCCIN A LA PROGRAMACIN NOTAS DE CLASE
APNDICE B: EXTENSIONES AL PASCAL
DEFI ICIO ES de tipos y DECLARACIO ES de variables

<tipos de estructuras>::= <pilas> | <filas> | <listas> <pilas>::= <pila de caracteres> | <pila de enteros> | <pila de reales> | <pila de booleanos> <pila de caracteres>::= stack_of_char <pila de enteros>::= stack_of_int <pila de reales>::= stack_of_real <pila de booleanos>::= stack_of_bool <filas>::= <fila de caracteres> | <fila de enteros> | <fila de reales> | <fila de booleanos> <fila de caracteres>::= queue_of_char <fila de enteros>::= queue_of_int <fila de reales>::= queue_of_real <fila de booleanos>::= queue_of_bool <listas>::= <listas uni-direccionales> | <listas bi-direccionales> <listas uni-direccionales>::= <lista uni-direccional de caracteres> | <lista uni-direccional de enteros> | <lista uni-direccional de reales> |<lista uni-direccional de booleanos> <lista uni-direccional de caracteres>::= ulist_of_char <lista uni-direccional de enteros>::= ulist_of_int <lista uni-direccional de reales>::= ulist_of_real <lista uni-direccional de booleanos>::= ulist_of_bool <listas bi-direccionales>::= <lista bi-direccional de caracteres> | <lista bi-direccional de enteros> | <lista bi-direccional de reales> |<lista bi-direccional de booleanos> <lista bi-direccional de caracteres>::= blist_of_char <lista bi-direccional de enteros>::= blist_of_int <lista bi-direccional de reales>::= blist_of_real <lista bi-direccional de booleanos>::= blist_of_bool <identificador de estructura> ::= <identificador> { de variable de estructura dinmica } <dato> ::= Es una constante o variable del tipo de la estructura. ota: Las ulist y blist tienen asociados, para cada una, un cursor propio a cada una de ellas, que permite las operaciones correspondientes. Ejemplo 1: type filareal = queue_of_real ; listau = ulist_of_char ; var pila : stack_of_char; uldechr : ulist_of_char; fil : queue_of_char; f : filareal ; ul : listau ; blista : blist_of_int; c: char; i: integer;
U.N.S.L. Argentina
112
A. DASSO NTRODUCCIN A LA PROGRAMACIN NOTAS DE CLASE
Atencin: Es conveniente, para evitar posibles errores, ejecutar el procedure init(<identificador de estructura>) A TES de emplear cada estructura. Ejemplo 2: init(ul);
OPERACIO ES sobre las estructuras

ota: Los ejemplos de las operaciones estn basados en las definiciones y declaraciones dadas en el Ejemplo 1.
I SERCIO
insert (<identificador de estructura>, <dato>)
PROCEDURE para insercin de un elemento en la estructura <identificador de estructura>, en la posicin que corresponda, con un valor <dato>. Ejemplo 3: insert(pila, d) ; { inserta el carcter d en el tope de pila } insert(pila, c) ; {inserta el contenido de la variable c en el tope de pila} insert(fil, h) ; { inserta el carcter h en la fila fil } insert(fil, c) ; { inserta el contenido de la variable c en la fila fil } insert(blista, 2) ; { inserta el entero 2 en el lugar apuntado por el cursor de la lista blista } insert(blista, i) ; { inserta el contenido de la variable i en el lugar apuntado por el cursor de la lista blista }
SUPRESIO
supres (<identificador de estructura>)
PROCEDURE para la supresin de un elemento en la estructura <identificador de estructura. Suprime la vipd del elemento. Ejemplo 4: supres(pila) ; {suprime el caracter que est en el tope de pila} supres(fil) ; {suprime el caracter que est en el primer lugar de fil} supres(blista) ; {suprime el elemento apuntado por el cursor de blista} supres(ul) ; {suprime el elemento apuntado por el cursor de ul }
COPIA (o inspeccin)
copy (<identificador de estructura>, <variable>)
PROCEDURE, que devuelve el valor de la vipd de un elemento en la estructura <identificador de estructura>, en <variable>, que es del tipo de la vipd que corresponda, en la posicin, de la estructura, que corresponda. Ejemplo 5: copy(pila, c); {copia el caracter que est en el tope de pila en la variable c } copy(fil, c); {copia el caracter que est en el primer lugar de fil en la variable c} copy(blista,i); {copia el elemento apuntado por el cursor de blista en la variable i} ota: Para las estructuras de tipo: stack: insert, supres y copy se hacen sobre el tope.
U.N.S.L. Argentina
113
A. DASSO NTRODUCCIN A LA PROGRAMACIN NOTAS DE CLASE queue: insert despus del ltimo; supres y copy sobre el primero.
ulist y blist: insert, supres, y copy se hacen sobre el elemento o en el lugar para insert apuntado por el cursor asociado a cada estructura, el que se ha colocado all empleando reset, forwards y/o backwards. Luego de un insert el cursor queda apuntando al nuevo elemento, es decir, el insertado. Para insertar en el primer lugar de la lista debe hacerse un reset previamente; o el cursor estar ya apuntando al primer elemento. Para insertar en el ltimo lugar de la lista oos = true. Luego de un supres el cursor queda apuntando al elemento siguiente al que se suprime (oos = true si el elemento suprimido era el ltimo). Luego de un copy el cursor queda apuntando al elemento al que apuntaba antes (el mismo). Para TODAS las estructuras: - insert solo debe ejecutarse si full = false sino produce un error en ejecucin. - supres y copy solo deben ejecutarse si empty = false sino producen un error en ejecucin.
OPERACIO ES sobre los cursores asociados a las ulist y blist

E TRAR a la ESTRUCTURA
reset (<identificador de estructura>)
PROCEDURE que coloca el cursor de una ulist o blist en el primer elemento. Ejemplo 6: reset(blista); {coloca el cursor de la lista apuntando al primer elemento}
RECORRER la ESTRUCTURA
Hacia adelante (forwards). Del primero al ltimo. forwards (<identificador de estructura>)
PROCEDURE que avanza el cursor de una ulist o blist al siguiente elemento. Ejemplo 7: forwards(blista) ; {avanza el cursor de la lista blista al siguiente elemento } forwards(ul) ; { avanza el cursor de la lista ul al siguiente elemento }
Hacia atrs (backwards). Del ltimo al primero, slo para las blist. backwards (<identificador de estructura>)
PROCEDURE que retrocede el cursor de una blist al elemento anterior. Ejemplo 8: backwards(blista) ; {retrocede el cursor de la lista al elemento anterior } ota: Estos procedure solo pueden ser ejecutados si oos = false sino producen un error en ejecucin.
PREDICADOS de control sobre las estructuras

VACIA
empty (<identificador de estructura>)
FUNCTION, de tipo boolean, que devuelve true si la estructura <identificador de estructura> no tiene elementos,
U.N.S.L. Argentina
114
A. DASSO NTRODUCCIN A LA PROGRAMACIN NOTAS DE CLASE sino false. Ejemplo 9:
if empty(ul) then writeln(Lista vaca) else writeln(Lista NO vaca) ;
LLE A
full (<identificador de estructura>)
FUNCTION, de tipo boolean, que devuelve true si la estructura soporte de la estructura <identificador de estructura>, est llena, es decir no hay lugar para almacenar nuevos elementos, sino false. Ejemplo 10: if full(pila) then writeln(Pila llena) else writeln(Pila NO llena);
FUERA de la estructura
oos (<identificador de estructura>)
FUNCTION (out of structure de una ulist o blist), de tipo boolean, que devuelve: true si, empleando forwards, se ha avanzado el cursor, asociado a la estructura, ms all del ltimo elemento de la estructura <identificador de estructura> (ulist o blist); o empleando backwards, se ha llevado el cursor asociado a la estructura por delante del primer elemento de la estructura <identificador de estructura>, (blist); sino false. Ejemplo 11: if oos(blista) then writeln(Cursor fuera de la lista) else writeln(Cursor NO est fuera de la lista) ;
U.N.S.L. Argentina
115

Apunte

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Apunte

Caricato da

Copyright:

Formati disponibili

Introduccin a la Programacin

Aristides Dasso Ana Funes

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes - Introduccin a la Programacin - Notas de Clase

CAPTULO 1 LAS COMPUTADORAS

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

1.2 Las partes de una computadora

Las partes internas

Unidad Central de Proceso

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

Unidades de medida de almacenamiento

Las partes externas

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

1.3 La informacin dentro de la computadora

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

1.5 El sistema operativo

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

g) Qu fro! h) La Ctedra de programacin. i) j) 3 + x = 16 x - 3y + 6 = 0

2.3 Operadores, conectivas o funtores

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

Figura 2.2. Tabla de verdad de la conjuncin

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

Figura 2.3. Tabla de verdad de la disjuncin (o) incluyente

. Sin embargo los smbolos ; son

Figura 2.4. Tabla de verdad de la disjuncin (o) excluyente

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

Figura 2.5. Tabla de verdad del condicional

Condicin suficiente y condicin necesaria

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

Figura 2.6. Tabla de verdad del bicondicional

Figura 2.8. Tabla de verdad de la negacin

2.4 Equivalencias lgicas

Identidad P V=P PF=P

A. Dasso, A. Funes ntroduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

3.2 Programacin de computadoras

3.3 Programacin y resolucin de problemas

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

3.4 El proceso de resolucin de problemas

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

Etapas de la resolucin de problemas

3.5 Los paradigmas de la programacin

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

CAPTULO 4 PROGRAMACI IMPERATIVA

Las etapas en la construccin de un programa

Con errores Prueba Compilacin

Sin errores A usar el programa!

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase

4.2 Definicin de los lenguajes de programacin

<frase> ::= <sujeto> <verbo> <objeto>

A. Dasso, A. Funes Introduccin a la Programacin Notas de Clase