LibroProgramacion PDF

Programacin y
Algoritmia
Un enfoque prctico y didctico
para el diseo de algoritmos
Lic. Oscar Ricardo Bruno, MDU
Agradecimientos
Para Cristi, Anto, Meli,
Euge, Gustavo, Nahuel, Esteban, Ornella, Yamila y
todos los estudiantes de UTN FRBA, USAL y el KRAUSE.
A mis amigos Carlos Tomassino, Jorge Muchnik, Marcelo Zanitti y Alicia Giorgetti y
Zulma Cataldi
A mis maestros Leopoldo Carranza,
Roberto Laborero,
Carlos Cullen
PROLOGO
Quien este prlogo escribe, lleva ms de cuarenta aos dedicado a la actividad
informtica cuando an ni siquiera se llamaba informtica! habindose iniciado
como programador y vivido lidiando en todos los rdenes con los proyectos de estas
tecnologas, tanto desde la docencia como desde la gestin, en la actividad de campo y
la consultora.
En aquellos lejanos tiempos, la programacin era desarrollada con criterios ms basados
en la intuicin y la creatividad que en las metodologas.
Cuando con el devenir de las dcadas las tecnologas fueron miniaturizndose y con
ello, consecuentemente, debieron bajarse los costos de los proyectos informticos, los
programas de computacin debieron a su vez volverse ms cercanos a las realidades de
las pocas, y hubieron mtodos que acercaron los costos de la programacin a los
nuevos tiempos y esfuerzos.
Y si bien esto fue llevndose a la prctica con la aparicin de las nuevas formas de la
Programacin Estructurada durante los aos ochenta, recin con la visin de Objetos,
sobre finales del milenio, puede aseverarse que estamos en el camino correcto, cual es el
de mezclar mtodo con creatividad.
El libro Programacin y Algoritmiaque hoy se presenta describe con claridad de
conceptos todo lo que debe ser tenido en cuenta para que un programa de cualquier
ndole y con independencia del lenguaje, termine exitoso.
Su autor, un estudioso y entraable amigo, el Magister en Docencia Universitaria y
Licenciado Oscar Ricardo Bruno, vuelca en l su larga experiencia en este campo, tanto
en la Universidad Tecnolgica Nacional, como en la Universidad del Salvador o la
Escuela Tcnica Nmero 1 Otto Krause, y permite al lector alcanzar un alto nivel de
aprendizaje del manejo metodolgico de la programacin con las mejores tcnicas.
Pero, tanto Bruno como quien esto escribe, sabemos la verdad revelada sobre el tema y
la debemos transmitir a los jvenes lectores: la programacin solo se aprende en
gerundio: esto es, programando. Por lo que debemos decirle que cuando Ud. se
encuentre ante el problema, sentado frente a la PC, recin all sabr cabalmente cmo
llevar el programa adelante, ya que las experiencias a veces muy ricas en contenido no son traspasables.
En Programacin y Algoritmia solo le suministramos las reglas: Ud deber ver cmo
las aplica para llevar su programa a buen puerto. Buena suerte!
________________
Lic Carlos Tomassino
Presidente de Fundesco y
Director de la Ctedra Proyecto en la UTN - Facultad Regional Buenos Aires
Contenido
Conceptos bsicos _____________________________________________________ 8
Introduccin:_______________________________________________________ 8
Informtica ________________________________________________________ 8
Programacin ______________________________________________________ 8
Partes de un programa_______________________________________________ 9
Dato ______________________________________________________________ 9
Abstraccin _______________________________________________________ 10
Modelizacion ______________________________________________________ 10
Precondicin ______________________________________________________ 10
Poscondicin ______________________________________________________ 10
Especificacin _____________________________________________________ 10
Lenguaje de programacin __________________________________________ 10
Del problema real a su solucin por computadoras ______________________ 10
Caractersticas de un algoritmo ______________________________________ 13
Propiedades de los algoritmos ________________________________________ 14
Eficiencia de un algoritmo ___________________________________________ 14
Complejidades ms comunes_________________________________________ 15
Lxico y algoritmo _________________________________________________ 15
Estructura de un algoritmo __________________________________________ 15
Proceso Computacional _____________________________________________ 16
Representaciones grficas de algoritmos__________________________________ 21
Diagrama de Nassi-Sneiderman ______________________________________ 21
Diagramas de Jackson ______________________________________________ 21
Diagramas de Lindsay.______________________________________________ 22
Llaves de Warniel __________________________________________________ 23
Notacin Algoritmica _______________________________________________ 23
Asignacin - Control Iteracin ________________________________________ 24
Introduccin:______________________________________________________ 24
Asignacin, secuenciacin y anlisis de casos ___________________________ 24
Asignacin. _______________________________________________________ 24
Anlisis de casos ___________________________________________________ 25
La necesidad de iterar ______________________________________________ 29
Composiciones iterativas ____________________________________________ 30
Composiciones iterativas No Exactas __________________________________ 31
Composiciones iterativas Exactas _____________________________________ 31
Recursividad ______________________________________________________ 33
Iteracin vs. Recursion______________________________________________ 34
Algoritmos que utilizan secuencias ____________________________________ 35
Estilos de Indentacin ______________________________________________ 40
Acciones y Funciones _________________________________________________ 42
Introduccin ______________________________________________________ 42
Modularizacion ____________________________________________________ 42
Mdulos __________________________________________________________ 42
Alcance de los datos ________________________________________________ 43
Datos locales y globales _____________________________________________ 43
Ocultamiento y proteccin de datos ___________________________________ 43
Parmetros _______________________________________________________ 43
Integridad de los datos ______________________________________________ 43
Proteccin de datos_________________________________________________ 44
Uso de parmetros para retornar valores ______________________________ 44
Utilidad del uso de parmetros _______________________________________ 44
Reusabilidad ______________________________________________________ 44
Acciones __________________________________________________________ 44
Utilizacin de acciones ______________________________________________ 44
Acciones con parmetros ____________________________________________ 45
Abstraccin y acciones ______________________________________________ 45
Tipos de Parmetros________________________________________________ 46
Beneficios del uso de acciones ________________________________________ 47
Funciones_________________________________________________________ 47
Estructuras Enlazadas_________________________________________________ 49
Introduccin ______________________________________________________ 49
Estructuras enlazadas vs. estructuras indexadas ________________________ 49
Estructuras enlazadas con asignacin dinmica en memoria ______________ 49
El tipo de dato Puntero______________________________________________ 51
Acceso a datos mediante apuntadores _________________________________ 53

Tipos de datos autorreferenciados o recursivos__________________________ 54
Estructuras de datos dinmicas lineales________________________________ 55
El tipo pila ________________________________________________________ 55
Insertar elemento en una pila:________________________________________ 57
Desapilar: leer y eliminar un elemento ________________________________ 57
El tipo cola________________________________________________________ 58
Aadir un elemento Encolar: ________________________________________ 58
Leer un elemento de una cola Eliminar primero: ________________________ 59
El tipo lista________________________________________________________ 59
Listas simplemente enlazadas ________________________________________ 59
Eliminar elementos en una lista ______________________________________ 60
Algoritmo de insercin ______________________________________________ 62
Listas circulares ___________________________________________________ 64
Operaciones bsicas con listas circulares _______________________________ 65
Aadir un elemento ________________________________________________ 65
Eliminar un elemento de una lista circular _____________________________ 66
Listas doblemente enlazadas _________________________________________ 70
Operaciones bsicas con listas doblemente enlazadas ____________________ 70
Aadir un elemento ________________________________________________ 70
Eliminar un elemento de una lista doblemente enlazada __________________ 73
A modo de sntesis con estructuras enlazadas ___________________________ 76
ALGORITMOS PUNTUALES __________________________________________ 77
Acciones y funciones para vectores____________________________________ 77
Acciones y funciones para archivos ___________________________________ 86
Acciones y funciones para pilas_______________________________________ 90
Acciones y funciones para Colas ______________________________________ 91
Acciones y funciones para Listas Ordenadas enlazadas ___________________ 92
Acciones y funciones para arboles ___________________________________ 101
Inserciones en arboles AVL _________________________________________ 106
Funciones recursivas ______________________________________________ 106
Archivos en pascal ________________________________________________ 109
Ejemplo en C con aplicaciones de estructuras enlzadas __________________ 114
ANEXO 1 Representaciones grficas de algoritmos________________________ 116
Diagrama de Nassi-Sneiderman _____________________________________ 116
Diagramas de Jackson _____________________________________________ 116

Diagramas de Lindsay._____________________________________________ 117
Llaves de Warniel _________________________________________________ 118
Notacin Algoritmica ______________________________________________ 118
Equivalencias entre notacin algortmica y lenguajes de programacin ____ 119
Estilos de Indentacin _____________________________________________ 119
BIBLIOGRAFIA ____________________________________________________ 121
Conceptos bsicos
Objetivos de aprendizaje
Dominando los temas del presente capitulo Usted podr.
1. Conocer la terminologa propia de la disciplina.
2. Definir y comprender claramente conceptos especficos muchas veces mal
definidos
3. Comprender el valor de la abstraccin.
4. Dar valor a la eficiencia en las soluciones
5. Introducirse en la notacin algortmica y a la forma e encarar los problemas de
programacin
Introduccin:
Se introducen conceptos fundamentales de algoritmia y programacin, los que servirn
de base para el desarrollo de los temas a trataren materias de algoritmos y estructurad e
datos.
Informtica
Disciplina del estudio sistematizado de los procesos algortmicos que describen y
transforman informacin, su teora, anlisis, diseo, eficiencia, implementacin y
aplicacin.
La informtica es una disciplina cientfica, matemtica y una ingeniera; tiene tres
formas de pensar propias: Teora, abstraccin y diseo.
Las tres se complementan para la resolucin de la mayora de los problemas.
Teora: Con el pensamiento terico se describen y prueban relaciones.
Abstraccin: Recoleccin de datos y formulacin de un modelo, se eliminan los
detalles irrelevantes.
Diseo: se tienen en cuenta requisitos, especificaciones y se disean o analizan
mecanismos para resolver problemas. Supone llevar a la prctica los resultados
tericos.
Programacin
La programacin es una actividad transversal asociada a cualquier rea de la
informtica, aunque es la ingeniera del software el rea especfica que se ocupa de la
creacin del software.
En principio la programacin se vea como un arte, solo era cuestin de dominar un
lenguaje de programacin y aplicar habilidades personales a la resolucin de problemas,
casi en forma artesanal. El software era visto como algo desarrollado a travs de la
intuicin sin la utilizacin de mtodos de diseo con tcnicas para proceder en forma
sistemtica y sin ningn control de su desarrollo. Con el reconocimiento de la
complejidad del desarrollo del software naci la ingeniera del software.
Se considero que al igual que cualquier otra disciplina la creacin de software deba ser
reconocida como una actividad de ingeniera que requera la aplicacin de slidos
principios cientficos.
La ingeniera del software es la disciplina que se ocupa de la aplicacin del
conocimiento cientfico al diseo y construccin de programas de computacin y a
todas las actividades asociadas de documentacin, operacin y mantenimiento, lo que
proporciona un enfoque sistemtico.
La programacin es una actividad en la que la creatividad juega un rol primordial
Programa:
Conjunto de instrucciones, ejecutables sobre una computadora, que permite cumplir una
funcin especifica. Se asocia al programa con una determinada funcin o requerimiento
a satisfacer por la ejecucin del conjunto de instrucciones que lo forman. En general
alcanzan su objetivo en tiempo finito, aunque hay excepciones, por ejemplo los
programas de control de un sistema de alarma poseen requerimiento de tiempo infinito.
Un programa sin errores que se ejecuta puede no ser correcto si no cumple con los
requerimientos.
Definicin
Programa: conjunto de instrucciones no activas almacenadas en un computador, se
vuelve tarea a partir de que se selecciona para su ejecucin y permite cumplir una
funcin especfica. Un proceso es un programa en ejecucin.
En principio las tareas ms importantes a la que se enfrenta quien debe escribir
programas en computadoras son:
1. Definir el conjunto de instrucciones cuya ejecucin ordenada conduce a la
solucin.
2. Elegir la representacin adecuada de los datos del problema.
La funcin esencial del especialista informtico es explotar el potencial de las
computadoras para resolver situaciones del mundo real. Para esto debe analizar los
problemas del mundo real, ser capaz de sintetizar sus aspectos principales y poder
especificar la funcin objetivo que se desee. Posteriormente debe expresar la solucin
en forma de programa, manejando los datos del mundo real mediante una
representacin valida para una computadora.
Partes de un programa
Los componentes bsicos son las instrucciones y los datos. Las instrucciones o
sentencias representan las operaciones que se ejecutaran al interpretar el programa.
Todos los lenguajes de programacin tienen un conjunto mnimo de operaciones que
son las de asignacin, seleccin e iteracin. Un lenguaje con solo estas tres
instrucciones permite escribir cualquier algoritmo.
Los datos son valores de informacin de los que se necesita disponer, en ocasiones
transformar para ejecutar la funcin del programa.
Los datos estn representados simblicamente por un nombre que se asocia con una
direccin nica de memoria.
El contenido de la direccin de memoria correspondiente a un dato constante se asigna
solo una vez y solo puede ser modificado en una nueva compilacin. En cambio el
contenido o valor de la direccin de memoria correspondiente a un dato variable puede
ser asignado o modificado en tiempo de ejecucin.
Un programa se corresponde con una transformacin de datos. A partir de un contexto
determinado por las precondiciones.
El programa transforma la informacin debiendo llegar al resultado esperado
produciendo el nuevo contexto caracterizado por las poscondiciones.
Dato
Representacin de un objeto el mundo real mediante el cual se pueden modelizar
aspectos de un problema que se desea resolver con un programa en una computadora.
Definicin
Dato representacin de un objeto el mundo real mediante el cual se pueden modelizar
aspectos de un problema que se desea resolver con un programa en una computadora.
<dato> -> <objeto><atributo><valor>
Abstraccin
Proceso de anlisis del mundo real con el propsito de interpretar los aspectos
esenciales de un problema y expresarlo en trminos precisos.
Modelizacion
Abstraer un problema del mundo real y simplificar su expresin, tratando de encontrar
los aspectos principales que se pueden resolver, requerimientos, los datos que se han de
procesar y el contexto del problema.
Precondicin
Informacin conocida como verdadera antes de iniciar el programa.
Poscondicin
Informacin que debiera ser verdadera al cumplir un programa, si se cumple
adecuadamente el requerimiento pedido.
Especificacin
Proceso de analizar problemas del mundo real y determinar en forma clara y concreta el
objetivo que se desea. Especificar un problema significa establecer en forma univoca el
contexto, las precondiciones
el resultado esperado, del cual se derivan las
poscondiciones.
Lenguaje de programacin
Conjunto de instrucciones permitidas y definidas por sus reglas sintcticas y su valor
semntico para la expresin de soluciones de problemas.
Del problema real a su solucin por computadoras
Analizando un problema del mundo real se llega a la modelizacin del problema por
medio de la abstraccin.
A partir del modelo se debe elaborar el anlisis de la solucin como sistema, esto
significa la descomposicin en mdulos. Estos mdulos deben tener una funcin bien
definida.
La modularizacin es muy importante y no solo se refiere a los procesos a cumplir, sino
tambin a la distribucin de los datos de entrada, salida y los datos intermedios
necesarios para alcanzar la solucin.
Estudio de los datos del problema.
Cada mdulo debe tener un proceso de refinamiento para expresar su solucin en forma
ordenada, lo que llevara a la construccin del algoritmo correspondiente.
A partir de los algoritmos se pueden escribir y probar programas en un lenguaje
determinado y con un conjunto de datos significativos.
Etapas de resolucin de problemas con computadoras.
1. Anlisis del problema: en su contexto del mundo real.
2. Diseo de la solucin: Lo primero es la modularizacin del problema, es decir la

descomposicin en partes con funciones bien definidas y datos propios
estableciendo la comunicacin entre los mdulos.
3. Especificacin del algoritmo: La eleccin adecuada del algoritmo para la
funcin de cada modulo es vital para la eficiencia posterior.
4. Escritura del programa: Un algoritmo es una especificacin simblica que debe
convertirse en un programa real sobre un lenguaje de programacin concreto.
5. Verificacin: una vez escrito el programa en un lenguaje real y depurado los
errores sintcticos se debe verificar que su ejecucin conduzca al resultado
deseado con datos representativos del problema real.
Programacin modular programacin estructurada
Se dice modular porque permite la descomposicin del problema en mdulos y
estructurada solo permite la utilizacin de tres estructuras: Asignacin, seleccin,
repeticin.
Algoritmo
El termino algoritmo es en honor del matemtico rabe del siglo IX, Abu Jafar
Mohamed ibn Musa Al Khowrizm. Refiere conjunto de reglas, ordenadas de forma
lgica, finito y preciso para la solucin de un problema, con utilizacin o no de un
computador.
En la actualidad al trmino se lo vincula fuertemente con la programacin, como paso
previo a la realizacin de un programa de computacin aunque en realidad es una
metodologa de resolucin presente en muchas de las actividades que se desarrolla a lo
largo de la vida.
Desde los primeros aos de escuela se trabaja con algoritmos, en especial en el campo
de las matemticas. Los mtodos utilizados para sumar, restar, multiplicar y dividir son
algoritmos que cumplen perfectamente las caractersticas de precisin, finitud,
definicin y eficiencia.
Para que el algoritmo pueda ser fcilmente traducido a un lenguaje de programacin y
luego ser ejecutado la especificacin debe ser clara, precisa, que pueda ser interpretada
con precisin y corresponda a pocas acciones, si esto no ocurre ser necesario acudir a
desarrollar un mayor nivel de refinamiento.
La utilizacin de refinamientos sucesivos es lo que permite alcanzar la solucin modular
que se propone.
Diseo modular, entonces, es la aplicacin del criterio de refinamientos sucesivos,
partiendo de un plan de accin, determinando que hacer, por aplicacin de los
conocimientos estratgicos de resolucin pasando luego al como hacerlo con los
conocimientos tcticos para la realizacin del algoritmo.
La programacin de algoritmos representa un caso de resolucin de problemas que
requiere representacin mental del mundo real, adaptacin para tener una solucin
computable y criterio para elegir una alternativa eficiente de implementacin.
Cuando se analiza un problema, particularmente de programacin, y ste es difcil de
describir, el plan de accin recomendable para alcanzar la solucin es comenzar
trazando un esbozo de las formas ms gruesas, para que sirvan de andamio a las dems;
aunque algunas de ellas se deban cambiar posteriormente. Despus, se agregan los
detalles, (obtenindose el algoritmo refinado), para dotar a estos esqueletos de una
estructura ms realista.
Durante la tarea de integracin final, se descartan aquellas primeras ideas provisionales

que ya no encajan en la solucin. Por lo que, hasta que no se haya visto el conjunto
global es imposible encontrarle sentido a ninguna de las partes por s solas.
Siempre es mejor explicar un misterio en trminos de lo que se conoce, pero cuando
esto resulta difcil de hacer, se debe elegir entre seguir tratando de aplicar las antiguas
teoras, o de descartarlas y probar con otras nuevas. Siguiendo este anlisis, se define
como reduccionistas a aquellas personas que prefieren trabajar sobre la base de ideas
existentes, y como renovadores a los que les gusta impulsar nuevas hiptesis. En
programacin debe encontrarse un equilibrio entre ambas posturas.
La programacin como toda actividad que requiere creatividad necesita que se produzca
un salto mental que se puede sintetizar como seala David Perkins en:
1. Larga bsqueda, se requiere esfuerzo en analizar y buscar.
2. Escaso avance aparente: el salto mental sobreviene tras un avance que parece
escaso o no muy evidente, pero sobreviene.
3. Acontecimiento desencadenante: El tpico proceso de hacer clic comienza con
un acontecimiento que lo desencadena.
4. Chasquido cognitivo: De pronto aparece la solucin la que sobreviene con
rapidez que hace que las piezas encajen con precisin, aun cuando sea necesario
todava ajustar algunos detalles. Pero la idea generadora apareci.
5. Transformacin. Este avance nos va modificando nuestro mundo mental.
En sntesis, la practica del salto de pensamiento requiere en primer lugar de buscar
analogas, en segundo lugar juegan un papel importante las conexiones lgicas,
formulacin de una pregunta crucial ocupa un papel decisivo. El repertorio de acciones
tras el salto del pensamiento se expande para incluir no solo la analoga sino una
extrapolacin lgica y la formulacin de la pregunta adecuada
Para encontrar una solucin muchas veces se necesita desplazarse bastante por el
entorno adecuado. Conforme a esto Thomas Edison declaro que la invencin significa
99% de transpiracin y 1% de inspiracin, en contraposicin con Platn que sostena
que las soluciones aparecen por inspiracin divina.
Muchos problemas son razonables, cabe razonarlos paso a paso para alcanzar la
solucin. Otros son irrazonables no se prestan a un a reflexin por etapas.
Definicin
Algoritmo
Especificacin rigurosa (debe expresarse en forma univoca) de la secuencia de pasos,
instrucciones, a realizar sobre un autmata para alcanzar un resultado deseado en un
tiempo finito. Esto ltimo supone que el algoritmo empieza y termina, en el caso de los
que no son de tiempo finito (ej. Sistemas en tiempo real) deben ser de nmero finito de
instrucciones.
En definitiva un algoritmo es una especificacin ordenada de la solucin a un problema
de la vida real. Son el fundamento de la programacin de computadores en el paradigma
de programacin imperativo.
Bajo este paradigma desarrollar un programa significa indicarle al computador, con
precisin, sin ambigedad y en un lenguaje que este pueda entender, todos y cada uno
de los pasos que debe ejecutar para lograr el objetivo propuesto.
Previo a la traduccin en un lenguaje de programacin es necesario poder entender el
problema, conocer las pre condiciones, establecer cual debe ser la pos condicin, o
aquello que debe ser cierto al finalizar la ejecucin del algoritmo, en definitiva entender
claramente Que es lo que se debe hacer para luego avanzar en Como hacerlo. Aqu
debe utilizarse todas las herramientas al alcance de la mano para el desarrollo del
algoritmo como paso previo a la solucin del problema por el computador.
Existen varias tcnicas para representar formalmente un algoritmo, una descriptiva
llamada pseudo cdigo, y otras graficas como los diagrama de flujo, diagrama Nassi
Sneiderman, Diagramas de Lindsay, diagramas de Jackson, entre otros, en este caso se
presentara una notacin algortmica similar a la presentada por Piere Scholl en el texto
Esquemas algortmicos fundamentales: Secuencia e iteracin.
Definicin
Algoritmo:
Secuencia finita de instrucciones, reglas o pasos que describen en forma precisa las
operaciones que una computadora debe realizar para llevar a cabo una tarea en tiempo
finito [Knuth, 1968].
Descripcin de un esquema de comportamiento expresado mediante un repertorio finito
de acciones y de informaciones elementales, identificadas, bien comprendidas y
realizables a priori. Este repertorio se denomina lxico[Scholl, 1988].
Esta formado por reglas, pasos e instrucciones.
Las reglas especifican operaciones.
La computadora es el agente ejecutor.
La secuencia de reglas y la duracin de la ejecucin son finitas.
Caractersticas de un algoritmo
Un algoritmo debe tener al menos las siguientes caractersticas:
1. Ser preciso: esto significa que las operaciones o pasos del algoritmo deben
desarrollarse en un orden estricto, ya que el desarrollo de cada paso debe
obedecer a un orden lgico.
2. Ser definido. Ya que en el rea de programacin, el algoritmo es el paso
previo fundamental para desarrollar un programa, es necesario tener en cuenta
que el computador solo desarrollar las tareas programadas y con los datos
suministrados; es decir, no puede improvisar y tampoco inventar o adivinar el
dato que necesite para realizar un proceso. Por eso, el algoritmo debe estar
plenamente definido; esto es, que cuantas veces se ejecute, el resultado depende
estrictamente de los datos suministrados. Si se ejecuta con un mismo conjunto
de datos de entrada, el resultado deber ser siempre el mismo.
3. Ser finito: esta caracterstica implica que el nmero de pasos de un algoritmo,
por grande y complicado que sea el problema que soluciona, debe ser limitado.
Todo algoritmo, sin importar el nmero de pasos que incluya, debe llegar a un
final. Para hacer evidente esta caracterstica, en la representacin de un
algoritmo siempre se incluyen los pasos inicio y fin.
4. Presentacin formal: para que el algoritmo sea entendido por cualquier persona
interesada es necesario que se exprese en alguna de las formas comnmente
aceptadas; pues, si se describe de cualquier forma puede no ser muy til ya que
solo lo entender quien lo dise. Las formas de presentacin de algoritmos
son: el pseudo cdigo, diagrama de flujo y diagramas de Nassi/Schneiderman,
entre otras. En esta publicacin se propondr una notacin algortmica y se
darn las equivalencias entre la propuesta y las existentes y tambin con las
sentencias de los lenguajes de programacin, en particular Pascal y C.
5. Correccin: el algoritmo debe ser correcto, es decir debe satisfacer la necesidad
o solucionar el problema para el cual fue diseado. Para garantizar que el
algoritmo logre el objetivo, es necesario ponerlo a prueba; a esto se le llama

verificacin o prueba de escritorio.
6. Eficiencia: hablar de eficiencia o complejidad de un algoritmo es evaluar los
recursos de cmputo que requiere para almacenar datos y para ejecutar
operaciones frente al beneficio que ofrece. En cuanto menos recursos requiere
ser ms eficiente el algoritmo.
La vida cotidiana est llena de soluciones algortmicas, algunas de ellas son tan
comunes que no se requiere pensar en los pasos que incluye la solucin. La mayora de
las actividades que se realizan diariamente estn compuestas por tareas ms simples que
se ejecutan en un orden determinado, lo cual genera un algoritmo. Muchos de los
procedimientos utilizados para desarrollar tareas cotidianas son algortmicos, sin
embargo, esto no significa que todo lo que se hace est determinado por un algoritmo.
El primer paso en el diseo de un algoritmo es conocer la temtica a tratar, el segundo
ser pensar en las actividades a realizar y el orden en que deben ejecutarse para lograr el
objetivo, el tercero y no menos importante es la presentacin formal.
Propiedades de los algoritmos
1. Especificacin precisa de la entrada: El algoritmo debe dejar claro el nmero y
tipo de datos de entrada y las condiciones iniciales que deben cumplir esos
valores de entrada para conseguir que las operaciones tengan xito.
2. Especificacin precisa de cada instruccin: cada etapa del algoritmo debe estar
definida con precisin, no debe haber ambigedades sobre las acciones que se
deben ejecutar en cada momento.
3. Un algoritmo debe ser exacto y correcto: Un algoritmo se espera que resuelva un
problema y se debe poder demostrar que eso ocurre. Si las condiciones de
entrada se cumplen y se ejecutan todos los pasos el algoritmo entonces debe
producir la salida deseada.
4. Un algoritmo debe tener etapas bien definidas y concretas, un nmero finito de
pasos, debe terminar y debe estar claro la tarea que el algoritmo debe ejecutar.
5. Debe ser fcil de entender, codificar y depurar.
6. Debe hacer uso eficiente de los recursos de la computadora
Finitud: en longitud y duracin.
Precisin: Determinar sin ambigedad las operaciones que se deben ejecutar.
Efectividad: las reglas pueden ejecutarse sin el ordenador obtenindose el mismo
resultado.
Generalidad: Resolver una clase de problema y no un problema particular.
Entradas y salidas: puede tener varias entradas pero una sola salida, el resultado que se
debe obtener.
Eficiencia de un algoritmo
Se pueden tener varias soluciones algortmicas para un mismo problema, sin embargo el
uso de recursos y la complejidad para cada una de las soluciones puede ser muy
diferente.
La eficiencia puede definirse como una mtrica de calidad de los algoritmos asociada
con la utilizacin optima de los recursos del sistema de cmputo donde se ejecutara el
algoritmo, su claridad y el menor grado de complejidad que se pueda alcanzar. Hacer
todo tan simple como se pueda, no ms (Albert Einstein).
La eficiencia como factor espacio temporal debe estar estrechamente relacionada con la
buena calidad, el funcionamiento y la facilidad del mantenimiento.
Medidas de eficiencia para N = 10.0000

Eficiencia
Logartmica
Log 2 N
Lineal
N
Logartmica lineal
N * Log 2 N
Cuadrtica
N2
Poli nmica
Nk
Exponencial
2N
Iteraciones
14
10.000
140.000
10.000 2
10.000 K
2 10.000
Tiempo estimado
Microsegundos
0.1 segundo
2 segundos
15-20 minutos
Horas
Inmedible
Complejidades ms comunes
1. Complejidad constante: se expresa como O(1). Se encuentra en algoritmos sin
ciclos, por ejemplo en un intercambio de variables.
2. Complejidad logartmica: Es una complejidad eficiente, la bsqueda binaria
tiene esta complejidad.
3. Complejidad lineal: se encuentra en los ciclos simples.
4. Complejidad logartmica lineal: Los mejores algoritmos de ordenamiento tienen
esta complejidad.
5. Complejidad cuadrtica: Aparece en el manejo de matrices de dos dimensiones,
generalmente con dos ciclos anidados.
6. Complejidad cbica: Aparece en el manejo de matrices de tres dimensiones,
generalmente con tres ciclos anidados.
7. Complejidad exponencial: es la complejidad de algoritmos recursivos.
Lxico y algoritmo
Para escribir un algoritmo deben seguirse un conjunto de pasos bsicos
1. Comprender el problema
2. Identificar los elementos a incluir en el lxico: constantes, tipos, variables y
acciones.
3. Encontrar la forma de secuenciar las acciones para obtener el resultado, esto es,
alcanzar las poscondiciones a partir de un estado inicial que cumple con la
precondicin. Para establecer el orden de las acciones los lenguajes de
programacin proporcionan mecanismos de composicin: Secuenciacin,
anlisis de casos, iteracin y recursion.
4. Al organizar las acciones en el tercer paso puede ocurrir que se detecte que
faltan elementos en el lxico o que algn aspecto del problema no ha sido bien
comprendido lo cual requerira volver a los pasos anteriores.
5. Nunca la solucin aparece en el primer intento, en general aparece en un proceso
cclico, entonces se debe:
6. Escribir el lxico,
a. escribir la primera versin,
b. incluir en el lxico nuevos elementos que faltaban,
c. escribir la nueva versin del algoritmo y as sucesivamente
Estructura de un algoritmo
LEXICO {Lxico Global del algoritmo}
{Declaracin de tipos, constantes, variables y acciones}
Accin 1
PRE {Precondicin de la accin 1}
POS {Poscondicin de la accin 1}
LEXICO {Lxico local, propio de la accin 1}
Declaraciones locales
ALGORITMO {Implementacin de la accin 1}
{Secuencia de instrucciones de la accin 1}
FIN {Fin implementacin algoritmo de la accin 1}
ALGORITMO
PRE {Precondicin del algoritmo principal}
POS {Poscondicin del algoritmo principal}
{Secuencia de instrucciones del algoritmo principal}
FIN {Fin del algoritmo principal}
Proceso Computacional
Se refiere a un algoritmo en ejecucin. La ejecucin de las instrucciones origina una
serie de acciones sobre elementos de memoria que representan informacin manejada
por el algoritmo. A nivel algortmico se asigna un nombre a cada informacin de modo
de manejar un par nombre-valor para cada informacin.
Una variable representa alguna entidad del mundo real, relevante para el problema que
se quiere resolver. El efecto que producen las acciones del proceso sobre las variables
produce cambio de estados o de sus valores.
Definiciones
Programa: Algoritmo escrito en un lenguaje cuyas instrucciones son ejecutables por
una computadora y que estn almacenados en un disco.
Tarea: Un programa se vuelve tarea a partir del momento que se lo selecciona para su
ejecucin y hasta que esta termina.
Proceso: programa en ejecucin, se ha iniciado pero an no ha finalizado.
Lenguajes de programacin: notacin que permite escribir programas a mayor nivel
de abstraccin que los lenguajes de mquina. Sus instrucciones deben ser traducidas a
lenguaje de mquina.
Lenguaje de mquina: Instrucciones que son ejecutables por el hardware de una
computadora.
Paradigmas de programacin
Paradigma: Coleccin de conceptos que guan el proceso de construccin de un
programa. Estos conceptos controlan la forma en que se piensan y formulan los
programas.
Imperativo Procedural Objetos.
Declarativo Funcional Lgico.
Dato Informacin Conocimiento
Dato: <objeto><atributo><valor> sin interpretar.
Informacin: aade significado al dato.
Conocimiento: Aade propsito y capacidad a la informacin. Potencial para generar
acciones.
Problema
Enunciado con una incgnita, la solucin es encontrar el valor de esa incgnita.
Problema computacional o algortmico: tarea ejecutada por una computadora con una
especificacin precisa de los datos de entrada y de los resultados requeridos en funcin
de estos.
Clase de problemas
No computables: No existe un algoritmo.
Computables
Tratables: Existe un algoritmo eficiente.
Intratable: No existe algoritmo eficiente.
Expresiones Sentencias Lxico
Expresiones: secuencia de operadores y operandos que se reduce a un solo valor.
Sentencias: accin produce un efecto, puede ser primitiva o no primitiva.
Lxico: Descripcin del conjunto de acciones e informaciones a partir de la cual se
expresa el esquema de comportamiento del algoritmo.
Pasos para resolver un algoritmo
Comprender el problema.
Identificar informacin y acciones a incluir en el lxico (constantes, tipos, variables y
acciones).
Encontrar un camino de secuenciar las acciones para obtener el resultado, es decir para
alcanzar la poscondicin a partir del estado inicial que cumple con la precondicin.
Acciones primitivas y derivadas
Acciones primitivas: Incorporadas por el lenguaje.
Acciones derivadas: realizadas mediante la combinacin de acciones primitivas con el
objeto de desarrollar una tarea en particular. Son complementarias y pueden ser
desarrolladas por el programador.
Estructura de un algoritmo
Accin 1
ALGORITMO
Resumen:
En el presente capitulo se introdujeron trminos y frases de la disciplina en estudio.
Se abordo el problema desde un punto de vista conceptual definiendo con precisin
trminos y frases para evitar ambigedades. Se puso especial nfasis en la necesidad de
pensar las soluciones antes de escribir cdigo. Se establecieron cuales son los pasos que
deben seguirse para una solucin correcta de problemas y cuales son los problemas que
pueden tratarse en forma algortmica. Se defini cuales son las caractersticas deseables
de los algoritmos y se introdujo el concepto de eficiencia de modo de hacer, tal como
recomendaba Albert Enstein, las cosas tan simple como se pueda.
Se introdujo, adems una representacin sem. formal para la descripcin de los
algoritmos
Representaciones grficas de algoritmos

Diagrama de Nassi-Sneiderman
Condicin 1
T
Accin 1
Accin 5
Accin 2
Mientras condicin 3
Condicin 2
T
Accin 6
F
Accin 3
Accin 7
Accin 8
Accin 9
Accin 4
Accin 10
Accin 11
Accin 12
Repetir hasta condicin 4
Diagramas de Jackson
Diagramas de Lindsay.
PASCAL
DIAGRAMA DE DETALLE
Variable expresin
Variable = expresin
READ (var1, var2,....var n)
var1, var2,....
WRITELN var 1 var 2

(
, ..... )
WRITE
liter1 liter2
var 1
liter1
IF condicin
THEN
sentencia 1
ELSE
sentencia 2
,....
liter2
Condicin
Instruccin 1
Instruccin 2
Condicin
WHILE condicin
DO
sentencia
Instruccin
REPEAT
sentencia;
:
:
sentencia n
UNTIL condicin
FOR variable: expres1
var 2
Instruccin 1
:
:
Instruccin n
Condicin
TO
expres2
DOWNTO
Var: exp1, exp2
Instruccin
DO sentencia
CASE expresin
OF
const1....... const n : instruccin1
:
:
const1...... const p : instruccin m
END
Cualquier sentencia puede ser reemplazada por
un bloque:
BEGIN
sentencias 1;
:
:
sentencias n
END
Expresin
Const1... Const n
Const1... Const p
Instruccin1
Instruccin m
Correspondiendo en el diagrama de detalle

la secuencia:
instruccin 1;
:
:
instruccin n
Llaves de Warniel
HacerUnaCosa)
Si
Condicin
Exclusin
No
1
Algoritmo
Case
Ordinal
Mientras
Condicin
HacerOtraCosa
Vacio
2
HacerUnaCosa;
HacerOtraCosa;
HacerAlgoMas
Notacin Algoritmica
Accin 1
ALGORITMO
Asignacin - Control Iteracin

1. Conocer las acciones simples que permiten capturar o mostrar los datos.
2. Encontrar en la secuenciacin el camino simple para la resolucin de problemas
3. Dividir el dominio de los datos en subdominios excluyentes y abarcativos.
4. Descubrir la necesidad de la repeticin.
5. Verificar que es posible repetir acciones en formas diferentes y para distintos
conjunto de secuencias.
Introduccin:
Se presenta en este trabajo un primer criterio de descomposicin del problema para
poder alcanzar la solucin del mismo. Se establece la secuenciacin y el anlisis de
casos como primer mecanismo correcto para la solucin de problemas.
Habitualmente se observa que aquellos jvenes que se acercan por primera vez a la
resolucin de problemas de programacin encuentran muchas dificultades para
organizar su pensamiento y encontrar una solucin algortmica.
No es simple comprender como se razona cuando se disea un algoritmo o cual es el
mecanismo que permite extraer de nuestro conocimiento la tcnica que nos gue a la
solucin de los mismos.
Una de las tcnicas que se dispone para dominar la complejidad de los problemas es la
descomposicin en subproblemas que pueden abordarse por separado, utilizando una de
las premisas bsicas en la programacin que es dividir para vencer. Cada problema
puede entonces verse como un conjunto de mdulos, vinculados y relacionados
adecuadamente. Estos mdulos utilizan mecanismos como la secuenciacin, anlisis de
casos, composiciones iterativas exactas, condicionales y recursivas para alcanzar la
solucin.
Asignacin, secuenciacin y anlisis de casos
Las instrucciones o sentencias representan las operaciones que ejecuta la computadora
al implementar un algoritmo. Estas instrucciones utilizan cierta informacin en forma de
expresiones que se resumen en un valor y que pueden ser constantes o variables.
Todos los lenguajes de programacin tienen un conjunto mnimo de instrucciones que
son asignacin, anlisis de casos y repeticiones.
Asignacin.
Asignar significa almacenar valores, constantes o variables, en una determinada
direccin de memoria, este valor puede ser almacenado desde una instruccin del
programa u obtenido o derivado hacia algn dispositivo externo.
Asignacin Interna. Almacenar un valor desde una instruccin del programa.
NombreDelIdentificador Valor;
Almacena en NombreDelIdentificador el valor. Valor puede corresponder a un dato
simple o a una expresin (operadores y operandos) la precondicin es que el tipo de
dato de valor debe corresponder al del identificador.
Asignacin Externa de entrada.
Almacena en una direccin de memoria un valor obtenido desde un dispositivo o flujo

de datos externo, el dispositivo estndar es el teclado pero es posible obtener datos
almacenados en archivos, en general esta accin recibe el nombre de leer.
Agnacin externa de salida.
Obtiene el valor contenido en una direccin de memoria y lo enva o deriva a algn
dispositivo o flujo externo. El dispositivo estndar es la pantalla pero la salida puede ser
direccionada a la impresora o un archivo (esta accin se llama grabar en un archivo).
Anlisis de casos
Al no ser posible resolver problemas con instrucciones secuenciales puras, muchas
veces es necesario tener que tomar decisiones en funcin de los datos del problema,
para ello se cuentan con instrucciones que permiten analizar alternativas y decidir que
camino seguir en cada caso.
Estructura de decisin Simple. Es la estructura bsica de decisin entre dos
alternativas. Evala una expresin condicional o condicin. Entendindose por
expresin condicional aquella expresin en la que tiene sentido preguntar por su valor
de verdad. Es una afirmacin que puede ser verdadera o falsa y se establecen con
identificadores vinculados con valores o expresiones a travs de operadores de relacin
con igual, mayor, menor, menor o igual, mayor o igual o distinto.
Estructura de decisin simple Incompleta. Solo procesa acciones en el caso de ser
verdadero el resultado de la expresin, no procesa instrucciones en el caso de ser falsa.
Formato
SI Condicin
ENTONCES
S
FIN_SI
Efecto
Si la expresin toma el valor verdadero entonces se ejecuta
la secuencia S si es falso ejecuta la accin siguiente a la
instruccin en caso de existir.
Estructura de decisin simple completa. Procesa acciones por la condicin de

verdadera y acciones distintas en caso de ser falso.
Formato
SI Condicin
ENTONCES
S
SI_NO
R
FIN_SI
Efecto
Si la expresin toma el valor verdadero entonces se ejecuta
la secuencia S si es falso se ejecuta la secuencia R.
Estructura de decisin Mltiple. Es una estructura de seleccin entre varios valores,

estos valores deben corresponder a variables de tipo ordinal y se pueden determinar
acciones distintas segn los valores del ordinal. Pueden reemplazar en forma eficiente a
estructuras de decisin simple que evalan expresiones booleanas anidadas que con
tipos de datos ordinales (caracteres o enteros).
Estructuras de decisin mltiple Incompleta. Solo realiza acciones para la lista de
valores determinada. No realiza accin en caso de que el ordinal no corresponda a un
valor definido.
Formato
SEGN expr
V1 : S1
V2 : S2
FIN_SEGN
Efecto
Segn el valor Vi de la expresin ordinal expr, se ejecuta la
secuencia Si(i = 1 ..n). Cualquier valor no especificado no
tiene accin asociada
Estructura de decisin mltiple Completa. Agrega una clusula para realizar acciones
particulares en caso de que el ordinal no se corresponda con ninguno de los valores
determinados.
Formato
SEGN expr
V1 : S1
V2 : S2
EN_OTRO_CASO : Sn
FIN_SEGN
Efecto
Segn el valor Vi de la expresin ordinal expr, se ejecuta la
secuencia Si(i = 1 ..n). Cualquier valor no especificado
realiza la secuencia Sn.
Ejemplos con uso de acciones primitivas de asignacin, entrada- salida y

declaraciones de acciones y lxico
Calculo de la nota final de una materia
LEXICO
NotaPrimerParcial :
Real
NotaSegundoParcial:
Real
NotaTrabajoPractico:
Real
NotaFinal:
Real
ALGORITMO
Leer(NotaPrimerParcial, NotaSegundoParcial, NotaTrabajoPractico)
NotaFinal (NotaPrimerParcial + NotaSegundo Parcial) / 2
Mostrar(NotaFinal, NotaTrabajoPractico)
FIN
Conversin de grados Fahrenheit en grados Celcius
LEXICO
TempFahrenheit : Real
{dato la temperatura en grados Fahrenheit}
TempCelcius: Real
{Resultado, temperatura en grados celsius}
CERO_ABSOLUTO = -459.58 {Constante el cero absoluto de temperatura}
ConvertirFahrenheitCelcius : UnaAccion
PRE {TempFaherenheit >= CERO_ABSOLUTO}
POS {Convierte a grados Celsius la Temperatura TempFahrenheit}
ALGORITMO
TempCelcius (5.0 /9.0) * TempFahrenheit 32.0)
FIN.
ALGORITMO
Ler(TempFahrenheit)
ConvertirFahrenheitCelcius
Escribir(La temperatura es :, TempCelcius
FIN
Ejemplos con anlisis de casos

PROBLEMA: Desarrollar un programa que simule una calculadora simple. Que
ingrese dos operandos y un operador. Segn el operador que muestre la suma, resta,
multiplicacin o divisin
El analisis de caso no evalua la posibilidad de
LEXICO
en otro caso, por lo tanto se deber cumplir
con la precondicin que el operador debe
Operando1, Operando2 : Entero;
estar entre uno de los caracteres validos. El
Operador
: Carcter;
operador de division que se utiliza s el
ALGORITMO
operador div que retorna la parte entera de la
division de dos enteros
Leer (Operando1, Operando2, Operador);
SEGN Operador
Operador = + : Escribir (Operando1 + Operando2)
Operador = - : Escribir (Operando1 - Operando2)
Operador = * : Escribir (Operando1 * Operando2)
Operador = / : Escribir (Operando1 Div Operando2)
FIN_SEGUN
FIN
Solucin alternativa utilizando accin en otro caso
LEXICO
En este caso se realizan acciones en caso
que el operador sea distinto a los
permitidos, por lo que si no se cumple con
Operador
: Carcter;
la precondicin es el programa quien
ALGORITMO
informa de una situacin irregular o no
Leer (Operando1, Obrando, Operador);
deseada
SEGN Operador
Operador = + : Escribir (Operando1 + Operando2)
Operador = - : Escribir (Operando1 - Operando2)
Operador = * : Escribir (Operando1 * Operando2)
Operador = / : Escribir (Operando1 Div Operando2)
EN_OTRO_CASO : Escribir(Operador no valido)
FIN_SEGUN
FIN.
PROBLEMA: Comprobar si una fecha es correcta

LEXICO
dia, mes, ao : Entero >0 ;
EsBisiesto, FechaValida : Booleano ;
AoBisiesto : una accin
POST {AoBisiesto V si ao es bisiesto F en caso contrario}
ALGORITMO
EsBisiesto (ao Mod 400 = 0) o ((ao Mod = 0)y(ao mod 100<>0))
FIN AoBisiesto
ALGORITMO
Leer (dia, mes, ao);
SI (dia < 1 )
ENTONCES FechaValida Falso
SI_NO
SEGN mes
mes = 1,3,5,7,8,10,12 : FechaValida dia <= 31
// si los meses son los que se enumeran y el dia menor o igual a 31 es valida//
mes = 4,6,9,11
: FechaValida dia <= 30
//en estos meses para ser valida el dia debe ser menor o igual a 30//
mes = 2
: AoBisiesto; FechaValida dia <=28 o (AoBisiesto y
dia<=29)
// en febrero debe verificar si el ao es o no bisiesto//
EN_OTRO_CASO : FechaValida Falso
// de no ocurrir nada de lo anterior, la fecha es falsa, no es una fecha valida//
FIN_SEGUN
FIN_SI
Escribir (La fecha , dia, /, mes,/.ao, : );
SI FechaValida
ENTONCES Escribir (Es Valida)
SI_NO Escribir(No es valida)
FIN_SI
FIN
A los efectos de simplificar la notacin de los anlisis de casos en una nica forma de
escritura se podra utilizar la notacin SI, con las variantes que correspondan y con la
sentencia equivalente segn el lenguaje de programacin.[J.D. Muchnik]
Formato
SI Condicin
ENTONCES
S
FIN_SI
Propuesta JDM
Si Condicin
S
FIN_SI
Formato
SI Condicin
ENTONCES
S
SI_NO
R
FIN_SI
Propuesta JDM
SI
Condicion1 S;
Condicion2 R;
FIN_SI
Formato
SEGN expr
V1 : S1
V2 : S2
FIN_SEGN
Propuesta JDM
SI
Condicion1 S1;
Condicion2 S2;
FIN_SI
Formato
SEGN expr
V1 : S1
V2 : S2
EN_OTRO_CASO : Sn
FIN_SEGN
Propuesta JDM
SI
Condicion1 S1;
Condicion2 S2;
CondicionB Sn;
FIN_SI
Solucin alternativa utilizando la propuesta Jorge Muchnik [JDM]

LEXICO
Operador
: Carcter;
ALGORITMO
Leer (Operando1, Oprando, Operador);
SI
(Operador = +) Escribir (Operando1 + Operando2);
(Operador = -) Escribir (Operando1 - Operando2);
(Operador = *) Escribir (Operando1 * Operando2)
(Operador = /) Escribir (Operando1 Div Operando2)
FIN_SI
FIN.
La necesidad de iterar
Supongamos que de un determinado curso se dispone de cada uno de los alumnos de su
nota y se requiere conocer la nota promedio del curso.
Para ello ser necesario conocer la nota de cada estudiante, se debe saber adems la
suma de todas las notas de los estudiantes y, para calcular el promedio, es
imprescindible conocer la cantidad de estudiantes.
Podramos pensar en un algoritmo con una estructura como la siguiente
LXICO
V : Real //Contiene la nota leda
S : Real //Contiene la sumatoria de las notas
N : Entero //Contiene el numero de alumnos
ALGORITMO
S <- 0 ;
N <- 0 ;
Leer (V) ;
S <- S + V ; //Suma las notas
N <- N + 1 ; // Cuenta los alumnos
Este bloque debe repetirse una cantidad de veces que no se puede determinar con
precisin, seria necesario escribir un texto diferente para cada caso particular, hasta
podra llegarse al extremo de tener que escribir un texto infinito, cosa imposible en la
implementacin. El infinito se lo puede pensar desde un punto de vista terico pero no
es posible implementarlo. Habamos mencionado entre las caractersticas de los
algoritmos su finitud en tiempo y en instrucciones.
La necesidad de un mecanismo de iteracin es clara si pensamos en computadoras como
maquinas de gran utilidad porque automatizan tareas, si solo se dispusiera de
composicin secuencial o anlisis de casos estaramos realmente limitados y los
programas deberan tener una gran extensin para ejecutar muy pocas acciones si estas
se repiten.
Secuencias
Algunas operaciones tienen que ver con secuencia de datos. Una secuencia es una
coleccin de elementos del mismo tipo. En ella se puede aplicar algn tratamiento a
cada uno de los elementos que componen la secuencia o buscar alguno que cumpla con
cierta propiedad.
Las secuencias pueden representarse de diferentes formas y se caracteriza por el acceso
secuencial a cada elemento. Esto es, para acceder al elemento de la posicin p, hay que
recorrer los p-1 elementos anteriores.
La secuencia debe contar con un elemento caracterstico que indique que se ha
alcanzado el final de la misma en forma correcta. Esta marca puede determinarse segn
una especificacin precisa de la cantidad de elementos o por un valor particular que
indique la finalizacin. Las secuencias estn vinculadas con las composiciones iterativas
y la reursion
Composiciones iterativas
Los componentes de una iteracin son
1. Inicializacin: instrucciones que se ejecutan para inicializar las variables que
participan de la iteracin.
2. Condicin de terminacin: expresin booleana que determina cuando acaba la
iteracin.
3. Cuerpo: conjunto de instrucciones que se ejecutan mientras no se cumple la
condicin de terminacin.
4. Finalizacin: conjunto de instrucciones que deben ejecutarse cuando la iteracin
termina.
Se presentan dos composiciones iterativas en las que la finalizacin viene determinada
por una condicin. Estas son la composicin MIENTRAS, REPETIR. Lo que las
diferencia es el lugar donde se comprueba la condicin: al principio o al final. Y
tambin si es una condicin de terminacin o de continuacin. Existe adems
composiciones iterativas en la que la finalizacin esta dada por la cantidad de elementos
que se deben evaluar
Diseo iterativo: nocin de invariante
El invariante de un ciclo, INV, es una condicin que se cumple al inicio y a cada paso de
la iteracin. Cuando finaliza la iteracin, el hecho de que se satisfaga el invariante y la
condicin de terminacin implica que se alcanz la solucin.
Dada una especificacin de un problema de recorrido de secuencias, la estrategia de una
solucin iterativa consta de los siguientes pasos:
1. Identificar qu variables son necesarias a partir de la poscondicin.
2. Establecer el invariante del ciclo.
3. Aplicar un razonamiento inductivo.
4. Escribir el algoritmo iterativo.
La composicin iterativa es el medio que permite escribir programas cortos que
involucran gran cantidad de acciones.
Existen varios formatos de iteracin que varan entre lenguajes pero que, en general
responden a tres modelos de repeticin: repetir mientras se cumpla una condicin,
repetir hasta que se cumpla una condicin y repetir una determinada cantidad de veces
Repetir mientras se cumpla una condicin
MIENTRAS condicin HACER
Accin
FIN_MIENTRAS
Repetir hasta que se cumpla una condicin
REPETIR
accin
HASTA_QUE Condicin
Repetir N veces
PARA i [1..n] HACER
accin
FIN_PARA
Composiciones iterativas No Exactas

No exacta o condicionales. Como vimos con las composiciones mientras y repetir,
puede ocurrir que un bloque de instrucciones se deba ejecutar desconociendo el numero
exacto de veces, en estos casos los lenguajes ofrecen estructuras de control iterativas
condicionales en las que las acciones se ejecutan dependiendo de la evaluacin de una
condicin.
Precondicionales
Formato
Mientras Cond. Hacer
S
FIN_MIENTRAS
Efecto
Ejecutar la secuencia S mientras la condicin Cond tenga
el valor de verdadero
Pre-condicionales. Estas evalan la condicin y si es verdadera se ejecuta el bloque de

acciones. Esto hace que dicho bloque pueda ejecutarse 0, 1, o varias veces. Es necesario
una asignacin previa a la variable de la expresin lgica para poder evaluarla y una
asignacin dentro del ciclo para evitar ciclos infinitos. Debe haber una asignacin que
permita hacer falsa a la expresin lgica para salir del ciclo.
Poscondicionales
Formato
REPETIR
S
HASTA Cond
Efecto
Ejecutar la secuencia S hasta que la expresin Cond tome
el valor de verdadero
Pos-condicionales. Primero se ejecuta el bloque de acciones y luego se evala la

condicin, si es falsa se ejecuta nuevamente el bloque de acciones el ciclo finaliza
cuando la condicin toma el valor de verdadero. A diferencia de la pre-condicional este
ciclo se ejecuta siempre, al menos una vez.
Composiciones iterativas Exactas
Formato
PARA i [Vi..Vf] HACER
S
Efecto
Ejecutar la secuencia S (Vf Vi + 1) veces.
FIN_PARA
Exacta. Una forma natural de esta estructura consiste en repetir un bloque de acciones
una cantidad fija de veces o conocido de antemano.
Tiene definido un contador o ndice como una variable de tipo ordinal que se
incrementa en una cantidad constante con cada iteracin y permite controlar el numero
de veces que se ejecutara el ciclo.
En cada iteracin el ndice toma el valor siguiente de acuerdo al tipo de valor asociado
al ordinal. Hay lenguajes que solo permiten que la variacin (que puede ser positiva o
negativa) sea solamente 1, y otros lenguajes que pueden modificar ese incremento. De
todas formas la variable ndice se actualiza con cada iteracin y se testea en cada ciclo
respecto del valor final deseado.
Si el incremento es uno la cantidad de repeticiones esta dada por:
Cantidad de repeticiones = Valor final del ndice Valor inicial del ndice + 1.
En el caso de que valor inicial y valor final coincidan se ejecuta 1 vez, en el caso de que
el valor inicial es mayor que el final y por cada iteracin se incrementa el ndice el ciclo
no se ejecutara y no producir errores en tiempo de ejecucin.
El ejemplo planteado utilizando composicin iterativa
LXICO
V : Real //Contiene la nota leda
S : Real //Contiene la sumatoria de las notas
N : Entero //Contiene el numero de alumnos
ALGORITMO // Composicin iterativa mientras

S0;
N <- 0 ;
Leer (V) // asignacin previa del dato de la expresin lgica
MIENTRAS V > 0
HACER
S S + V ; //Suma las notas
N N + 1 ; // Cuenta los alumnos
Leer (V) ;
FIN_MIENTRAS
SI N > 0
ENTONCES
Escribir (Promedio de las notas , S/N)
SI_NO
Escribir (No hay valores para procesar)
FIN.
La composicin iterativa mientras puede no ejecutarse por lo que es necesario al final del
proceso verificar si hubieron valores, el valor de n se puede utilizar para verificar esa condicin.
ALGORITMO // Composicin iterativa repetir hasta

S0;
N0;
Leer (v) // El primer valor ledo debe ser valido ya que se evala
REPETIR

Leer (V) ;
HASTA_QUE V = 0 //Cundo esto es verdadero finaliza la iteracin
No requiere validar ya que al menos hay un valor
ALGORITMO // Composicin iterativa para

S0;
N0;
Leer (N) // Lectura de la cantidad de elementos que contiene el lote de datos
PARA I [1..N] HACER
Leer (V)

FIN_PARA
SI N > 0
ENTONCES
SI_NO
Escribir (No hay valores para procesar)
La composicin iterativa para puede no ejecutarse ya que el valor ledo de N puede ser
cero, en ese caso no corresponde la iteracin por lo que es necesario al final del proceso
verificar si hubieron valores, el valor de n se puede utilizar para verificar esa condicin.
Recursividad
La repeticin puede relacionarse con el concepto de induccin matemtica, este tipo de
razonamiento permite demostrar una proposicin que depende de cierto parmetro N,
normalmente en el rango de los nmeros naturales, una forma de demostrar si una
proposicin P es cierta para todo natural N es:
Se demuestra que es cierta para N=0, inicio de la induccin o caso base
Se asume que P es cierto para n-1, hiptesis de induccin
Entonces se demuestra que tambin lo es para n, relacin de induccin
Tambin se puede utilizar la induccin para realizar definiciones matemticas de
funciones y sucesiones.
Por ejemplo se puede definir el factorial introduciendo el valor cuando n = 0 e
introduciendo una relacin para n > 0 a partir del factorial de n-1
0! = 1
N! = N * (N 1)!
La primera igualdad corresponde al caso base, la siguiente es la relacin d induccin
Otro ejemplo Es la conocida sucesin de Fibonacci
Fibo(0) = 1
Fibo(1) = 1
Fibo(N) = Fibo(n-1) + Fibo(N-2) para N>1
Los primeros valores de la serie son 1, 1, 2, 3, 5, 8, 11, 19, 21,......
Una funcin con sentencias entre las cuales se encuentra una llamada a si misma se dice
que es recursiva. Existen muchas aplicaciones matemticas y computacionales de la
recursividad. Numerosas circunstancias de la vida comn tiene naturaleza recursiva
Se debe tener en cuenta
1. Define el problema en trminos de un problema ms simple de la misma
naturaleza.
2. Debe disminuir el espacio del problema en cada llamada recursiva
Hay una instancia particular que se conoce como caso base o caso degenerado
3. Divide el problema original en subproblemas ms pequeos. Cuando es lo
suficientemente chico se resuelve directamente y se combinan soluciones del
subproblema hasta que queda resuelto el problema
HANOI
Este es un juego que tiene su origen en la cultura oriental y en una leyenda sobre el
templo de Brama, cuya estructura simulaba una plataforma metlica con tres varillas y
discos en su interior. El problema supona tres varillas Inicial, Central y Final en la que
se alojaban discos que podan trasladarse de una varilla a otra con la condicin que cada
disco era ligeramente inferior en dimetro al que estaba justo debajo de el. Los discos
originalmente estn en la varilla Inicial y se los desea trasladar a la final cumpliendo en
todos los pasos la condicin del tamao de los discos, el superior ligeramente menor al
inferior.
Si n = 1 ENTONCES
Mover n de I a F
SI_NO
Mov n-1 de I a C usando F
El analisis es simple desde el punto de vista

recursuivo es simple, si solo queda un disco en
el poste inicial este puede ser movido
directamente al disco final. Si quedaran mas
de uno habria que mover los n-1 anteriores
del inicio al medio para poder mover el ultimo
al fina. Despus habra que colocar todos los
del medio en el fina, esto recursivamentel
Mover n de I a F
Mover n-1 de C a F usando I
FIN_SI
El flujo de control de una funcin recursiva requiere tres condiciones para una
terminacin normal:
1. Un test para detener o continuar con la recursion.
2. una llamada recursiva para continuar la recursion, con un problema de la misma
naturaleza pero de menor complejidad.
3. un caso base para terminar la recursion
ALGORITMO
SI Es el caso base
ENTONCES
Ejecutar la accin final
Terminar con la recursion
SI_NO
Disminuir el espacio del problema
Volver a invocar a la funcin
FIN_SI
Iteracin vs. Recursion
Considerar solucin recursiva solo si una solucin iterativa sencilla no es posible.
Solo utilice recursividad dentro de limites aceptables de ejecucin y uso de memoria.
Si son posibles las soluciones iterativas y recursivas esta ultima requerir mas tiempo y
mas recursos de memoria.
En ciertos problemas la recursion produce soluciones mas simples de leer. Los
beneficios de la claridad compensan el costo extra
Ambas implican repeticin. Iteracin explcitamente y recursion con llamadas repetidas.
Ambas consideran un test de salida. Iteracin en la condicin, recursividad en el caso
base.
Muchas veces la resolucin de problemas exige probar sistemticamente todas las
posibilidades que pueden existir para encontrar la solucin.
En este caso se utilizan algoritmos de vuelta atrs o backtraking, que utilizan la
recursividad para probar cada una de las posibilidades hasta encontrar la solucin.
Una de las caractersticas principales de estos algoritmos es la bsqueda exhaustiva con
todas las posibilidades de soluciones parciales que conducen a la solucin del problema,
otra caracterstica es la vuelta atrs, en el sentido que si una solucin parcial no conduce
a la solucin total del problema se vuelve atrs para ensayar con otra solucin posible
de solucin.
El esquema general de estos algoritmos responden a
accin EnsayarSolucion
ALGORITMO
<Inicializar cantidad de posibles soluciones>
REPETIR
<tomar la siguiente seleccin>
<determinar si es seleccin valida>
SI Valido
ENTONCES
<anotar seleccin>
SI Problema Solucionado
ENTONCES
xito = Verdadero
SINO
EnsayarSolucion
llamada para realizar otra tarea
SINO xito
ENTONCES
<Borrar anotacin y probar otra solucin>
FINSI
FINSI
FINSI
HASTA xito O <No mas posibilidades>
Si sale por xito habr encontrado la solucin, si agota las posibilidades sin xito, el
problema no tiene solucin
FIN.
Algoritmos que utilizan secuencias
Algoritmos de bsqueda.
Dada una coleccin de elementos es posible extraer dos tipos diferentes de informacin:
Informacin relativa al conjunto de los datos que forman la coleccin
Informacin detallada de algn tem particular
En el caso en que se requiera informacin particular de un determinado tem de la
coleccin este debe ser ubicado y, eventualmente extrado de la misma para su
tratamiento particular.
El proceso de ubicar informacin particular en una coleccin de datos es conocido como
algoritmo de bsqueda.
Los procesos de bsqueda que consisten en ubicar un elemento particular deben
suministrar alguna informacin del resultado de la bsqueda. Existen bsquedas con
eficiencia optima (Ef =1), cuando se conoce el lugar preciso donde el dato se encuentra
y se denomina bsqueda directa, otras bsquedas de eficiencia logartmica las que
reducen el espacio del problema a la mitad con cada intento llamada bsqueda binaria o
dicotomica, y existe una bsqueda menos eficiente de orden N donde n representa la
cantidad de elementos de la lista. El desarrollo de estos procesos ser visto en captulos
posteriores.
Mximos y mnimos
En lo que hace a la informacin relativa a un conjunto de datos puede ser necesario
encontrar cual o cuales de los elementos de ese conjunto cumplen con ciertas
caractersticas. Por ejemplo si se tiene informacin de los nombres de los estudiantes y
sus calificaciones puede ser posible conocer el nombre del mejor estudiante, segn el
valor de sus notas, o conociendo el nombre de los atletas y el tiempo empleado en una
carrera de velocidad puede requerirse conocer el ganador. En el primer caso se busca al
estudiante cuyo promedio es el mayor, en el otro caso se busca el atleta cuyo tiempo es
el menor. Existen algoritmos puntuales que permiten buscar mximos y mnimos.
Buscar un mximo
Datos e entrada L1 ... L n Lista de n elementos
Datos de salida M identificador que contendr al valor mximo

N pertenece a los nmeros Naturales
N > 0 Por lo menos hay un elemento en la lista
Li pertenece a los nmeros racionales para todo 1<= i <= n
Poscondicin
M pertenece a los nmeros racionales
m>=li para todo 1<=i<=n
LXICO
Valor : Entero // Identificador que contendr las lecturas
Mximo : Entero // Identificador que contendr el mximo del conjunto
Esta accin le asigna el primer valor al mximo que puede ser el primer valor
ledo, si es que se tiene o un valor arbitrario. El valor arbitrario puede ser un valor
razonablemente bajo para que cualquier dato valido lo pueda desplazar o un valor
utilizado como valor centinela para indicar que corresponde a la primer lectura.
FIN
Para inicializar el identificador que contendra el maximo se
ALGORITMO
puede hacer con el primer valor leido o con un valor
razonablemente alto dentro del contexto delprpblema
Leer(Valor) ;
Mximo,valor ;
MIENTRAS haya datos HACER
SI Valor > Mximo
ENTONCES
Mximo valor
FIN_SI
FIN_MIENTRAS
SI hubodatos
ENTONCES
Escribir(El mximo del conjunto es , mximo)
SI_NO
Escribir(No hubo datos para procesar)
FIN_SI
FIN
La bsqueda de un mximo requiere:
1. Determinar el conjunto de datos para poder definir que tipo de composicin
iterativa es la mas adecuada para el problema planteado
2. Definir al menos dos identificadores del mismo tipo de dato, uno para las
sucesivas lecturas y el otro para contener el mximo del conjunto.
3. Se debe inicializar el mximo esto puede ser con un valor arbitrario,
razonablemente bajo o un valor particular que pueda ser utilizado como valor
centinela o con el valor de la primer lectura.
4. A continuacin se compara la nueva entrada con el valor mximo, cada vez que
la nueva entrada lo supera, se conserva ese valor como el nuevo mximo.
La bsqueda de un mnimo utiliza el mismo criterio solamente que requiere :
1. La inicializacin del mnimo si se hace con un valor arbitrario este debe ser lo
suficientemente alto coma para que cualquier dato del conjunto lo reemplace
2. Las comparaciones posteriores requieren simplemente cambia el operador de
relacin. Si en el mximo se compra por mayor, en el mnimo debe hacerse por
menor.
Dado 100 valores buscar el mximo del conjunto y su posicin relativa dentro del
mismo
//Bsqueda con una cantidad conocida de datos

LXICO
TAMAO_LOTE = 100;
I : Entero // variable para la iteracin
V : Entero // para las distintas lecturas
Mximo : Entero // Contiene el mximo del conjunto
PosRel : Entero // Contiene la pos del mximo dentro del conjunto
ALGORITMO
Leer(V);
Mximo = V ;//Asigna al mximo la primer lectura
PosRel = 1
PARA i [2,TAMAO_LOTE] HACER
Leer(V);
SI (V > Mximo)
ENTONCES
Mximo v;
PosRel i
FIN_SI;
FIN_PARA;
Escribir(Mximo es : ,Mximo. y su posicin relativa ,PosRel);
FIN.
Dado 100 valores buscar el mximo del conjunto y su posicin relativa dentro del
mismo
//Bsqueda con una cantidad conocida de datos con valor centinela
LXICO
TAMAO_LOTE = 100;
ALGORITMO
PARA i [1,TAMAO_LOTE] HACER
Leer(V);
El maximo lo asigna cuando es la primer lectura, es
SI ( i = 1 o V > Mximo)
decir cuando i es igual a uno, cosa que ocurre solo
una vez o cuando el valor leido reemplaza al
ENTONCES
maximo. Los compiladores evaluan las expresiones
Mximo v;
logicas de izquierda a derecha, al ser verdadera la
PosRel i
primera proposicion por ser una disyuncion no
necesita evaluar la segunda para saber su valor de
FIN_SI;
verdadero
FIN_PARA;
FIN.
Dado un conjunto de valores, que finalizan con un valor igual a 0 buscar el mximo del
conjunto y su posicin relativa dentro del mismo
//Bsqueda con una cantidad indefinida de datos
LXICO
ALGORITMO
Leer(V);
Mximo = V ;//Asigna al mximo la primer lectura
PosRel = 1
MIENTRAS (V <> 0) HACER
SI (V > Mximo)
ENTONCES
Mximo v;
PosRel i
FIN_SI;
Leer(v);
FIN_MIENTRAS;
SI (Mximo <> 0)
ENTONCES
SI_NO
Escribir(No se ingresaron valores);
FN_SI;
FIN.
Dado un conjunto de valores, que finalizan con un valor igual a 0 buscar el mximo del
conjunto y su posicin relativa dentro del mismo
//Bsqueda con una cantidad indefinida de datos
LXICO
ALGORITMO
Leer(V);
Mximo = 0; PosRel = 0;
MIENTRAS (PosRel = 0 o V <> 0) HACER
Leer(V);
SI (V > Mximo)
ENTONCES
Mximo v;
PosRel i
FIN_SI;
Leer(v);
FIN_MIENTRAS;
SI (Mximo <> 0)
ENTONCES
SI_NO
Escribir(No se ingresaron valores);
FIN.
Alternativa de solucin reemplazando el anlisis de casos con la notacin [JDM]

ALGORITMO
Leer(V);
Mximo = 0; PosRel = 0;
MIENTRAS (PosRel = 0 o V <> 0) HACER
Leer(V);
SI
(V > Mximo)
Mximo v;
PosRel i
FIN_SI;
Leer(v);
FIN_MIENTRAS;
SI
(Mximo <> 0)
(Mximo = 0) Escribir(No se ingresaron valores);
FN_SI;
FIN.
Corte de control
La utilizacin de este algoritmo puntual permite resolver el anlisis de una secuencia de
datos que cumplen con la precondicin de tener una clave que se repite, estn ordenados
o agrupados por esta clave y se requiere informacin de cada subconjunto formado por
todos los valores de la misma clave y adems informacin sobre la totalidad de los
datos. Debe garantizarse que se evaluaran todos los datos y que los que corresponden al
mismo subgrupo sern evaluados agrupados.
LXICO
Importe,Suma : Entero;
NumeroCliente, Anterior : Entero;
AGORITMO
Leer(NumeroCliente)
// hace una lectura anticipada del dato de la expresin lgica//
MIENTRAS (NumeroCliente > 0) HACER
//garantiza la secuencia de lectura de todos los datos//
Suma = 0; //inicializa acumuladores//
Anterior = NumeroCliente; //guarda e valor a controlar//
MIENTRAS (NumeroCliente > 0 y Anterior = NumeroCliente;) HACER
//ciclo que garantiza estar en el mismo subgrupo y que aun haya datos//
Leer(Importe); // lectura del resto de los datos//
Suma = Suma + Importe;
Leer(NumeroCliente)//lectura del nuevo s es igual al anterior
Continua, sino sale del ciclo.
FIN_MIENTRAS
Escribir(El Cliente : ,Anterior, Compro : ,Suma);
FIN_MIENTRAS
FIN.
Equivalencias entre notacin algortmica y lenguajes de programacin

CONDICIONAL
Formato
SI Condicion
ENTONCES
S
SI_NO
R
FIN_SI
Pascal
If expresion condicional
Then
S
Else
R;
C
If (expresion)
S;
Else
R;
Formato
SEGN expr
V1 : S1
V2 : S2
EN_OTRO_CASO : Sn
FIN_SEGN
Pascal
Case selector of
Valor1 : S1;
.........................
else Ve: Se;
end;
C
switch (selector) {
case etiqueta:S; break;
..............................
default: R;
}
ITERACION
Formato
S
FIN_MIENTRAS
Pascal
While Expresion logica do
S;
C
while(expresion)
S;
Formato
REPETIR
S
HASTA Cond
Efecto
Repeat
S
Until expresion logica
do
S;
while(expresion)
Formto
S
FIN_PARA
Efecto
For i:=Vi to vf do
S;
for(i=0;i<vf;i++)
S;
Estilos de Indentacin
Recomendacion de estilos de indentacion para desarrollos ms claros y legibles.(Ing. J.
M. Sola)
Estilo The One True Brace Style
while( SeaVerdad() ) {
HacerUnaCosa();
HacerOtraCosa();
}
HacerUnaUltimaCosaMas();
BSD/Allman.
while( SeaVerdad() )
{
HacerUnaCosa();
HacerOtraCosa();
}
Estilo Whitesmiths
{
HacerUnaCosa();
HacerOtraCosa();
}
Estilo GNU
{
HacerUnaCosa();
HacerOtraCosa();
}
Estilo Pico
while( SeaVerdad()
{
HacerUnaCosa();
HacerOtraCosa(); }
Estilo Banner
HacerUnaCosa();
HacerOtraCosa();
}
Acciones y Funciones
1. Entender la descomposicin como forma de resolucin de problemas.
2. Dar valor a la reusabilidad en bsqueda de la eficiencia en la escritura el cdigo.
3. Establecer comunicacin entre mdulos.
4. Comprender las ventajas de la descomposicin
5. Diferenciar acciones de funciones y los distintos tipos de parmetros
Introduccin
En este capitulo se analiza la descomposicin como forma de alcanzar la solucin de
problemas. Una regla bsica de la programacin indica que si existe un programa de
longitud L tal que L = L1 + L2, se dice que el esfuerzo de resolver L es mayor que la
suma de los esfuerzos de resolucin de L1 y L2, aun cuando haya que derivar esfuerzo
para la integracin de los mdulos.
SI L = L 1 + L 2
Entonces
Esfuerzo(L) > Esfuerzo(L1) + Esfuerzo (L2)
Antes de analizar las particularidades de las acciones y funciones es necesaria la
definicin de los trminos que se utilizan.
Modularizacion
En general los problemas a resolver son complejos y extensos, puede incluso
presentarse situaciones en que una parte del problema deba ser modificada para
adaptarse a nuevos requerimientos. Se hace necesario conocer algunas herramientas que
permitan facilitar la solucin de estos problemas, la abstraccin y la descomposicin
pueden ayudar a ello. La abstraccin permitir encontrar y representar lo relevante del
problema y la descomposicin se basa en el paradigma de dividir para vencer . La
descomposicin tiene como objetivo dividir cada problema en subproblemas cada uno
de los cuales ser de ms simple solucin.
Es conveniente, e importante descomponer por varias razones:
Una persona entiende un problema de caractersticas complejas partiendo la
informacin. Por esto para comprender un problema complejo del mundo real es
necesario dividirlo o modularizar.
Favorece el trabajo en equipo, cada programador recibe las especificaciones la tarea a
realizar y las restricciones con las que debe manejarse.
Favorece el mantenimiento. Las tareas involucradas en este mantenimiento, corregir
errores y modificar cdigo, se hace mucho mas simple el anlisis y control de una
porcin o modulo que de la totalidad del problema.
Permite la reusabilidad del cdigo. Siempre es deseable, de ser posible, hacer uso de
cdigo ya escrito.
Mdulos
Un problema debe ser descompuesto en subproblemas que se denominan mdulos en
los que cada uno tendr una tarea especifica, bien definida y se comunicaran entre si
adecuadamente para conseguir un objetivo comn. Un modulo es un conjunto de
instrucciones mas un conjunto de datos que realizan una tarea lgica.
Alcance de los datos

El desarrollo de un programa complejo con muchos mdulos en los que en cada uno de
ellos se deben definir los propios tipos de datos puede ocasionar algunos de los
inconvenientes siguientes:
Demasiados identificadores.
Conflictos entre los nombres de los identificadores de cada modulo.
Integridad de los datos, lo que implica que puedan usarse datos que tengan igual
identificador pero que realicen tareas diferentes.
La solucin a estos problemas se logra con una combinacin entre ocultamiento de
datos y uso de parmetros.
Datos locales y globales
Unos se declaran en la seccin de declaracin del programa principal, los otros en la
seccin de declaracin de cada modulo.
Local y global ha sido utilizado hasta ahora de manera absoluta pero los mdulos
pueden anidarse las reglas que gobiernan el alcance de los identificadores son:
El alcance de un identificador es el bloque del programa donde se lo declara.
Si un identificador declarado en un bloque es declarado nuevamente en un bloque
interno al primero el segundo bloque es excluido del alcance de la primera seccin.
Ocultamiento y proteccin de datos
Todo lo relevante para un modulo debe ocultarse a los otros mdulos. De este modo se
evita que en el programa principal se declaren datos que solo son relevantes para un
modulo en particular y se protege la integridad de los datos.
Parmetros
Son variables cuya caracterstica principal es que se utilizan para transferir informacin
entre mdulos. En programas bien organizados toda informacin que viaja hacia o
desde mdulos se hace a travs de parmetros.
Hay dos tipos de parmetros, los pasados por valor y los pasados por referencia o
direccin.
Cuando existen datos compartidos entre mdulos una solucin es que un modulo pase
una copia de esos datos al otro. En este caso el pasaje se denomina pasaje por valor. El
modulo que recibe esta copia no puede efectuar ningn cambio sobre el dato original; el
dato original se encuentra de este modo protegido de modificacin.
Los parmetros pasados por referencia o direccin no envan una copia del dato sino
envan la direccin de memoria donde el dato se encuentra por lo que tanto el proceso
que lo llama como el proceso llamado pueden acceder a dicho dato para modificarlo.
Razones por la que es conveniente la utilizacin de parmetros sobre las variables
globales.
Integridad de los datos
Es necesario conocer que datos utiliza con exclusividad cada modulo para declararlos
como locales al modulo ocultndolo de los otros, si los datos pueden ser compartidos
por ambos mdulos debera conocerse cuales son, si el modulo los utiliza solo de lectura
o puede modificarlos y es aqu donde se utilizan los parmetros.
Proteccin de datos
Si una variable es local a un modulo se asegura que cualquier otro modulo fuera del
alcance de la variable no la pueda ver y por lo tanto no la pueda modificar. Dado que las
variables globales pueden ser accedidas desde distintos mdulos, la solucin para evitar
modificaciones no deseadas es el pasaje como parmetros valor.
Uso de parmetros para retornar valores
Si bien el pasaje por valor es til para proteger a los datos, existen situaciones en las que
se requiere hacer modificaciones sobre los datos y se necesitan conocer esas
modificaciones. Para esto se deben utilizar parmetros pasados por referencia. Los
parmetros enviados por referencia son aptos adems para enviar datos en ambos
sentidos.
Utilidad del uso de parmetros
El uso de parmetros independiza a cada modulo del nombre de los identificadores que
utilizan los dems. En el caso de lenguajes fuertemente tipiados solo importa la
correspondencia en cantidad tipo y orden entre los actuales del llamado y los formales
de la implementacin con independencia del nombre del identificador.
Reusabilidad
El uso de parmetros permite separar el nombre del dato, del dato en si mismo, lo que
permite que el mismo cdigo sea utilizado en distintas partes del programa simplemente
cambiando la lista de parmetros actuales.
Acciones
El lxico establece el nivel de abstraccin de un algoritmo. Es decir, introduce las
variables, las constantes, los tipos de datos y las acciones con que se construye el
algoritmo. Ahora se profundizara sobre el estudio de las acciones.
El concepto de accin est muy ligado al concepto de abstraccin. Se analiza como
abstraccin por parametrizacin y abstraccin por especificacin.
Utilizacin de acciones
Una accin es una secuencia de instrucciones que se identifica por un nombre y que
puede ser invocada desde un algoritmo principal o desde otra accin. Cuando una
accin es invocada desde algn punto de un algoritmo, el flujo de ejecucin se traslada a
la primera instruccin de la accin, entonces la accin se ejecuta hasta el final y cuando
acaba, el flujo se traslada de nuevo a la instruccin del algoritmo que sigue a aquella
que origino la invocacin.
Una accin debe tener un efecto bien definido, lo que significa que debe ser cohesiva.
El nombre de la accin es conveniente que evoque la tarea que realiza. Hay que definir
acciones que sean aplicables a cualquier posible conjunto de valores de entrada y no a
un valor concreto.
Entre una accin y el algoritmo que la invoca se debe producir una comunicacin de
valores: el algoritmo debe proporcionar los valores de entrada y la accin puede retornar
el resultado, o puede modificar el estado de alguno de ellos.
Puede haber acciones en las que la comunicacin se realice mediante variables globales
definidas en el mbito del algoritmo principal, que pueden ser manejadas por la accin.
Pero esta no es la forma mas apropiada. Una accin, en principio, nunca debera acceder
a variables globales.
Los parmetros son el mecanismo que posibilita escribir acciones generales, aplicables
a cualquier valor de la entrada, e independientes del lxico del algoritmo.
Acciones con parmetros
Un parmetro es un tipo especial de variable que permite la comunicacin entre una
accin y el algoritmo que la invoca, ya sea que este pase a la accin un valor de entrada
o bien que la accin devuelva el resultado al algoritmo, o que pasen ambas cosas
simultneamente.
A los parmetros que proporcionan un valor de entrada se los llaman Parmetros dato,
y a los que, adems de recoger un valor, retornan un resultado, se los llama datoresultado. En la declaracin de una accin, la lista de los parmetros se indica despus
del nombre de la accin entre parntesis y separados por punto y coma.
Nombre(dato p1 : TipoDato; dato-resultado p2 : TipoDto) :
una accin
Un parmetro tambin cuenta con una caracterstica: la direccin de memoria en la que

se realiza la transmisin de la informacin.
Se denomina paso de parmetros al modo en que se establece la comunicacin entre los
argumentos pasados a la accin desde el algoritmo y los parmetros de la accin; en la
llamada se pasan los datos de entrada, y en el retorno se devuelven los resultados. Cada
argumento se liga con el parmetro que ocupa la misma posicin en la declaracin de la
accin y ambos deben coincidir en tipo.
En la invocacin a una accin, el algoritmo debe proporcionar un valor para cada
parmetro dato, mientras que debe indicar para cada parmetro dato-resultado qu
variable de su lxico recoger el valor.
Abstraccin y acciones
El trmino abstraccin se refiere al proceso de eliminar detalles innecesarios en el
dominio del problema y quedarse con aquello que es esencial para encontrar la solucin.
Como resultado de aplicar la abstraccin, se obtiene un modelo que representa la
realidad que nos ocupa. Este modelo no es la realidad, es una simplificacin de esa
realidad que establece un nivel de abstraccin mas apropiado para razonar sobre el
problema y encontrar la solucin.
La abstraccin tambin est relacionada con los lenguajes de programacin. Estos
ofrecen mecanismos de abstraccin que determinan la forma de razonar de un
programador.
El concepto de accin conjuga dos tcnicas de abstraccin que son la parametrizacin y
la especificacin. La parametrizacin es un mecanismo por el cual se generaliza una
declaracin para que no sea aplicado a un nico caso, sino que sirva para cualquier valor
que pueda tomar cierto parmetro.
La abstraccin por especificacin es la separacin entre la especificacin (el Qu) y la
implementacin (el cmo). En el caso de acciones, se refiere a distinguir entre la
descripcin de qu hace la accin y el cmo se la implementa. Una vez que se define
una nueva accin, se las utiliza del mismo modo que si se tratase de una accin
primitiva.
Del mismo modo que el algoritmo, las acciones se especifican mediante una
precondicin y una poscondicin. La precondicin establece las restricciones que
satisfacen los parmetros (datos de entrada) para que se pueda ejecutar la accin, y la
postcondicin describe el resultado.
Cada accin debe ir siempre acompaada de una descripcin textual de su efecto y de su
precondicin y postcondicin. De esta forma, cualquier programador podra conocer
qu hace y podra utilizarla sin conocer cmo lo hace.
El programador solo debe preocuparse por que se cumpla la precondicin al invocar la

accin y tendr la certeza de que la accin cumplir su objetivo.
Tipos de Parmetros
Una accin se comunica con el algoritmo que lo invoca a travs de los parmetros. Es
necesaria una comunicacin en dos sentidos. El algoritmo debe proporcionar los datos
de entrada que manipular durante su ejecucin y la accin debe retornar los resultados
que obtiene.
El tipo de parmetro indica cmo los valores de los argumentos son ligados a los
parmetros.
El tipo de parmetro dato solo permite que el parmetro pueda recibir el valor de un
argumento mientras que el tipo de parmetro dato-resultado permite que el parmetro
pueda recibir un valor y pueda retornar un resultado. En la declaracin de una accin
hay que indicar el tipo de cada parmetro. Si hay varios parmetros del mismo tipo y del
mismo tipo de dato, se pueden poner en la misma declaracin, separados por comas. La
declaracin de una accin se la denomina cabecera.
Se denomina paso por valor al paso de parmetros que corresponda al tipo de parmetro
dato y paso por referencia al que corresponda al tipo de parmetro dato-resultado.
Parmetro dato (o parmetro de entrada)
El valor del argumento es asignado al parmetro en el momento de la llamada. El
argumento puede ser una expresin del mismo tipo de dato que el parmetro. Se trata de
una comunicacin unidireccional: solamente se transmite informacin desde el punto
del llamado hacia la accin.
Una regla de buen estilo de programacin es no modificar el valor de parmetros tipo
dato, aunque ello no tenga efecto fuera de la accin.
Parmetro dato-resultado (o parmetro de entrada y salida)
El valor del argumento es asignado al parmetro en el momento de la llamada y al final
de la ejecucin el valor del parmetro es asignado al argumento. Se trata de una
comunicacin bidireccional. Si la ejecucin de la accin provoca un cambio en el valor
del parmetro, en el momento del retorno el argumento tendr el valor del parmetro al
finalizar la ejecucin.
Un argumento para un parmetro dato-resultado debe ser una variable del mismo tipo de
dato que el parmetro y no puede ser una expresin.
Accin para el intercambio de dos variables: La accin recibe dos identificadores con
dos valores y debe retornar los identificadores con los valores cambiados
Intercambiar(dato-resultado a, b : Entero) : una accin
PRE { a, b : Entero, a = A, b = B }
POST { a = B, b = A }
LXICO
Estos son los parmetros, que como
deber ser modificados sus valores
t : Entero
Este identificador se
por la accion se definen como DatoALGORITMO
necesita como variable
Resultado, son las variables que
t = a;
auxiliar para poder hacer el
intercambian informacion entre el
intercambio. Su valor no lo
programa principal y el modulo. Son
a = b;
necesita el programa que
parmetros variables
b = t
invoca a la accion, solo
FIN
interesa su visibilidad en el
modulo por tanto no es
parmetro, es una variable
local al modulo
Beneficios del uso de acciones

En la actualidad, las clases de los lenguajes orientados a objetos son los mecanismos
mas adecuados para estructurar los programas. No obstante, las acciones no desaparecen
con estos nuevos mecanismos porque dentro de cada clase se encuentran acciones.
Una accin tiene cuatro propiedades esenciales. Ellas son:
1. Generalidad
2. Ocultamiento de informacin
3. Localidad
4. Modularidad
De estas propiedades, se deducen una serie de beneficios muy importantes para el
desarrollo de algoritmos.
1. Dominar la complejidad
2. Evitar repetir cdigo
3. Mejorar la legibilidad
4. Facilitar el mantenimiento
5. Favorecer la correccin
6. Favorecer la reutilizacin
Funciones
Si el propsito es calcular un valor a partir de otros que se pasan con argumentos y se
utilizan acciones, habr que definir un parmetro dato-resultado para que retorne el
valor calculado. Las acciones que retornan un nico valor no pueden ser utilizadas en
una expresin.
Para resolver este problema, los lenguajes de programacin incorporan el concepto de
funcin. Las funciones devuelven un nico valor. La funcin supone extender el
conjunto de operadores primitivos.
En cada declaracin se especifica el nombre de la funcin, la lista de los parmetros y
finalmente el tipo de valor que retorna la funcin.
Nombre_funcion (par1 : td1 ; ... ; parn : tdn) : tr : una funcin
Una funcin no debe tener efectos laterales. Es decir, debe limitarse a calcular un valor
y no modificar ninguno de los que se describen en el momento de la invocacin.
Las acciones se utilizan para extender el conjunto de acciones primitivas. Las funciones
permiten extender el conjunto de funciones u operadores primitivos. Siempre deben
utilizarse dentro de una expresin.
Funcin que obtenga el mayor de tres nmeros

Max(a, b, c : Entero) Entero : una funcin
ALGORITMO
SI (a >= b) y (a >= c)
ENTONCES
Max = a
SINO SI (b >= a) y (b >= c)
ENTONCES
Max = b
SINO
Max = c
FIN_SI
Las funciones siempre retornan un unico

valor. Es imprescindible asignarle valor
al nombre e la funcion. El identificador
del nombre de la funcion se puede utilizar
en una expresin como cualquier
identificador del tipo que retorna. Las
funciones pueden retornar un escalar un
apuntadoro un registro
FIN_SI
FIN.
Resumen:
En este capitulo se avanza sobre la necesidad de mayor abstraccin procedural
introduciendo conceptos claves de programacin como acciones y funciones como la
forma mas adecuada de estructurar problemas en el paradigma procedural. Es una
introduccin a la abstraccin procedural y de datos que servir de base para sustentar
futuros conocimientos de estructuracin de programas en clases cuando se aborde, en
otra instancia, la programacin orientada a objetos.
Se dio valor a trminos como reusabilidad, ocultamiento de datos y cohesin
Estructuras Enlazadas
1. Manejar estructuras complejas.
2. Introducirse a la semntica de direcciones
3. Comprender como se asigna memoria dinmicamente en tiempo de ejecucin.
4. Conocer estructuras enlazadas lineales
5. Diferenciar entre estructuras indexadas y estructuras enlazadas
Introduccin:
En el presente trabajo se incorpora el concepto de asignacin dinmica en memoria.
Esto permite romper con la limitacin de tamao fijo que proporcionan las tablas
cuando es necesario trabajar con coleccin de datos el mismo tipo en memoria.
Para esto se incorporan los conceptos de estructuras enlazadas, punteros y asignacin
dinmica en memoria.
Estructuras enlazadas vs. estructuras indexadas
Como vimos una tabla es una secuencia de datos del mismo tipo donde a cada elemento
se puede acceder a travs de un ndice. En esta estructura las posiciones de memoria son
contiguas y se las puede ir recorriendo con solo incrementar el ndice. En estas
estructuras el primer elemento lgico coincide con el primero fsico, es decir se
comienza desde la primera posicin, y el siguiente lgico coincide con el siguiente
fsico, es decir al prximo elemento se accede incrementando en uno el ndice. Estas
estructuras, con esta organizacin son estructuras indexadas. Las estructuras pueden
organizarse de forma diferente. El primer elemento lgico puede no coincidir con el
primero fsico, en ese caso, para conocer donde comienza lgicamente se debe saber la
posicin de ese primero. El siguiente elemento lgico no necesariamente debe estar en
la posicin contigua, para saber donde esta ser necesario tener algo que referencie la
posicin del siguiente elemento. Una estructura con esta organizacin es una estructura
enlazada. Las estructuras enlazadas tienen la particularidad que se necesita conocer la
posicin del primer elemento y en cada posicin se tiene un registro, llamado nodo, con
al menos dos campos, uno que contenga la informacin y otro que indique o referencie
donde se encuentra el siguiente que no necesariamente debe ser el contiguo.
Por otro lado vimos que si se quiere definir en memoria una coleccin de datos del
mismo tipo mediante una tabla esta requiere establecer una capacidad mxima. Estas
son estructuras con tamao fijo, el mismo no puede ser modificado en tiempo de
ejecucin. Existe entonces riesgo que la cantidad de posiciones definidas en tiempo de
declaracin no alcancen, o, que se utilicen muy pocas de las posiciones definidas
haciendo un uso poco eficiente de los recursos.
Estructuras enlazadas con asignacin dinmica en memoria
Una estructura con asignacin dinmica es un conjunto de elementos de tipo
homogneo donde los mismos no ocupan posiciones contiguas de memoria, pueden
aparecer fsicamente dispersos manteniendo un orden lgico y son instanciados y/o
liberados en tiempo de ejecucin.
Operaciones con listas
1. Crear una estructura

2. Recorrerla, parcial o totalmente
3. Agregar o insertar nuevos elementos o nodos en distintos lugres y con criterio
variado.
4. Localizar un elemento en particular en la estructura
5. Borrar un elemento de posicion particular o previamente desconocida
La mayor facilidad de las listas es el enlace dinmico a travs de punteros que
permiten intercalar o eliminar valores sin un movimiento masivo de memoria, con solo
pedir memoria o liberarla y hacer simplemente los enlaces de los nodos involucraos.
Punteros
Es posible definir estructuras de datos complejas cuyo tamao puede cambiar en tiempo
de ejecucin, por lo que son denominadas estructuras de datos dinmicas. Se instancias
a travs de punteros.
Mediante la utilizacin de tablas se puede definir una secuencia de valores como:
TipoSecuencia = TIPO Tabla [1, LongitudMaxima] de elemento;
Con esta definicin se reserva espacio en tiempo de ejecucin para una cantidad fija de
elementos. Esta cantidad esta dada por el valor de LongitudMaxima.
Otra forma de definir una secuencia de valores seria por induccin o recursion:
La secuencia vaca es una secuencia
Un elemento concatenado a una secuencia es otra secuencia
De esta forma se declara el tipo sin especificar ninguna capacidad mxima, se define en
forma recursiva.
En esta definicin es necesario que cada elemento referencie con precisin el siguiente
elemento si es que este existe.
Una secuencia, con esta organizacin, como ya dijimos es una concatenacin de
registros llamados nodos de dos campos: uno para la informacin y otro para un
indicador al siguiente elemento. El siguiente elemento al que se referencia es un registro
del mismo tipo del actual, por referenciar a una estructura de su mismo tipo estas
estructuras se conocen como estructuras autoreferenciadas.
Para la asignacin dinmica en memoria, los elementos se enlazan a travs de un
determinado tipo de dato que disponen la mayora de lenguajes de programacin y que
se denominan puntero o apuntador, cuyos valores son referencias o punteros a variables
de un tipo.
TipoPunteroEntero = TIPO Apuntador a Entero;
Se hace una definicin de un tipo de dato con la particularidad que tendr como valor
una direccin de memoria. Se dir entonces que es un puntero al tipo de dato o que
apunta a determinado tipo de dato
Si de define
PunteroEntero = TipoPunteroEntero
Los posibles valores de PunteroEntero no sern enteros, sino referencias a enteros; esto
sera la direccin del espacio de memoria en la que se almacena el entero.
Ya se defini variable como un identificador que denota un espacio de memoria en el
que se almacena un valor del tipo asociado en la direccin.
Un valor apuntador es la direccin de una variable annima, se le asigna la direccin
a se crea en tiempo de ejecucin.
Para indicar que una variable puntero no referencia o apunta a ninguna a otra variable
se le debe asignar el valor NULO.
TipoInfo = TIPO Entero
//define la informacin que tendr el campo dato del nodo//
TipoPuntero = TIPO Apuntador a TipoNodo;
//Define un puntero que en cada instancia generara un nodo.

TipoNodo = TIPO < dato : TipoInfo; sgte : TipoPuntero >;
//Define un nodo con la informacin y la referencia al siguiente que es un puntero a la
siguiente direccin de memoria de la secuencia definida//
Se trata de una definicin recursiva o autorreferenciada siguiendo la definicin
inductiva de secuencia.
Una estructura enlazada utilizando punteros debe tener una variable que controle la
estructura, en general debe contener la direccin de memoria del primer nodo de la
misma, que debe ser de tipo puntero e inicialmente debe ser creada haciendo apuntar a
la misma al valor NULO, lo que indica que la secuencia esta vaca.
Con este tipo de estructura no es necesario especificar una capacidad mxima en la
declaracin, sino que se asigna espacio en tiempo de ejecucin, conforme se necesita, a
travs de los apuntadores, por lo que se obtienen dos importantes beneficios.
1. No se desaprovecha espacio cuando la secuencia tiene menos elementos que el
tamao mximo establecido.
2. El tamao de la secuencia no est limitado.
Solo se podra mencionar como desventaja el hecho que cada elemento adema de tener
la informacin propia debe destinar recursos para referenciar al siguiente, situacin que
puede estar a favor de las tablas. Con lar particularidades de cada estructura es
responsabilidad del programador seleccionar la ms idnea para cada caso que deba
resolver.
Como ya mencionamos estas estructuras de datos cuyo tamao puede variar en tiempo
de ejecucin se denominan estructuras de datos dinmicas, que son bsicas en
programacin, como: listas, pilas, colas y rboles binarios de bsqueda que sern
abordados en este capitulo y el siguiente.
El tipo de dato Puntero
Se ha definido un tipo de datos puntero como aquel cuyo dominio de valores est
formado por referencias o punteros a variables (direcciones de memoria) de un tipo
existente.
Si los tipos de datos se definen por sus valores y sus operaciones los valores que pueden
tener los punteros son los de direcciones de memoria o el valor NULO en caso de no
estar apuntando a una direccin definida y, entre las operaciones se pueden mencionar
la asignacin interna, la creacin o la destruccin, los lenguajes de programacin
ofrecen los mecanismos para estas operaciones.
Constantes y operaciones con punteros
No es posible el uso de literales para representar valores de tipo puntero salvo las
constantes simblicas que representan el valor NULO con sintaxis diferente segn el
lenguaje de programacin que se trate. NULO representa solo eso y no contiene un
valor de direccin de memoria vlido. Esta constante NULO es compatible de
asignacin y comparacin con cualquier tipo de dato apuntador, con independencia a
cualquiera sea el tipo de valores a los que apunta ste.
Los valores de tipo apuntador son datos internos propios de cada ejecucin del
programa, solo aceptan asignacin interna, no es correcto hacer asignaciones externas
leer o escribir con variables de tipo apuntador.
Las operaciones elementales de una variable de tipo apuntador son las de creacin de
un nuevo objeto y destruccin del objeto apuntado.
Para la creacin de un nuevo objeto apuntado dispondremos de la accin Nuevo. Esta

accin tiene un nico parmetro de tipo Apuntador a T, cualquiera sea el tipo de T, y su
efecto es el siguiente:
Reserva espacio de memoria suficiente para alojar una variable de tipo T
Asigna al el valor de la direccin de memoria que acaba de reservar, si es que se
dispone de espacio en memoria o el valor NULO en caso de no poder ejecutar la accin
de creacin.
El efecto de invocar a la accin Nuevo (Puntero) sera la creacin de una nueva variable
annima del tipo al que apunta el puntero, y la asignacin a pe de la direccin de
memoria donde se encuentra dicha variable. La nueva variable se denomina annima
porque no tiene identificador propio, y nicamente ser accesible a travs de la
direccin que la accin Nuevo ha asignado al parmetro puntero. La nueva variable est
recin creada y, por tanto, sin inicializar; no tiene un valor definido mientras no se le
asigne nada.
Aunque los lenguajes de programacin tienden a aliviar al programador de la
responsabilidad de liberar el espacio reservado a variables de tipo apuntador e
incorporan rutinas de recoleccin de basuras para liberar los espacios de memoria
reservados que ya no estn siendo utilizados, de cualquier modo es errneo el realizar
reservas de espacios de memoria que posteriormente queden reservados e inaccesibles
por la prdida de valor de la direccin donde se encuentran.
Cuando un espacio de memoria que ha sido reservado con la accin Nuevo no es ya
necesario, podemos destruir las variables en l contenidas y liberar ese espacio para que
quede disponible para futuras reservas. Para ello, utilizaremos la accin Destruir, que
ejecuta la operacin inversa de Nuevo: recibe como parmetro una variable de tipo
apuntador que contiene una direccin vlida que previamente ha sido reservada con la
accin Nuevo, y libera el espacio de memoria al que apunta este parmetro. Cuando
programemos, no debemos suponer que la accin Destruir modifica el valor del
parmetro que recibe, sino que una buena prctica es asignar el valor NULO a una
variable de tipo apuntador tras invocar Destruir. Si analizamos el siguiente fragmento de
algoritmo:
LXICO
TPEntero = TIPO Apuntador a Entero;
p, q = TPEntero;
...
ALGORITMO
...
Nuevo(p);
q p;
Destruir(q);
...
FIN
Se puede ver que con independencia de si Destruir modifica o no el valor de q, despus
de ejecutar esas tres instrucciones el apuntador p tiene un valor de direccin de memoria
que no sera vlida, pues ha sido liberada. Se dice que p queda como un apuntador
colgante, ya que no apunta a nada, o mejor dicho, apunta a una direccin que ya no es
vlida, pues ha sido liberada. Es responsabilidad del programador el mantener de
manera conveniente los valores de los apuntadores y no acceder a direcciones que no
son vlidas.
Acceso a datos mediante apuntadores

Sea TPEntero un tipo de apuntador que referencia a variables de un tipo cualquiera
TipoBase y p una variable apuntador del tipo TPuntero:
TipoPuntero = TIPO Apuntador a TipoBase;
p : TipoPuntero
Los lenguajes de programacin utilizan el operador * en notacin prefija (*Puntero) o el
operador ^ (Punteros)en notacin posfija, en esta publicacin se los utilizara en forma
indistinta, agregando el operador en notacin postfija, es decir puntero, para
referenciar al objeto apuntado por el puntero. La expresin Puntero, *Puntero o
Puntrero^ har referencia al contenido de la direccin apuntada por el puntero y ser un
identificador de la variable de tipo TipoBase a que se refiere el apuntador puntero.
Respecto al tema de la asignacin debe diferenciarse si lo que se asigna es el contenido
o lo que se asigna es la direccin. Si p y q so dos variables de tipo puntero que apuntan
al mismo tipo base hay que diferenciar que es lo que ocurre con las asignaciones
siguientes:
p = q
En este caso se le asigna al contenido de p el contenido de q. P y Q siguen apuntando a
su propia direccin de memoria, i los contenidos de esas dos direcciones es lo que se
iguala.
Por otro lado la asignacin:
p q
Hace que q apunte a la direccin apuntada por p.
En el caso en que el tipo base de un determinado tipo apuntador no sea un tipo simple,
sino un tipo estructurado, el acceso se realiza con los mismos operadores de acceso que
los datos estticos.
TipoRegistro=TIPO <Campo1:TipoDeDato1;Campo2:TipoDeDato2>
TipoPunteroRegistro = TIPO Apuntador a TipoRegistro;
PunteroRegistro : TipoPunteroRegistro
PunteroRegistro es un puntero a un registro, contiene la direccin de memoria donde se
aloja un registro, pro lo tanto el contenido de la direccin de memoria a la que apunta es
un registro.
PunteroRegistro es un p TipoPuntero.
PunteroRegistro^ es un registro que se encuentra en la direccin apuntada por el
puntero.
Si PunteroRegistro^ es un registro, el operador de acceso a un miembro de un registro
es el operador punto, por lo tanto
PunteroRegistro^.Campo1 hace referencia al miembro Campo1 del registro que esta en
la direccin de memoria apuntada por PunteroRegistro
Algunos lenguajes de programacin permiten utilizar apuntadores para referenciar
variables no annimas declaradas en el lxico. Para ello disponen de un operador
direccin_de (el operador & en el caso del lenguaje de programacin C) que dada una
variable, devuelve su direccin.
LXICO
TipoRegistro=TIPO <Campo1 : Entero ; Campo2 : Entero>
TipoPunteroRegistro = TIPO Apuntador a TipoRegistro;
Registro : TipoRegistro
PunteroRegistro : TipoPunteroRegistro
ALGORITMO
Registro.Campo1 5; //asigna valores al registro
Registro.Campo2 10;
PunteroRegistro direccin_de(Registro);//
PunteroRegistro.Campo1 35;
Escribir(Registro.Campo1); //imprime el valor 35
FIN
Obviamente, cuando una variable de tipo apuntador haga referencia a una variable
declarada en el lxico, como en el caso del ejemplo anterior, no ser posible destruir su
contenido mediante la accin Destruir, ya que solo pueden destruirse las instancias que
se crean en tiempo de ejecucin con la accin Nuevo.
Tipos de datos autorreferenciados o recursivos
Hemos mostrado que con punteros se pueden definir tipos que se autorreferencian, lo
que permite que el tamao de una estructura enlazada slo est limitado por la
disponibilidad de memoria principal. Con una nica variable de tipo puntero ser
posible referenciar a una secuencia cuyo nmero de elementos podr crecer o disminuir
en tiempo de ejecucin.
En tipo de dato recursivo o autorreferenciado es un registro, llamado nodo, que contiene
entre sus elementos al menos dos campos, uno con la informacin y el otro es un
puntero a una estructura del mismo tipo. La bibliografa denomina nodo para referir a
ese elemento ya que es el trmino utilizado habitualmente para referirse a los elementos
de una estructura dinmica.
TPNodo = TIPO Apuntador a Nodo;
Nodo = TIPO < dato : Entero; sig : TPNodo >;
Cada vez que reservemos espacio para una variable se crea una nueva variable de tipo
Nodo. Es posible construir sucesivamente una secuencia indefinidamente larga de datos
de tipo Nodo, en la que el campo sig de cada uno de ellos apunta al siguiente elemento
de tipo Nodo creado. El ltimo elemento de tipo Nodo contiene en su campo sig el valor
NULO para indicar que no existen ms elementos siguientes.
El tipo Nodo es, por tanto, un tipo de dato autorreferenciado.
La siguiente funcin CrearSecuencia lee de la entrada n valores de tipo entero, crea una
secuencia con esos valores en el orden inverso de entrada y devuelve como resultado un
apuntador al primer elemento de la secuencia. La variable r se utiliza para apuntar al
nodo creado en cada paso y p apunta al primer elemento de la secuencia. Cada nuevo
nodo se aade delante del primero.
CrearSecuencia(n : Entero) TPNodo : una funcin
LXICO
Guarda en el registro apuntado por r el valor v y en el
p, q, r : TPNodo;
campo siguiente el puntero p, este puntero contiene la
direccion del que estaba en primer lugar por lo que se
i, v : Entero;
establece como siguiente el que era primero antes.
ALGORITMO
p NULO; //Crea la estructura
Leer(n);
i PARA [1, n] HACER
Escribir(Ingrese un valor entero: );
Leer(v);
Nuevo(r); // instancia y pide memoria
r^
= < v, p >;
p r
FIN_PARA;
CrearSecuencia p
FIN
El mbito de una variable local es la accin o funcin en la que se declara.
En cambio, aun cuando todas las variables apuntador usadas en la funcin
CrearSecuencia, es decir, p y r, son parte de su lxico local y, por tanto, desaparecen
tras concluir la llamada a sta. No sucede as con las variables dinmicas creadas a
travs de ellas con las llamadas a Nuevo. La secuencia creada por la funcin sera
accesible fuera de ella a travs del valor TPNodo que retorna.
La siguiente accin recorre una secuencia y escribe los datos en ella contenidos:
EscribirSecuencia(dato p : TPNodo) : una accin
LXICO
q = TPNodo;
ALGORITMO
q = p;
MIENTRAS q NULO HACER
Escribir(q.dato);
q q.sig
FIN_MIENTRAS
FIN
DestruirSecuencia(dato-resultado p : TPNodo) : una accin
LXICO
q : TPNodo;
ALGORITMO
MIENTRAS p < > NULO HACER
q p;
p p.sig
Destruir(q)
FIN_MIENTRAS
FIN
Estructuras de datos dinmicas lineales
Dependiendo del nmero de punteros y de las relaciones entre nodos, podemos
distinguir varios tipos de estructuras dinmicas
El tipo pila
Una pila es una coleccin de elementos de un mismo tipo, posiblemente vaca, sobre la
que podemos hacer operaciones de insercin de un nuevo elemento, eliminacin de un
elemento. Una pila es una estructura de tipo LIFO (del ingls, Last-Input, FirstOutput), lo cual significa que los elementos siempre sern eliminados de ella en orden
inverso al que fueron colocados, de modo que el ltimo elemento en entrar ser el
primero en salir. A este tipo de coleccin de datos se la conoce por el nombre de pila
precisamente por esta caracterstica. A la hora de retirar elementos, nicamente
podremos tomar el que est en la cima de la pila, que ser el ltimo que fue apilado.
Para definir el tipo de pila debemos, por tanto, disear las siguientes operaciones:
PilaVacia: Pila
EsPilaVacia: Pila Booleano
Apilar : Pila X TipoBase Pila

Cima : Pila TipoBase
Desapilar : Pila Pila
La lista anterior de operaciones disponibles para un tipo se conoce con el nombre de
signatura, y en ella se establecen los nombres de las operaciones y el nmero y tipo de
parmetros de cada una de ellas. En la signatura de un cierto tipo T se distinguen tres
tipos de operaciones:
1. Operaciones constructoras: son aquellas en las que el tipo T aparece como
resultado devuelto, pero no como parmetro de la operacin.
2. Operaciones modificadoras: son aquellas en las que el tipo T aparece tanto en la
lista de parmetros como en el resultado devuelto.
3. Operaciones de consulta: son aquellas en las que el tipo T aparece nicamente
en la lista de parmetros.
En el caso del tipo pila anterior, la nica operacin constructora sera PilaVacia; las
operaciones Apilar y Desapilar seran modificadoras, y las operaciones EsPilaVacia y
Cima seran de consulta. Las operaciones Cima y Desapilar tendrn como precondicin
que la pila que reciben como parmetro no sea vaca, pues para una pila vaca no estara
definida su cima ni se podra desapilar.
Se puede definir una pila de caracteres mediante las siguientes declaraciones:
TPNodoPilaCars = TIPO Apuntador a NodoPilaCars;
NodoPilaCars=Tipo < dato: Carcter; sig : TPNodoPilaCars >;
PilaCars = TPNodoPilaCars;
PilaVacia PilaCars : una funcin
ALGORITMO
PilaVacia NULO
FIN
EsPilaVacia(p : PilaCars) Carcter : una funcin
ALGORITMO
EsPilaVacia p = PilaVacia
FIN
Cima(p : PilaCars) Carcter : una funcin
PRE ( no EsPilaVacia (p) )
ALGORITMO
Cima p.dato
FIN
Apilar(p : PilaCars; c : Carcter) PilaCars : una funcin
LXICO
q : TPNodoPilaCars;
ALGORITMO
Nuevo(q);
q < c, p >;
Apilar q
FIN
Desapilar(p : PilaCars) PilaCars : una funcin
PRE ( NO EsPilaVacia(p) )
LXICO
q : PilaCars;
ALGORITMO
q p .sig;
Destruir(p);
Desapilar q
FIN
Es importante que se sepa que cuando se definen tipos de datos basados en estructuras
de datos complejas, las operaciones usuales de igualdad o desigualdad, que se realizan
por defecto mediante los operadores booleanos = y , produciran resultados que no se
corresponden con la semntica del tipo implementado. Por ejemplo, suponga que
declaramos dos variables, p1 y p2 de tipo PilaCars, y efectuamos una comparacin
como la siguiente:
SI p1 = p2 ENTONCES
...
FIN_SI;
Lo que estamos comparando en realidad no son las pilas, es decir, si constan de los
mismos elementos y estn en idntico orden, sino los apuntadores p1 y p2, puesto que
ambas variables son de tipo PilaCars el cual, a su vez, es un tipo apuntador. La
comparacin
p1 = p2 devolver Verdadero si y slo si los apuntadores p1 y p2
apuntan a la misma direccin de memoria.
Insertar elemento en una pila:
Apilar en una pila vaca:
Partiendo que ya tiene el nodo a insertar y un puntero que apunte a l, adems el puntero
a la pila valdr NULO:
El proceso es:
1. nodo^.siguiente apunte a NULO
2. Pila apunte a nodo.
Meter en una pila no vaca:
Se puede considerar el caso anterior como un caso particular de ste, la nica diferencia
es el siguiente ser pila. Se puede utilizar este procedimiento para ambos casos.
El proceso sigue siendo muy sencillo:
1. Hacemos que nodo^.siguiente apunte a Pila.
2. Hacemos que Pila apunte a nodo.
Desapilar: leer y eliminar un elemento
Slo existe un caso posible, en las pilas slo se puede leer y sacar desde le extremo de la
pila.
1. Se utiliza un puntero auxiliar.
2. Se hace apuntar al auxiliar al primer elemento de la pila, es decir a Pila.
3. Se avanza con la pila, asignando a Pila la direccin del segundo nodo de la
pila Pila^.siguiente.
4. Se conserva el contenido del nodo para devolverlo como retorno. La operacin
sacar equivale a leer y borrar.
5. Se libera la memoria asignada al auxiliar, que es el nodo a liberar.
Si la pila slo tiene un nodo, el proceso sigue siendo vlido, ya que el valor de
Pila^.siguiente es NULO, y despus de eliminar el ltimo nodo la pila quedar vaca, y
el valor de Pila ser NULO.
Algoritmo de la funcin "push" Apilar:

1. Se Crea un nodo para el valor que se colocara en la pila.
2. Se hace que nodo^.siguiente apunte a Pila.
3. Pila debe apuntar al nuevo nodo.
Algoritmo de la funcin "pop" Desapilar:
1. Se hace que nodo apunte al primer elemento de la pila, es decir a Pila.
2. Se asigna a Pila la direccin del segundo nodo de la pila: Pilasiguiente.
3. Se guarda el contenido del nodo retornarlo.
4. Se libera la memoria asignada a nodo.
El tipo cola
El tipo cola difiere del tipo pila nicamente en la forma de insercin y extraccin de
elementos. Una cola es una estructurade tipo FIFO (del ingls, First-Input, FirstOutput), es decir, primero en entrar, primero en salir. Se conoce con el nombre de cola
por ser la que habitualmente se utiliza en las colas de la vida cotidiana: el primero que
llega (que entra en la cola) es el primero en ser atendido (en ser eliminado de la cola).
TPNodoColaCars = TIPO Apuntador a NodoColaCars;
NodoColaCars = TIPO < dato: carcter; sig TPNodoColaCars >;
ColaCars = TPNodoColaCars;
Las operaciones propias del tipo cola son las siguientes:
ColaVacia : Cola
EsColaVacia : Cola Booleano
Encolar : Cola X TipoBase Cola
Primero : Cola TipoBase
EliminarPrimero : Cola Cola
Operaciones bsicas con colas
Por las restricciones a esta estructura tienen muy pocas operaciones disponibles. Las
colas slo permiten aadir y leer elementos:
1. Aadir: Inserta un elemento al final de la cola.
2. Leer: Lee y elimina un elemento del principio de la cola.
Aadir un elemento Encolar:
Las operaciones con colas son muy sencillas, prcticamente no hay casos especiales,
salvo que la cola est vaca.
Aadir elemento en una cola vaca:
Se parte de tener el nodo a insertar y un puntero que apunte a l, adems los punteros
que definen la cola, primero y ultimo que valdrn NULO
El proceso es muy simple, bastar con que:
1. nodo^.siguiente apunte a NULO.
2. Y que los punteros primero y ltimo apunten a nodo.
Aadir elemento en una cola no vaca:
De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de una
cola, en este caso, al no estar vaca, los punteros primero y ltimo no sern nulos:
1. Nodo^.siguiente apunte a NULO.
2. Ultimo^,siguiente apunte a nodo.

3. Y se actualiza ltimo, haciendo que apunte a nodo.
Aadir elemento en una cola, caso general:
Para generalizar el caso anterior, slo necesitamos aadir una operacin:
Siempre nodo^.siguiente apunta a NULO.
Si ultimo no es NULO, entonces ultimo^.siguiente apunta a nodo.
Si no el primero tambin es NULO, significa que la cola estaba vaca, as que primero
tambin apunta a nodo
Y se actualiza ltimo, haciendo que apunte a nodo.
.
Leer un elemento de una cola Eliminar primero:
Ahora tambin existen dos casos, que la cola tenga un solo elemento o que tenga ms de
uno.
Leer un elemento en una cola con ms de un elemento:
1. Se utilaza puntero auxiliar:
2. Se hace que auxiliar apunte al primer elemento de la cola, es decir a primero.
3. Se asigna a primero la direccin del segundo nodo de la cola:
primeroprimero^.siguiente.
4. Se guarda el contenido del auxiliar para devolverlo, la operacin de lectura en
colas implican tambin borrar.
5. Se Libera la memoria asignada a nodo.
Leer un elemento en una cola con un solo elemento:
1. Tambin se requiere un puntero auxiliar:
2. Se Hacemos que auxiliar apunte al primer elemento de la cola.
3. Se le asigna NULO
4. Se guarda el contenido del auxiliar para retornarlo.
5. Se libera la memoria asignada al primer nodo, el que queremos eliminar.
6. El ltimo debe apuntar a NULO.
El tipo lista
El tipo lista es el caso ms general de estructura de datos lineal. No existe una forma
prefijada de insercin y extraccin de elementos, de modo que stos pueden ser
insertados en, y tambin eliminados de, cualquier posicin arbitraria.
Listas simplemente enlazadas
Con las listas existe un repertorio ms amplio de operaciones bsicas que se pueden
realizar:
1. Aadir o insertar elementos.
2. Buscar o localizar elementos.
3. Borrar elementos.
4. Moverse a travs de una lista, anterior, siguiente, primero.
Insertar un elemento en una lista vaca:
El proceso es muy simple

1 Crear el nodo
2 Guardar la informacin
3 nodo^.siguiente apunte a NULO
4 Lista apunte a nodo
Nuevo(Nodo)
Nodo^<Valor, NULO>
Lista Nodo
Insertar un elemento en la primera posicin de una lista:

1. Crear el Nodo
2. Guardar la informacin
3. Nodo^.siguiente apunte a Lista, que contiene la direccin del anterior primero.
4. Lista debe apuntar al nuevo nodo.
Insertar un elemento en la ltima posicin de una lista:
Se supone una lista no vaca, el proceso en este caso tampoco es complejo, se necesita
un puntero que seale al ltimo elemento de la lista. La manera de conseguirlo es
empezar por el primero y avanzar hasta que el nodo que tenga como siguiente el valor
NULO.
1. Auxiliar primero
2. Al Nodo se le asigna el valor y NULO como siguiente Nodo^. <valor,
NULO>
3. Avanzar hasta que Auxiliar^.siguiente apunte al valor NULO.
4. Hacer que Auxiliar^.siguiente apunte al nuevo Nodo y as queda enlazado.
Insertar un elemento a continuacin de un nodo cualquiera de una lista:
En este caso, siguiendo el criterio del ejemplo anterior se hace que el nodo "anterior"
sea aquel a continuacin del cual insertaremos el nuevo nodo:
Si ya se dispone del anterior y del nuevo nodo, el proceso a seguir ser:
1. Hacer que Nodo^.siguiente apunte a anterior^.siguiente.
2. Hacer que anterior^.siguiente seale Nodo.
Recorrer una lista:
Las listas simplemente enlazadas slo pueden recorrerse en un sentido, ya que cada
nodo apunta al siguiente.
Para recorrer una lista se utiliza un puntero auxiliar como ndice:
1. Se le asigna al puntero ndice el valor de Lista.
2. Se recorre con un ciclo de repeticin que al menos debe tener una condicin, que
el ndice no sea NULO.
3. Dentro del Ciclo se asigna al ndice el valor del nodo siguiente al ndice actual.
Eliminar elementos en una lista
Eliminar el primer nodo de una lista abierta:
Es el caso ms simple. Se parte de una lista con uno o ms nodos, y se utiliza un
puntero auxiliar, Nodo:
1. Se hace apuntar a Nodo al primer elemento de la lista, es decir a Lista.
2. Se le asigna a Lista la direccin del segundo nodo de la lista:
ListaLista^.siguiente.
3. Se libera la memoria asignada al primer nodo, apuntado por Nodo.
Si la lista slo tiene un nodo, el proceso es tambin vlido, ya que el valor de

Lista^.siguiente es NULO, y despus de eliminar el primer nodo la lista quedar vaca, y
el valor de Lista ser NULO.
Eliminar un nodo cualquiera de una lista simplemente enlazada:
En todos los dems casos, eliminar un nodo se puede hacer siempre del mismo modo.
Supongamos que tener una lista con al menos dos elementos, y un puntero al nodo
anterior al que queremos eliminar. Y un puntero auxiliar nodo.
El proceso es parecido al del caso anterior:
Se busca que Nodo apunte al nodo a eliminar(1).
Se asigna como nodo siguiente del nodo anterior, el siguiente al que se quiere eliminar:
anterior^.siguiente = nodo^.siguiente.(2)
Se elimina la memoria asociada al nodo a eliminar.(3)
Si el nodo a eliminar es el ltimo, es procedimiento es igualmente vlido, ya que

anterior pasar a ser el ltimo, y anterior^.siguiente valdr NULO.
Moverse a travs de una lista
Slo hay un modo de moverse a travs de una lista abierta, hacia delante.
An as, a veces necesitaremos acceder a determinados elementos de una lista abierta.
Veremos ahora como acceder a los ms corrientes: el primero, el ltimo, el siguiente y
el anterior.
Primer elemento de una lista:
El primer elemento es el ms accesible, ya que es a ese a que apunta el puntero que
define la lista.
1. Para obtener un puntero al primer elemento bastar con copiar el puntero Lista.
Elemento siguiente a uno cualquiera:
Supongamos que tenemos un puntero nodo que seala a un elemento de una lista. Para
obtener un puntero al siguiente bastar con asignarle el campo "siguiente" del nodo,
nodo^.siguiente.
Elemento anterior a uno cualquiera:
Ya hemos dicho que no es posible retroceder en una lista, de modo que para obtener un
puntero al nodo anterior a uno dado tendremos que partir del primero, e ir avanzando
hasta que el nodo siguiente sea precisamente nuestro nodo, teniendo un puntero auxiliar
para contener el anterior.
Nodo = Primero
MIENTRAS no sea el nodo buscado HACER
Auxiliar = Nodo
Nodo = Nodo^.siguiente
FIN_MIENTRAS
Auxiliar apuntara al nodo anterior al buscado
ltimo elemento de una lista:

Para obtener un puntero al ltimo elemento de una lista se parte del primer nodo y se
avanza hasta que el nodo apunte a NULO, el auxiliar apuntara al ltimo. Tambin se
puede preguntar anticipadamente por el valor NULO evitndose de este modo el
puntero auxiliar
Suponiendo la lista no vaca
Nodo = Primero;
MIENTRAS Nodo^.siguiente <> NULO HACER
Nodo Nodo^.siguiente
FIN_MIENTRAS
En este caso Nodo, al final del ciclo apunta l ltimo nodo de la estructura
Como determinar si una lista est vaca:
Basta con comparar el puntero Lista con NULLO si Lista vale NULO la lista est vaca.
Borrar una lista completa:
El algoritmo genrico para borrar una lista completa consiste simplemente en borrar el
primer elemento sucesivamente mientras la lista no est vaca.
Algoritmo de insercin:
2. El primer paso es crear un nodo para el dato que vamos a insertar.
3. Si Lista es NULO, o el valor del primer elemento de la lista es mayor que el del
nuevo, insertaremos el nuevo nodo en la primera posicin de la lista.
4. En caso contrario, se debe buscar el lugar adecuado para la insercin, tenemos
un puntero "anterior". Lo inicializamos con el valor de Lista, y avanzaremos
mientras anterior^.siguiente no sea NULO y el dato que contiene
anterior^.siguiente sea menor que el dato a insertar.
5. Ahora anterior sealando al nodo previo al insertar, por lo que se enlazan lo
puntero de modo que el siguiente del nuevo sea el que era siguiente del anterior
y al siguiente del anterior se lo hace apuntar al nuevo nodo. Se debe recordar que
anterior contiene el valor inmediato anterior al valor insertado y el siguiente es
mayor. El nuevo nodo debe intercalarse entre ambos.
En el capitulo de algoritmos puntuales se ofrecen varios ejemplos para insertar nodos en
situaciones distintas y con distintos fines
Algoritmo para borrar un elemento:
Para eliminar un nodo se necesita disponer de un puntero al nodo anterior.
1. Lo primero ser localizar el nodo a eliminar, si es que existe. Pero sin perder el
puntero al nodo anterior.
2. Se parte del nodo primero, y del valor NULO para anterior.
3. Se avanza mientras nodo no sea NULO o mientras que el valor almacenado en
nodo sea menor que el que buscamos.
4. Ahora pueden darse tres casos:
5. Que el nodo sea NULO, esto indica que todos los valores almacenados en la lista
son menores que el que buscamos y el nodo que buscamos no existe. Entonces
se retorna sin borrar nada.
6. Que el valor almacenado en nodo sea mayor que el buscado, en ese caso tambin
se retorna sin borrar nada, ya que esto indica que el nodo que buscado no existe.
7. Que el valor almacenado en el nodo sea igual al buscado, nuevo existen dos
casos:
a. Que anterior sea NULO. Esto indicara que el nodo que se quiere borrar
es el primero, as que se modifica el valor de Lista para que apunte al
nodo siguiente al que se quiere borrar.
b. Que anterior no sea NULO, el nodo no es el primero, as que se asigna a
anterior^.siguiente la direccin de nodo^.siguiente.
Despus de 7 , se libera la memoria de nodo.
Implementacin de algoritmos para listas

TPNodoListaCars = TIPO Apuntador a NodoListaCars;
NodoListaCars=TIPO <dato : carcter; sig TPNodoListaCars >;
ListaCars = TPNodoListaCars;
Veamos como podemos implementar, haciendo uso de esta representacin, las
funciones de una posible especificacin:
ListaVacia : Lista
EsListaVacia : Lista Booleano
Long : Lista Entero
InsertaEnPos : Lista X Entero X TipoBase Lista
BorraDePos : Lista X Entero Lista
BuscaPos : Lista X TipoBase Entero
BuscaElem : Lista X Entero TipoBase
InsertaEnPos(lis:ListaCars;pos:Entero;e:Carcter)
ListaCars : una funcin
PRE { 1 pos Long(lis) + 1 }
LXICO
Res, p, q : TPNodoListaCars;
I : Entero;
ALGORITMO
Nuevo(p);
p.dato e;
SI pos = 1 ENTONCES
res p;
p.sig lis;
SI_NO
res lis;
q lis;
PARA i [3, pos] HACER
q q.sig
FIN_PARA;
p.sig q.sig;
q.sig p
FIN_SI;
InstertaEnPos res
FIN
BorraDePos(lis : ListaCars; pos : Entero) ListaCars: una
funcin
PRE { 1 pos Long(lis) }

LXICO
res, q, p : TPNodoListaCars;
i : Entero;
ALGORITMO
SI pos = 1 ENTONCES
res lis.sig;
Destruir(lis)
SI_NO
res lis;
p lis;
i RECORRIENDO [2, pos] HACER
q p;
p p.sig
FIN_RECORRIENDO;
q.sig p.sig;
Destruir(p)
FIN_SI;
BorraDePos res
FIN
Listas circulares
Una lista circular es una lista lineal en la que el ltimo nodo a punta al primero.
Las listas circulares evitan excepciones en la operaciones que se realicen sobre ellas. No
existen casos especiales, cada nodo siempre tiene uno anterior y uno siguiente.
En algunas listas circulares se aade un nodo especial de cabecera, de ese modo se evita
la nica excepcin posible, la de que la lista est vaca.
El nodo tpico es el mismo que para construir listas abiertas es una estructura
autoreferenciada que tiene un campo con la informacin y otro campo con un puntero a
una estructura del mismo tipo:
Lista es el puntero para contener el inicio de las listas, tanto abiertas como circulares.
En el caso de las circulares, apuntar a un nodo cualquiera de la lista.
A pesar de que las listas circulares simplifiquen las operaciones sobre ellas, tambin
introducen algunas complicaciones. Por ejemplo, en un proceso de bsqueda, no es tan
sencillo dar por terminada la bsqueda cuando el elemento buscado no existe.
Por ese motivo se suele resaltar un nodo en particular, que no tiene por qu ser siempre
el mismo. Cualquier nodo puede cumplir ese propsito, y puede variar durante la
ejecucin del programa.
Otra alternativa que se usa a menudo, y que simplifica en cierto modo el uso de listas
circulares es crear un nodo especial de har la funcin de nodo cabecera. De este modo,
la lista nunca estar vaca, y se eliminan casi todos los casos especiales.
Operaciones bsicas con listas circulares

A todos los efectos, las listas circulares son como las listas abiertas en cuanto a las
operaciones que se pueden realizar sobre ellas:
4. Moverse a travs de la lista.
Cada una de estas operaciones podr tener varios casos especiales, por ejemplo,
tendremos que tener en cuenta cuando se inserte un nodo en una lista vaca, o cuando se
elimina el nico nodo de una lista.
Aadir un elemento:
El nico caso especial a la hora de insertar nodos en listas circulares es cuando la lista
est vaca.
Aadir elemento en una lista circular vaca:
Partiremos de que ya tenemos el nodo a insertar y un puntero que apunte a l, adems el
puntero que define la lista, que valdr NULO:
El proceso es muy simple:

1. lista apunta a nodo.
2. lista^.siguiente apunte a nodo.
Aadir elemento en una lista circular no vaca:

De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de una
lista, en este caso, el puntero no ser nulo:

1. Nodo^.siguiente apunte a lista^.siguiente.
2. lista^.siguiente apunte a nodo.
Aadir elemento en una lista circular, caso general:

Para generalizar los dos casos anteriores, slo necesitamos aadir una operacin:
1. Si lista est vaca hacemos que lista apunte a nodo.
2. Si lista no est vaca, hacemos que nodo^.siguiente apunte a lista^.siguiente.
3. Despus que lista^.siguiente apunte a nodo.
Buscar o localizar un elemento de una lista circular
Para buscar elementos en una lista circular slo hay que tener una precaucin, es
necesario almacenar el puntero del nodo en que se empez la bsqueda, para poder
detectar el caso en que no exista el valor que se busca. Por lo dems, la bsqueda es
igual que en el caso de las listas abiertas, salvo que podemos empezar en cualquier
punto de la lista.
Eliminar un elemento de una lista circular:
Para sta operacin podemos encontrar tres casos diferentes:
1. Eliminar un nodo cualquiera, que no sea el apuntado por lista.
2. Eliminar el nodo apuntado por lista, y que no sea el nico nodo.
3. Eliminar el nico nodo de la lista.
En el primer caso necesitamos localizar el nodo anterior al que queremos borrar. Como
el principio de la lista puede ser cualquier nodo, haremos que sea precisamente lista
quien apunte al nodo anterior al que queremos eliminar.
Esto elimina la excepcin del segundo caso, ya que lista nunca ser el nodo a eliminar,
salvo que sea el nico nodo de la lista.
Una vez localizado el nodo anterior y apuntado por lista, hacemos que lista^.siguiente
apunte a nodo^.siguiente. Y a continuacin borramos nodo.
En el caso de que slo exista un nodo, ser imposible localizar el nodo anterior, as que
simplemente eliminaremos el nodo, y haremos que lista valga NULO
Eliminar un nodo en una lista circular con ms de un elemento:
Considerando los dos primeros casos como uno slo.
El primer paso es conseguir que lista apunte al nodo anterior al que se quiere eliminar.
1. Esto se consigue haciendo que lista valga lista^.siguiente mientras
lista^.siguiente sea distinto de nodo.
2. Se hacemos que lista^.siguiente apunte a nodo^.siguiente.
3. Se elimina el nodo.
Eliminar el nico nodo en una lista circular:

Este caso es mucho ms sencillo. Si lista es el nico nodo de una lista circular:
1. Borramos el nodo apuntado por lista.
2. Hacemos que lista valga NULO.
Otro algoritmo para borrar nodos:
Existe un modo alternativo de eliminar un nodo en una lista circular con ms de un
nodo.
Si se quiere eliminar un nodo apuntado por nodo:
1. Se copia el contenido del nodo^.siguiente sobre el contenido de nodo.

2. Se hace que nodo^.siguiente apunte a nodo^.siguiente^.siguiente.
3. Se elimina nodo^.siguiente.
Si lista es el nodo^.siguiente, se hace lista = nodo.
Este mtodo tambin funciona con listas circulares de un slo elemento, salvo que el
nodo a borrar es el nico nodo que existe, y hay que hacer que lista apunte a NULO.
En una lista circular desde cualquier nodo se puede alcanzar cualquier otro. En una lista
simplemente enlazada apuntando a un nodo no es posible volver a nodos anteriores, es
necesario volver a recorrer desde el principio. En una lista circular apuntando a un nodo
se puede volver al predecesor recorriendo hacia delante.
El riesgo con esta estructura es que de no ser riguroso se puede caer en ciclos infinitos
la lista esta sin orden el puntero a lista puede apuntar, como sealamos a cualquier
nodo.
Estas lista tienen cdigo sencillo pero ineficiente. Para insertar un nodo en esta lista sin
orden:
1.
Si se aceptan repeticiones simplemente habr que insertar el nodo en el lugar
donde se encuentra el puntero.
2.
Si no se aceptan repeticiones habr que recorrer la lista, sin caer en ciclos
infinitos para ver si el elemento a insertar ya existe. Para evitar ciclos
infinitos se debe:
a. Guardar en un puntero auxiliar el nodo donde se encuentra el comienzo
del recorrido.
b. Detener el ciclo al encontrar el dato, si es que esta o al igualar el puntero
de recorrido con el auxiliar.
Listas Circulares Ordenadas
En estas estructuras, como en las listas simplemente enlazadas se seala con un puntero
el inicio de la estructura. El cdigo es un poco mas complejo que en las listas sin orden
pero mas eficientes ya que se evitan recorridos innecesarios.
La bibliografa discute donde debe apuntar el puntero al inicio de esta listas para
simplificar el cdigo.
En las listas simplemente enlazadas para insertar un nodo y tener la direccin del
anterior para hacer la insercin se poda recorrer con dos punteros, uno que seala al
nodo actual y otro que seala al nodo anterior. Tambin es posible evitarse el uso de dos
punteros preguntando el forma avanzada por el dato contenido en el prximo nodo.
En una lista circular no vaca ningn siguiente es NULO y el recorrido se hace con un
puntero preguntando en forma avanzada. Como en el recorrido se pregunta en forma
avanzada, el puntero debe apuntar al predecesor del primer nodo, esto por si la insercin
debiera hacerse delante del primer nodo.
Si hay un nico nodo, predecesor y sucesor apuntan a dicho nodo.
Lista circular con header
Es una lista especial donde hay un nodo especial llamado HEADER, que guarda
informacin genrica sobre los otros nodos.
Por ejemplo si los nodos tienen los nombres de las personas y los sueldos, el nodo
HEADER podra tener la cantidad de nodos de la lista, excluyndolo, el sueldo
promedio y el mnimo.
Para definir este tipo de registros los lenguajes de programacin permiten definir
registros variantes o uniones, estas estructuras tienen un tratamiento similar a los
registros y pueden tener una parte fija y una parte variante en la que se solapa la
informacin.
Las ventajas que pueden sealarse entre las listas circulares con header y sin header es:
1.
El Header guarda informacin genrica sobre la lista circular. No es
necesario recorrer la lista para obtener informacin global. Se debe tener en
cuenta que al insertar o eliminar un nodo de la lista se debe actualizar la
informacin de header para que sea consistente.
2.
El cdigo se simplifica porque el header esta siempre, aunque la lista este
vaca. En este caso el problema de poner el puntero a la lista esta resuelto, se
coloca siempre en el header.
Lista Circular Ordenada con HEADER
Definiciones
Nodo = (header, comn) // enumera dos valores posibles si es header o comn.

TipoPunteroCircularCon Header = TIPO Apuntador a TipoNodo;
TipoNodo = <
Sig : TipoPuntero;
Segn tag: Nodo
Header : (cant: Entero; promedio Real; mnimo Real);
// parte del nodo cabecera//
comn : (nombre Cadena; Sueldo : Real)
// Parte comn del resto de los nodos//
FIN_SEGUN
>;
TipoDato = <nombre : Cadena; sueldo : Rel>
CrearVacia (Dato_Resultadolch_TipoPunteroCircularConHeader): una accin
ALGORITMO
Nuevo(lch);
Lch^.tag header
Lch^.cant 0;
Lch^.promedio 0;
Lch^.Minimo ValorAlto;
Lch^.sig lch
FIN
esVacia (DATO lch: TipoPunteroCircularConHeader): booleano UNA ACCION
// si el siguiente es el mismo nodo entonces solo hay un nodo y este es el header//
ALGORITMO
esVacia lch = lch^.sig
FIN
insertarOrdenado(DATO_RESULTADO lch :TipoPunterCircularConHeader; DATO
dato: TipoDato)
ALGORITMO
SI (Dato.sueldo < lcj^.Minimo)
ENTONCES
Lch^.cant = Lch^.cant + 1
// el resto de las operaciones generales//
FIN_SI
Salir Falso
REPETIR
SI (lch^.sig^.nombre < dato.nombre)
ENTONCES
Lch lch^.sig
SINO
Salir verdadero
FIN_SI
HASTA que (salir o lch^.sig.tag = header)
Nuevo(Aux)
Aux^.sig lch^.sig
Lch^.sig aux
Aux^.nombre dato.nombre
Aux^.sueldo dato.sueldo
Aux^.tag comn
FIN
ImprimirOrdenado(DATO lch :TipoPunterCircularConHeader)
ALGORITMO
REPETIR
Imprimir(lch^.sig^.nombre)
Imprimir(lch^.sig^.sueldo)
Lch lch^.sig
HASTA QUE lch^.sig^.tag = header
FIN
Listas doblemente enlazadas
Una lista doblemente enlazada es una lista lineal en la que cada nodo tiene dos enlaces,
uno al nodo siguiente, y otro al anterior.
Las listas doblemente enlazadas no necesitan un nodo especial para acceder a ellas,
pueden recorrerse en ambos sentidos a partir de cualquier nodo, esto es porque a partir
de cualquier nodo, siempre es posible alcanzar cualquier nodo de la lista, hasta que se
llega a uno de los extremos.
El nodo tpico es el mismo que para construir las listas que hemos visto, salvo que
tienen otro puntero al nodo anterior:
El movimiento a travs de listas doblemente enlazadas es ms sencillo, y como veremos

las operaciones de bsqueda, insercin y borrado, tambin tienen ms ventajas.
Operaciones bsicas con listas doblemente enlazadas
Es imilar al de listas:
4. Moverse a travs de la lista, siguiente y anterior.
Aadir un elemento:
La estructura s diferente a las vistas anteriormente por lo que se analizaran todos los
casos posibles de insercin.
Aadir elemento en una lista doblemente enlazada vaca:
tambin se parte que se dispone del nodo a inserta y el puntero que define la lista, que
valdr NULO:
El proceso es muy simple:

lista apunta a nodo.
Lista^.siguiente y lista^.anterior apunten a NULO.
Insertar un elemento en la primera posicin de la lista:

Se parte de una lista no vaca y lista apunta al primer elemento de la lista doblemente
enlazada:
El proceso es el siguiente:
Nodo^.siguiente debe apuntar a Lista.
Nodo^.anterior apuntar a Lista^.anterior.
Lista^.anterior debe apuntar a nodo.
Lista no tiene por qu apuntar a ningn miembro concreto de una lista doblemente
enlazada, cualquier miembro es igualmente vlido como referencia.
Insertar un elemento en la ltima posicin de la lista:
Igual que en el caso anterior, se parte de una lista no vaca, y de nuevo para simplificar,
que Lista est apuntando al ltimo elemento de la lista:
El proceso es el siguiente:
1. Nodo^.siguiente debe apuntar a Lista^.siguiente (NULO).
2. Lista^.siguiente debe apuntar a nodo.
3. Nodo^.anterior apuntar a Lista.
Insertar un elemento a continuacin de un nodo cualquiera de una lista:

Bien, este caso es ms genrico, ahora partimos de una lista no vaca, e insertaremos un
nodo a continuacin de uno nodo cualquiera que no sea el ltimo de la lista:

1. Que Nodo^.siguiente apunte a lista^.siguiente.
2. Que Lista^.siguiente apunte a nodo.
3. Que nodo^.anterior apunte a lista.
4. Que nodo^.siguiente^.anterior apunte a nodo.
Aadir elemento en una lista doblemente enlazada, caso general:

1. Si lista est vaca se hace que Lista apunte a nodo, y nodo^.anterior y
nodo^.siguiente a NULO.
2. Si lista no est vaca, entonces que nodo^.siguiente apunte a Lista^.siguiente.
3. Luego que Lista^.siguiente apunte a nodo.

4. Que nodo^.anterior apunte a Lista.
5. Si nodo^.siguiente no es NULO, entonces nodo^.siguiente^.anterior apunte a
nodo.
Buscar un elemento de una lista doblemente enlazada
En muchos aspectos, una lista doblemente enlazada se comporta como dos listas
abiertas que comparten los datos. Pero adems se tiene la ventaja que se puede avanzar
y retroceder desde cualquier nodo, sin necesidad de volver a uno de los extremos de la
lista.
Para recorrer una lista se procede de un modo parecido al que defini con las listas
simplemente enlazadas, ahora no se necesita un puntero auxiliar, y debe tenerse en
cuenta que Lista no tiene por qu estar en uno de los extremos:
Se retrocede hasta el comienzo de la lista, asignando a lista el valor de lista^.anterior
mientras lista^.anterior no sea NULO.
Se abre un ciclo de repeticin que al menos debe controlar que el puntero no sea NULO.
Dentro del ciclo se le asigna a lista la direccin del nodo siguiente.
Eliminar un elemento de una lista doblemente enlazada:
Se Analizan cuatro casos diferentes:
1. Eliminar el nico nodo de una lista doblemente enlazada.
2. Eliminar el primer nodo.
3. Eliminar el ltimo nodo.
4. Eliminar un nodo intermedio.
Para los casos que lo permitan consideraremos dos casos: que el nodo a eliminar es el
actualmente apuntado por Lista o que no.
Eliminar el nico nodo en una lista doblemente enlazada:
En este caso, ese nodo ser el apuntado por Lista.

1. Eliminamos el nodo.
2. Hacemos que Lista apunte a NULL.
Eliminar el primer nodo de una lista doblemente enlazada:

Se tienen los dos casos posibles, que el nodo a borrar est apuntado por Lista o que no.
Si lo est, simplemente hacemos que Lista sea Lista^.siguiente.
1. Si nodo apunta a Lista, se hace que Lista apunte a Lista^.siguiente.

2. que nodo^.siguiente^.anterior apunte a NULO
3. Borramos el nodo apuntado por nodo.
El paso 2 separa el nodo a borrar del resto de la lista, independientemente del nodo al
que apunte Lista.
Eliminar el ltimo nodo de una lista doblemente enlazada:
De nuevo tenemos los dos casos posibles, que el nodo a borrar est apuntado por Lista o
que no. Si lo est, simplemente hacemos que Lista sea Lista^.anterior.
1. Si nodo apunta a Lista, se hace que Lista apunte a Lista^.anterior.

2. que nodo^.anterior^.siguiente apunte a NULL
3. Se Borra el nodo apuntado por nodo.
Eliminar un nodo intermedio de una lista doblemente enlazada:

De nuevo tenemos los dos casos posibles, que el nodo a borrar est apuntado por Lista o
que no.
Si lo est, simplemente hacemos que Lista sea Lista^.anterior o Lista^.siguiente
Se trata de un caso ms general de los dos casos anteriores..
1. Si nodo apunta a Lista, se hace que Lista apunte a Lista^.anterior (o

Lista^.siguiente).
2. que nodo^.anterior^.siguiente apunte a nodo^.siguiente.
3. que nodo^.siguiente^.anterior apunte a nodo^.anterior.
4. Borrar el nodo apuntado por nodo.
Eliminar un nodo de una lista doblemente enlazada, caso general:

1.
De nuevo estn los dos casos posibles, que Si nodo apunta a Lista,
2.
Si Lista^.anterior no es NULO se hace que Lista apunte a Lista^.anterior.
3.
Si Lista^.siguiente no es NULO se hace que Lista apunte a Lista^.siguiente.
4.
Si ambos son NULO, se hace que Lista sea NULO.
5.
Si nodo^.anterior no es NULO, se hace que nodo^.anterior^.siguiente apunte
a nodo^.siguiente.
6.
Si nodo^.siguiente no es NULO, Se hace que nodo^.siguiente^.anterior
apunte a nodo^.anterior.
7.
Se borra el nodo apuntado por el nodo a borrar est apuntado por Lista o que
no. Si lo est, simplemente hacemos que Lista sea Lista^.anterior, si no es
NULO o Lista^.siguiente en caso contrario.
A modo de sntesis con estructuras enlazadas

Listas simplemente enlazadas: cada elemento slo dispone de un puntero, que
apuntar al siguiente elemento de la lista o valdr NULO si es el ltimo elemento.
Pilas: son un tipo especial de lista, conocidas como listas LIFO (Last In, First Out: el
ltimo en entrar es el primero en salir).
Colas: otro tipo de listas, conocidas como listas FIFO (First In, First Out: El primero en
entrar es el primero en salir).
Listas circulares no ordenadas: el ltimo elemento apunta al primero. Cualquier nodo
puede ser el nodo de entrada y salida.
Lista circular ordenada: por convencin el puntero a la lista circular apunta al
predecesor del primer nodo.
Lista con Header: Existe un nodo especial donde se guarda informacin genrica sobre
los dems nodos.
Listas doblemente enlazadas: cada elemento dispone de dos punteros, uno a punta al
siguiente elemento y el otro al elemento anterior.
rboles: cada elemento dispone de dos o ms punteros, pero las referencias nunca son a
elementos anteriores, de modo que la estructura se ramifica y crece igual que un rbol.
rboles binarios: son rboles donde cada nodo slo puede apuntar a dos nodos.
rboles binarios de bsqueda (ABB): son rboles binarios ordenados. Desde cada
nodo todos los nodos de una rama sern mayores, segn la norma que se haya seguido
para ordenar el rbol, y los de la otra rama sern menores.
rboles AVL: son tambin rboles de bsqueda, pero su estructura est ms optimizada
para reducir los tiempos de bsqueda.
rboles B: son estructuras ms complejas, aunque tambin se trata de rboles de
bsqueda, estn mucho ms optimizados que los anteriores.
Tablas HASH: son estructuras auxiliares para ordenar listas.
Grafos: es el siguiente nivel de complejidad, podemos considerar estas estructuras
como rboles no jerarquizados.
Diccionarios. Se implementan con tablas Hash para la bsqueda.
ALGORITMOS PUNTUALES
1. Evaluar algoritmos puntuales aplicables a distintas estructuras de datos.
2. Conocer las precondiciones para la utilizacin de algoritmos puntuales
Introduccin
Se describen a continuacin un conjunto de algoritmos puntuales para el manejo de
estructuras estticas y dinmicas. Con una descripcin breve de las precondiciones y
poscondiciones, utilizando definiciones genricas para todos los casos
Definiciones de tipos
Definiciones de los tipos de datos utilizados en los algoritmos que se describen
MAX_FIL
= 100;
Tinfo
= TIPO Entero;
TinfoC
= TIPO <C1 : Td1, C2 : Td2>
TVector
= TIPO Tabla [1,MAX_FIL] de Tinfo;
TPNodo
= TIPO Apuntador a Nodo;
Nodo
= TIPO <Info : Tinfo; sgte : TPNodo>
Arbol
= TIPO <Info : Tinfo; Izq, Der : TPArbol>
Acciones y funciones para vectores
BusqSecEnVector(Dato V: Tvector; Dato N: Entero; Dato Clave:Tinfo;
Dato_resultado Posic: Entero): una accion
Usar este algoritmo si alguna de las otras bsquedas en vectores mas eficientes no son
posibles, recordando que bsqueda directa tiene eficiencia 1, bsqueda binaria es
logartmica y bsqueda secuencial es de orden N
PRE: V: Vector en el que se debe buscar
Clave : Valor Buscado
N: Tamao lgico del vector
POS: Posic: Posicin donde se encuentra la clave, 0 (Cero) si no esta.
LEXICO
Controla No superar el tamao fisico del vector j<= MAX_FIL
j : Entero;
No leer mas alla del ultimo elemento logico cargado j <= N
ALGORITMO
Salir si es que encuentra la clave buscada V[j] <> clave
Posic = 0;
j = 1; //Pone el indice en la primera posicin para recorrer el vector//
MIENTRAS (j <= MAX_FIL y j <= N y V[j] <> Clave) HACER
Inc (j) //Incrementa el indice para avanzar en la estructura//
FIN_MIENTRAS;
SI (j > N)
ENTONCES
Posic =0 // No encontr la clave buscada
SI_NO
Posic = j // Encontr la clave en la posicin de ndice j
FIN_SI;
FIN. // Bsqueda secuencial En Vector
BusqMaxEnVector(Dato V: Tvector; Dato N: Entero; Dato_resultado Maximo :Tinfo;

Dato_resultado Posic: Entero): una acccion
PRE: V: Vector en el que se debe buscar (sin orden)
N : Tamao lgico del vector
POS: Posic: Posicin donde se encuentra el mximo
Maximo : Valor mximo del vector.
LEXICO
j : Entero;
Supone que el maximo es el primer valor del vector por lo que le asigna ese
valor a maximo y la posicin 1 a la posicin del maximo. Al haber leido solo un
ALGORITMO
elemento supone ese como maximo
Posic = 1;
Maximo = V[1];
PARA j [2, N] HACER
Recorre ahora las restantes posiciones del vector, a partir de la
SI (v[j] > Maximo) segunda y lcada vez que el valor leido supera al maximo
contiene ese valor como maximo y el indice actual como posicin
ENTONCES
del maximo
Posic = j;
Maximo = v[j];
FIN_SI;
FIN_PARA;
FIN. // Bsqueda mximo En Vector
BusqMinDistCeroEnVector(Dato V: Tvector; Dato N: Entero; Dato_resultado
Minimo :Tinfo; Dato_resultado Posic: Entero): una acccion
PRE: V: Vector en el que se debe buscar (sin orden)
N : Tamao lgico del vector, existe al menos un valor <> de cero
POS: Posic: Posicin donde se encuentra el minimo distinto de cero
Minimo : Valor minimo distinto de cero del vector.
LEXICO
Recorre el vector hasta encontrar el primero distinto de cero.
i,j : Entero;
Al encontrarlo supone ese valor como minimo y el valor del
ALGORITMO
indice como posicin del minimo
//
J = 1;
Mientras (J<=N) Y (V[j] = 0) Hacer
Incrementar[j];
Posic = J;
Minimo = V[j];
Recorre el vector desde la posicin inmediata
PARA j [Posic.+1 , N] HACER
siguiente hasta la ultima desplazando el minimo
SI (v[j]<> 0 Y v[j] < Minimo) solo si el valor es distinto de cero y, ademas,
ENTONCES
menor que el minimo
Posic = j;
Minimo = v[j];
FIN_SI;
FIN_PARA;
FIN. // Bsqueda minimo distinto de cero En Vector
BusqMaxySiguienteEnVector(Dato V: Tvector; Dato N: Entero; Dato_resultado
Maximo :Tinfo; Dato_resultado Posic: Entero, Dato_resultado Segundo :Tinfo;
Dato_resultado PosicSegundo: Entero): una accion
N : Tamao lgico del vector mayor o gual a 2

POS: Posic: Posicin donde se encuentra el mximo, PosicSegundo: Posicin donde se
encuentra el siguiente al mximo
Maximo : Valor mximo del vector. Segundo : Valor del siguiente al mximo del vector
LEXICO
j : Entero;
ALGORITMO
SI V[1] > V[2]
ENTONCES
Posic = 1;
Maximo = V[1];
Se tiene como precondicion que al menos hay dos
valores. Se verifica el valor que esta en la primera
PosicSegund = 2;
posicin y se lo compara con el que esta en la
Segundo = V[2];
segunda posicin, en el caso de ser mayor, el
SINO
maximo es ese valor, posicin del mximo es uno,
el segundo el valor que esta en segundo lugar y
Posic = 2;
posicin del segundo es 2. En caso contrario se
Maximo = V[2];
establece como maximo el valor de la segunda
PosicSegund =1;
posicin y segundo el de la primera.
Segundo = V[1];
FIN_SI
PARA j [3, N] HACER
SI (v[j] > Maximo)
ENTONCES
Segundo = Maximo;
PosicSegundo = Posic;
Posic = j;
Maximo = v[j];
SINO
SI Maximo>Segundo
ENTONCES
Segundo = V[j];
PosicSegundo = j
FIN_SI
FIN_SI;
FIN_PARA;
Se verifica luego desde la tercera

posicin hasta el final. En el caso
que el nuevo valor sea mayor que
el maximo, se debe contener el
anterior maximo en el segundo y al
maximo se le asigna el nuevo
valor. Cosa similar hay que hacer
con las posiciones. Si esto no
ocurriera se debe verificar si el
nuevo valor supera al segundo, en
ese caso debera desplazarlo
FIN. // Bsqueda mximo En Vector

CargaSinRepetirEnVectorV1(Dato_Resultado V: Tvector; Dato_Resultado N: Entero;
Dato Clave:Tinfo; Dato_resultado Posic: Entero; Dato_resultado Enc : Booleano): una
accion
Utilizar este algoritmo si la cantidad de claves diferentes es fija, se dispone de memoria
suficiente como para almacenar el vector y la clave no es posicional(es decir clave e
ndice no se corresponden directamente con posicin nica y predecible.Si la posicin
fuera unica y predecible la busqueda debe ser directa
POS: Posic: Posicin donde se encuentra la clave, o donde lo inserta si no esta.

Retorna
0 (cero) en caso que el vector esta completo y no lo encuentra
Enc : Retorna True si estaba y False si lo inserto con esta invocacin
Carga vector sin orden
LEXICO
j : Entero;
Controla No superar el tamao fisico del vector j<= MAX_FIL
ALGORITMO/
No leer mas alla del ultimo elemento logico cargado j <= N
Salir si es que encuentra la clave buscada V[j] <> clave
Posic = 0;
J = 1;
MIENTRAS (j <= MAX_FIL y j <= N y V[j] <> Clave) HACER
Inc (j)
FIN_MIENTRAS;
Si debio superar el tamao fisico maximo del vector no pudo
SI j > MAX_FIL
cargarlo y retorna cero como seal de error
ENTONCES
Si encontro un dato o lo debe cargar esto es en el indice j por lo
Posic = 0
que a pos se se asigna ese valor. En el caso que j sea mayor que
SI_NO
n significa que recorrio los n elemntos cargados del vector, tiene
Posic = j:
estpacio por lo que debe cargar el nuevo en la posicin j. En este
caso, y al haber un elemento nuevo debe incrementar n que es el
SI (j > N)
identificador que controla el tamao logico del vector
ENTONCES
Enc =FALSE; // No encontr la clave buscada
Inc(N);
V[N] = Clave;
SI_NO
Enc = True // Encontr la clave en la posicin de ndice j
FIN_SI;
FIN_SI
FIN. // Carga sin repetir en vector
BusquedaBinariaEnVectorV1(Dato V: Tvector; Dato N: Entero; Dato Clave:Tinfo;
Dato_resultado Posic: Entero; Dato_resultado Pri : Entero): una accion
Utilizar este algoritmo si los datos en el vector estn ordenados por un campo clave y
se busca por ese campo. Debe tenerse en cuenta que si la clave es posicional se deber
utilizar bsqueda directa ya que la diferencia en eficiencia esta dada entre 1, para la
bsqueda directa y log2N para la binaria
PRE: V: Vector en el que se debe buscar con clave sin repetir
POS: Posic: Posicin donde se encuentra la clave, o 0 (cero) si no esta
Pri : Retorna la posicin del limite inferior
LEXICO
Establece valores para las posiciones de los elementos del vector, Pri
contiene el indice del primero, es decir el valor 1, U el indice del ultimo
j : Entero;
elemento logicio, es decir N. Ademas se coloca en Posic. El valor cero,
u,m : Entero;
utilizando este valor como bandera para salir del ciclo cuando encuentar
ALGORITMO
el valor buscado
Posic = 0;
Pri = 1;
U = N;
MIENTRAS (Pri < = U y Pos = 0) HACER
M = (Pri + U ) div 2
Permanece en el ciclo mientras no encuentre lo
buscado, al encontrarlo le asigna a pos el indice
donde lo encontro, como es un valor > que cero
hace false la expresin logica y sale del ciclo. Si no
lo encuentra, y para evirtar ciclo infinito verifica
que el primero no tome un valor mayor que el
ultimo. Si eso ocurre es que el dato buscado no esta
y se debe salir
SI V[M] = Clave
ENTONCES
Posic = M;
SI_NO
SI Clave > V[M]
ENTONCES
Pri = M+1
SI_NO
U=M1
FIN_SI
FIN_SI
FIN_MIENTRAS;
FIN. // Bsqueda binaria en vector
Si el dato buscado lo encuentra le asigna a posicin

el indice para salir. Si no lo encuentra verifica si
esmayor el dato buscabo a lo que se encuentra
revisa en la mitad de los mayores por lo que le
asigna al primero el indice siguiente al de la mitad
dado que alli no estab y vuelve a dividir el conjunto
de datos en la mitas, de ser menor pone como tome
ultimo el anterior al de la mitad actual
BusquedaBinariaEnVectorV2(Dato V: Tvector; Dato N: Entero; Dato Clave:Tinfo;

Dato_resultado Posic: Entero; Dato_resultado Pri : Entero): una acccion
PRE: V: Vector en el que se debe buscar clave puede estar repetida
POS: Posic: Posicin donde se encuentra la primera ocurrencia de la clave.
0 (cero) si no esta.
Pri : Retorna la posicin del limite inferior
LEXICO
j : Entero;
u,m : Entero;
ALGORITMO
Posic = 0;
Pri = 1;
U = N;
MIENTRAS (Pri < U ) HACER
M = (Pri + U ) div 2
SI V[M] = Clave
ENTONCES
Posic = M;
Pri = M;
SI_NO
SI Clave > V[M]
ENTONCES
Pri = M+1
SI_NO
U=M1
FIN_SI
FIN_SI
FIN_MIENTRAS;
FIN. // Bsqueda binaria en vector
La busqueda es bastante parecida a lo

desarrollado anteriormente, pero en pos debe
tener la primera aparicion de la clave buscada
que puede repetirse.
En la busqueda anterior utilizabamos esta pos
como bandera, para saber cuando Sali si lo
encontro. En este caso si lo utilizamos con el
mismo proposito saldria cuando encuentra un
valor oincidente con la clave que no
necesariamente es el primero, por lo que esa
condicion se elimina. Al encontrarlo en m se le
asigna ese valoe a pos, alli seguro esta. No
sabemos si mas arriba vuelve a estar por lo que
se asigna tambien esa posicin al ultimo para
seguir iterando y ver si lo vuelve a encontrar.
Debe modificarse el operador de relacion que
compara primero con ultimo para evitar un
ciclo infinito, esto se hace eliminando la
relacion por igual. Insisto en el concepto de los
valores de retorno de la busqueda binaria. Una
particularidad de los datos es que si lo que se
busca no esta puede retornal en el primero la
posicin donde esa clave deberia estar
CargaSinRepetirEnVectorV2(Dato_Resultado V: Tvector; Dato_Resultado N: Entero;

Dato Clave:Tinfo; Dato_resultado Posic: Entero; Dato_resultado Enc : Booleano): una
acccion
PRE: V: Vector en el que se debe buscar ordenado por clave
La busqueda es bastante parecida a lo desarrollado anteriormente, pero en pos debe tener la primera
aparicion de la clave buscada que puede repetirse.
En la busqueda anterior utilizabamos esta pos como bandera, para saber cuando Sali si lo encontro.
En este caso si lo utilizamos con el mismo proposito saldria cuando encuentra un valor oincidente
con la clave que no necesariamente es el primero, por lo que esa condicion se elimina. Al encontrarlo
en m se le asigna ese valoe a pos, alli seguro esta. No sabemos si mas arriba vuelve a estar por lo que
se asigna tambien esa posicin al ultimo para seguir iterando y ver si lo vuelve a encontrar. Debe
modificarse el operador de relacion que compara primero con ultimo para evitar un ciclo infinito,
esto se hace eliminando la relacion por igual. Insisto en el concepto de los valores de retorno de la
busqueda binaria. Una particularidad de los datos es que si lo que se busca no esta puede retornal en
el primero la posicin donde esa clave deberiaestar
POS: Posic: Posicin donde se encuentra la clave, o donde lo inserta si no esta.

Retorna
0 (cero) en caso que el vector esta completo y no lo encuentra
Enc : Retorna True si estaba y False si lo inserto con esta invocacin
Carga vector Ordenado
Al estar el vector ordenadola busqueda puede ser binaria, si lo
LEXICO
encuentra retorna en posicin un valor mayor a cero. Si no lo
j : Entero;
encuentra el valor de posicin sera cero. En este caso, se conoce
que en pri es en la posicin donde este valor debe estar
ALGORITMO
Enc = True;
BusquedaBinariaEnVectorV(V; N; Clave; Posic; Pri)
SI (Posic = 0)
ENTONCES
Se produce un desplazamiento de los valores
Enc = False ;
desde el ultimo hasta el valor de pri
Posic = Pri;
corriendolos un lugar para poder insertar en
PARA j [N, Pri](-) HACER
la posicin pri el nuevo valos. Al pasar por
aqu se inserto un nuevo elemento por lo que
V[j+1] = V[j];
n, que contiene la cantidad de elementos del
FIN_PARA;
vector debe incrementarse en uno
V[Pri] = Clave;
Inc(N);
FIN_SI
FIN. // Carga sin repetir en vector Versin 2. con vector ordenado
OrdenarVectorBurbuja(Dato_Resultado V: Tvector; Dato N: Entero): una acccion
Pre: V: Vector en el que se debe ordenar, se supone dato simple
POS:
Vector ordenado por clave creciente
Usar este algoritmo cuando los datos contenidos en un vector deben ser ordenados. Se
podra por ejemplo cargar los datos de un archivo al vector, ordenar el vector
recorrerlo y generar la estructura ordenada. Para esto la cantidad de elementos del
archivo debe ser conocida y se debe disponer de memoria suficiente como para
almacenar los datos. Una alternativa, si la memoria no alcanza para almacenar todos
los datos podra ser guardar la clave de ordenamiento y la referencia donde encontrar
los datos, por ejemplo, la posicin en el archivo.
La idea general es ir desarrollando pasos sucesivos en cada uno de los cuales ir
dejando el mayor de los elementos en el ltimo lugar. En el primer paso se coloca el
mayor en la ultima posicin, en el paso siguiente se coloca el que le sigue sobre ese
y asi hasta que queden dos elemntos. En ese caso al acomodar el segundo el otro
queda acomodado el primer ciclo cuenta los pasos, son uno menos que la cantidad
de elementos porque el ultimo paso permite acomodar 2 elementos, por eso el ciclo
se hace entre 1 y N 1 siendo n la cantidad de elementos
LEXICO
I,J, : Entero;
Aux : Tinfo;
ALGORITMO
PARA i [1, N - 1] HACER
PARA j [1, N - i] HACER
SI (v[j] > v[j + 1])
ENTONCES
Para poder colocar el mayor al final es necesario
Aux = v[j];
hacer comparaciones. Se compara el primero con el
V[j] = v[j + 1];
segundo y si corresponde se intercambian. Asi hasta
V[j + 1] = Aux;
llegar al ante ultimo eleemento que se lo compara
con el ltim.
FIN_SI;
Al ir recorriendo los distintos pasos, y dado que en
FIN_PARA;
cada uno se acomoda un nuevo elemento
FIN_PARA;
corresponde hacer una comparacin menos en cada
avance, como los pasos los recorremos con i, las
FIN
comparaciones seran n i. disminuye en 1 en cada
paso
OrdenarVectorBurbujaMejorado(Dato_Resultado V: Tvector; Dato N: Entero): una

acccion
PRE: V: Vector en el que se debe ordenar, se supone dato simple
POS: Vector ordenado por clave creciente
LEXICO
I,J, : Entero;
Aux : Tinfo;
Ord : Boolean;
ALGORITMO
I = 0;
REPETIR
Inc(i);
Ord = TRUE;
PARA j [1, N - i] HACER
SI (v[j] > v[j + 1])
ENTONCES
Ord = False;
Aux = v[j];
V[j] = v[j + 1];
V[j + 1] = Aux;
FIN_SI;
FIN_PARA;
HASTA ( Ord o I = N 1);
FIN
El algoritmo es similar al anterior, solo que

el ciclo de repeticin externo no lo hace si es
que tiene la certeza, en el paso anterior que
los datos ya estan ordenados. Es por eso que
agrega una bandera para verificar si ya esta
ordenado y cambia el cilo exactp por un
ciclo pos condicional. Es decir reemplaza la
composicin para por la composicin repetir
hasta
OrdenarVectorInserion(Dato_Resultado V: Tvector; Dato N: Entero): una accion

Este algoritmo consta de los siguientes pasos
El primer elemento A[0] se lo considera ordenado; es decir se considera el array con

un solo elemento.
Se inserta A[1] en la posicion correcta, delante o detras de A[0] segun sea mayor o
menor.
Por cada iteracion, d i desde i=1 hasta n-1, se explora la sublista desde A[i-1] hasta
A[0],buscando la posicion correcta de la insercion ; a la vez se mueve hacia abajouna
posicion todos los elementos mayores que el elemento a insertar A[i] para dejar vacia
la posicion.
Insertar el elemento en l posicion correcta.
LEXICO
I,J, : Entero;
Aux : Tinfo;
ALGORITMO
PARA I[1..N-1]
J = I;
Aux = A[i] ;
MIENTRAS (J >0 Y AUX < A[J - 1])HACER
A[J] = A[J - 1] ;
Dec(J) ;
FIN MIENTRAS ;
A[J] = Aux ;
FIN PARA;
FIN
OrdenarVectorShell(Dato_Resultado V: Tvector; Dato N: Entero): una acccion
Este algoritmo consta de los siguientes pasos
Dividir la lista original en n/2 grupos de dos, considerando un incremento o salto entre
los elementos en n/2.
Analizar cada grupo por separado comparandolas parejas de elementos, y si no estan
ordenados, se intercambian .
Se divide ahora la lista en la mitad n/4, con un incremento tambien en n/4 y nuevamente
se clasifica cada grupo por separado.
Se sigue dividiendo la lista en la mitad de grupos que en el paso anterior y se clasifica
cada grupo por separado.
El algoritmo termina cuando el tamao del salto es 1.
ALGORITMO
Intervalo = n / 2;
MIENTRAS Intervalo > 0 HACER
PARA I [Intervalo + 1 .. N] HACER
MIENTRAS (J > 0) HACER
K = J + Intervalo;
SI (A[J] <= A[K]
ENTONCES
J = -1
SINO
Intercambio(A[J] ,A[K]) ;
J = J Intervalo ;
FINSI ;
FIN PARA ;
FIN MIENTRAS;
FIN.
CorteDeControlEnVector(Dato V:Tvector; Dato N: Entero): una acccion
Usar este procedimiento solo si se tienen los datos agrupados por una clave comn y se
requiere procesar emitiendo informacin por cada subconjunto correspondiente a cada
clave.
PRE: V: Vector en el que se debe Recorrer con corte de control
Debe tener un elemento que se repite y estar agrupado por el.
POS: Recorre agrupando por una clave
LEXICO
I : Entero;
ALGORITMO
I = 1;
Anterior = TipoInfo;
// Inicializar contadores generales
MIENTRAS (I<=N) Hacer
//inicializar contadores de cada sublote
Anterior = V[i]
MIENTRAS (I<=N Y Anterior = V[i] HACER
// Ejecutar acciones del ciclo
I = I+1 // avanza a la siguiente posicin
FIN_MIENTRAS
// Mostrar resultados del sublote
FIN_MIENTRAS
// Mostrar resultados generales
FIN
ApareoDeVectores(Dato V1,v2:Tvector; Dato N1,N2: Entero): una acccion
Utilizar este procedimiento si se tiene mas de una estructura con un campo clave por el
que se los debe procesar intercalado y esas estructuras estn ORDENADAS por ese
campo comn.
PRE: V1,V2: Vectores a Recorrer mezclados o intercalados
Los vectores deben estar ordenados.
N1,N2 : Tamao lgico de los vectores
POS: Muestra la totalidad de los datos con el orden de las estructuras
LEXICO
I,J : Entero;
ALGORITMO
I = 1;
J = 1;
MIENTRAS (I<=N1 o J<=N2) Hacer
SI((J > N2) o ((I<=N1) y (V1[I]<V2[J])) HACER
ENTONCES
Imprimir (V1[I]);
I = I + 1;
SINO
Imprimir(V2[J]);
J = J + 1;
FIN_SI;
FIN_MIENTRAS
FIN
CargaNMejoresEnVector(Dato_Resultado V: Tvector; Dato_Resultado N: Entero;
Dato Clave:Tinfo): una acccion
PRE: V: Vector en el que se debe buscar e insertar los mejores
Clave: Valor Buscado
N: Tamao lgico del vector
POS: Vector con los N mejores sin orden
LEXICO
j : Entero;
Maximo: Tinfo
Posic: Entero;
ALGORITMO
SI (N < MAX-FIL)
ENTONCES
Inc (N);
V[n] = Clave
SI_NO
BusqMaxEnVector(V; N; Maximo :Tinfo; Posic: Entero);
SI (Clave > Maximo)
ENTONCES
V[Posic] = Clave;
FIN_SI;
FIN_SI;
FIN. // Carga los N mejores en vector
Acciones y funciones para archivos
Se identifican dos tipos de archivos, archivos de texto y archivos biarios. Los archivos
de texto son un conjunto de lineas las cuales tienen 0, 1 o mas caracteres que finalizan
con un carcter particular que representa el fin de la linea. Los datos son interpretados
como caracteres. <los archivos binario, en cambio, son una secuencia de bytes
lmacenados segn su representacin interna y sin interpretar, en este caso es necesario
que sean leidos los datos tal como fueron guardados para poder ser reconocidos como
iguales.
Operaciones elementales de acceso a archivos:
Accion
Asignar(a,s)
Efecto
Asigna al idntificador a la cadena s que representa ub archivo
en disco
Abrir(a)
Prepara el archivo asignado a la variable a para su utilizacion
Crear(a)
Crea el archivo asignado al identificador a y lo prepra para su
acceso
Cerrar(a)
Cierra el arhivo apuntado por a, actualiza la marca de fin si
corresponde
LeerCaracter(a,c)
Lee el siguiente carcter del flujo apuntado por a y lo almacena
en c
LeerLinea(a,s)
Lee la siguente linea del flujo apuntado por a y la almacena en s
GrabarCaracter(a,c)
Escribe secuencialmente en el flujo a el caracter c
GrabarCadena(a,s)
Escribe en el flujo a la cadena s
LeerArchivo(a,r)
Lee el siguiente tipo de dato (ejemplo registro) del flujo a y lo
almacena en r
GrabarArchivo(a,r)
Graba el siguiente tipo de dato, r, en el flujo a
LeerPosicion(a,p,r)
Lee del flujo a el valor contenido en l posicin p y lo almacena
en r
GrabarPosicion(a,p,r) Graba en la posicion p del flujo a el valor contenido en r
NumeroElementos(a) Retorna el numero de elementos almacenados en el archivo
PosicionActual(a)
Retorna la posicin en la que se encuentra posicionado el
puntero actual del archivo.
ApuntarA(a,p)
Accede a la posicin indicada por p en el archivo a.
FinArchivo(a)
Retorna verdadero si se ha alcanzado la marca de fin de archivo
Definiciones de tipos
TipoArchivoEntero = TIPO Entero;
TipoRegistro = TIPO <Clave : Entero ; Nombre : Cadena>;
TipoArchivoRegistro = TIPO Archivo de TipoRegistro;
Declaracion de variables
ArchTexto : Texto //declra una varible de tipo archivo de texto
ArchEntero : TipoArchivoEntero // declara una variable de tipo archivo entero
ArchRegistro: TipoArchivoRegistro //declara una variable de tipo archivo registro
CrearArchivoEnteros(Dato_Resultado Archivo: TipoArchivoEntero): una Accion
Crea un archivo y almacena en el un conjunto de enteros, el proceso termina cuando se
ingresa un entero menor o igual a cero.
LEXICO
I : Entero;
ALGORITMO
Asignar(Archivo,Archivo.dat);
Crear(Archivo);
Imprimir(Ingrese un valor entero);
Leer(i);
MIENTRAS (i <> 0) HACER
GrabarArchivo(Archivo,i);
Leer(i);
FIN_MIENTRAS
Cerrar(Archivo);
FIN.
RecorrerArchivoEnteros(Dato_Resultado Archivo: TipoArchivoEntero): una Accion
Recorre un archivo existente que contiene valores enteros y los muestra por pantalla.
LEXICO
I : Entero;
ALGORITMO
Asignar(Archivo,Archivo.dat);
Abrir(Archivo);
MIENTRAS (No Sea FinArchivo(Archivo)) HACER
LeerArchivo(Archivo,i);
Imprimir(El valor almacenado es : ,i);
FIN_MIENTRAS
Cerrar(Archivo);
FIN.
CrearArchivodeRegistros(Dato_Resultado Archivo: TipoArchivoRegistro): una
Accion
Crea un archivo y almacena en el un conjunto deregistros, el proceso termina cuando
se ingresa un entero menor o igual a cero en el campo clave del registro.
LEXICO
La lectura de cada miembro de un registro
R : TipoRegistro;
cuando el dispositivo es el teclado debe hacerse
ALGORITMO
por seprado. Es decir la lectura de un registro por
teclado se hace camo a campo
Asignar(Archivo,ArchivoR.dat);
Crear(ArchivoR);
La escritura de un registro en un archivo (Grabar
Leer(R.clave);
elarchivo)puede hacersecampo a campo o por la
MIENTRAS (R.clave <> 0) HACER
etructura completa. Hay lenguajes de
Imprmir(Ingrese un nombre);
programacin omo Pascal que solo permiten esta
ultima opcion
Leer(R.nombre);
GrabarArchivo(Archivo,R);
Imprmir(Ingrese un valor entero);
Leer(R.Clave);
FIN_MIENTRAS
Cerrar(Archivo);
FIN.
RecorrerArchivoRegistros(Dato_Resultado Archivo: TipoArchivoRegistro): una
Accion
Recorre un archivo exsistente que contiene registros y los muestra por pantalla.
LEXICO
La lectura de un registro cuando el dispositivo es
R : TipoRegistro;
un archivo se hace por estructura completa
ALGORITMO
Abrir(Archivo);
MIENTRAS (No Sea FinArchivo(ArchivoR)) HACER

LeerArchivo(Archivo,R);
Imprimir los dtos de un registro
Imprimir(La Clave es : ,R.clave);
cuando el dispositivo es la
pantalla se hace miembro a
Imprimir(El Nombre es : ,R.nombre);
miembro. Es decir por pantalla
FIN_MIENTRAS
los registros se imprimen campo
Cerrar(Archivo);
a campo
FIN.
AgregaArchivodeRegistros(Dato_Resultado Archivo: TipoArchivoRegistro): una
Accion
Agrega datos a un archivo y almacena en el un conjunto deregistros, el proceso termina
cuando se ingresa un entero menor o igual a cero en el campo clave del registro.
LEXICO
El archivo existe por lo que no hay que crearlo.
Para agragar valores debe colocarse el punrtero
R : TipoRegistro;
en la ultima posicin por lo que hay que
ALGORITMO
desplazarlo tantos registro como el valor
contenidoen cantidad de elementos
Abrir(ArchivoR);
ApuntarA(Archivo,CantidadElementos(Archivo))
Leer(R.clave);
MIENTRAS (R.clave <> 0) HACER
Imprmir(Ingrese un nombre);
Leer(R.nombre);
GrabarArchivo(Archivo,R);
Imprmir(Ingrese un valor entero);
Leer(i);
FIN_MIENTRAS
Cerrar(Archivo);
FIN.
AgregaArchivoAlFinalDeOtro(Dato_Resultado
Anterior,
Actual:
TipoArchivoRegistro): una Accion
Agrega los datos del archivo actual al final del archivo anterior.
LEXICO
R : TipoRegistro;
Ambos archivos existen por lo que se deben abrir
y no crear, para grabar todos los registros del
ALGORITMO
actual al anterior se debe colocar el puntero del
Asignar(Anterior,ArchivoN.dat);
anterior al final del archivo y recorriendo el
Abrir(Anterior);
actual se lee y graba en anterior
Asignar(Actual,ArchivoA.dat);
Abrir(Actual);
ApuntarA(Anterior,CantidadElementos,Anterior)
MIENTRAS (No FinArchivo(Actual)) HACER
LeerArchivo(Actual,R);
GrabarArchivo(Anterior,R);
FIN_MIENTRAS
Cerrar(Anterior);
Cerrar(Actual);
FIN.
Acciones y funciones para pilas

Pila estructura del tipo LIFO el ultimo en entrar es el primero en salir, en general el
uso de esta estructura es adecuado cuando se persigue el propsito de invertir el orden
de una estructura dada. Su uso es reservado para los compiladores que los utilizan
para recursividad y las notaciones sufijas, por ejemplo.
CrearPila(Dato_Resultado Pila: TPNodo): una Accion
Las estructuras deben ser creadas, esto es hacer apuntar al valor NULO, o inicializar la
estructura antes de comenzar a trabajar con ellas.
ALGORITMO
Simplemente asigna el valor NULO al puntero
Pila = NULO;
que controla el inicio de la estructura
FIN
EsVacia(Dato Puntero: TPNodo) : Boolean una Funcion
Esta funcin determina si hay nodos en la pila, es una forma de verificar la existencia
de elementos en la estructura para no producir errores en tiempo de ejecucin como
por ejemplo intentar sacar cuando ya no hay datos.
ALGORITMO
EsVaciaPila Puntero = NULO;
FIN
Retona verdadero si el puntero a punta al valor

NULO y falso en caso contrario. La asignacin d
una expresin logica asigna verdadero al
identificador booleano si se cumple la condicion y
falso en caso contrario
Meter(Dato_Resultado Pila: TPNodo; Dato Valor: Tinfo) una accion

Este procedimiento inserta un nuevo nodo en la pila, se encarga de pedir memoria,
guardar la informacin y actualizar los punteros. En esta estructura siempre la pila
retorna el valor del primer nodo, y como se agrega adelante, el procedimiento siempre
retorna en pila el nodo que acaba de crear.
LEXICO
Pre
Pila Apunta al Inicio o a NULO si esta vaca
Pos
Pila apunta al primer elemento de la estructura (coincide con el creado
La estructura queda perfectamente enlazada.
Ptr : TPNodo;
ALGORITMO
Pide memoria, guarda el valor en el nuevo nodo,
hace que el siguiente de este nodo sea pila, es ex
Nuevo(Ptr);
primero (porque agrega delante del primero) y
Ptr^ <Valor, Pila>;
pila apunta al nodo creado
Pila Ptr
FIN.
Sacar(Dato_Resultado Pila: TPNodo; Dato_Resultado Valor: Tinfo) una accion
Este procedimiento libera el nodo apuntado por pila, se encarga de guardar la
informacin contenida en el primer nodo en valor, por lo que este es un parmetro
variable y actualizar los punteros.
LEXICO
PRE: Pila Apunta al Inicio y no esta vaca
POS: Libera el nodo de la cima y retorna en valor la informacion.
Pila apunta al nuevo primer elemento de la estructura o a NULO si queda
Vacia.
Ptr : TPNodo;
ALGORITMO
Ptr Pila;
Valor Ptr^ .info;
Pila Pila^.sgte;
Destruir(Ptr);
FIN
Utiliza un puntero auxiliar para conservar el

inicio de la pila, guarda el valor contenido en ese
puntero, avanza con la estructura y libera el
puntero auxiliar.
Acciones y funciones para Colas

CrearCola(Dato_Resultado ColaFte,ColaFin: TPNodo): una Accion
ALGORITMO
ColaFte = NULO;
ColaFin = NULO;
FIN
Agregar(Dato_Resultado Colafte, Colafin: TPNodo; Dato Valor: Tinfo) una accion
Este procedimiento inserta un nuevo nodo en la cola, se encarga de pedir memoria,
guardar la informacin y actualizar los punteros. En esta estructura siempre ColaFte
retorna el valor del primer nodo, y como se agrega despus del ltimo, el
procedimiento siempre retorna en colafin el nodo que acaba de crear.
LEXICO
PRE
NULO
POS
Colafte Apunta al Inicio o a NULO si esta vaca, Cola Fin al final o

ColaFte apunta al primer elemento de la estructura.
ColaFin apunta al ultimo elemento de la estructura (coincide con el
creado)
Ptr : TPNodo;
ALGORITMO
Se pide memoria se guarda la informacin y el
siguiente del nuevo nodo siempre es el valor
Nuevo(Ptr);
NULO. Para enlazarlo, como vimos, hay dos
Ptr^ <Valor, NULO>;
situaciones posibles cuando es el primer nodo, en
SI (Colafte = NULO)
ese caso el puntero al inicio apunta al nuevo nodo
y cuando ya hay por lo menos un nodo, en ese
ENTONCES
caso se debe enlazar el nuevo nodo a
Colafte Ptr
continuacin del anterior ultimo. En todos los
SI_NO
casos el puntero al ultimo siempre apuntara al
nodo creado.
ColaFin^.sgte = Ptr;
FIN_SI;
ColaFin Ptr
FIN.
Suprimir(Dato_Resultado Colafte, ColaFin: TPNodo; Dato_Resultado Valor: Tinfo)
una accion
Este procedimiento libera el nodo apuntado porcolafte, se encarga de guardar la
informacin contenida en el primer nodo en valor, por lo que este es un parmetro
variable y actualizar los punteros
LEXICO
PRE ColaFte Apunta al Inicio y no esta vacia
POS Libera el nodo de la cima y retorna en valor la informacion.
Colafte apunta al nuevo primer elemento de la estructura o a NULO si queda
Vacia, en ese caso, ColaFin tambien apuntara a nulo.

Ptr : TPNodo;
Utiliza un puntero auxiliar para conservar el
ALGORITMO
inicio de lacolaa, guarda el valor contenido en
Ptr Colafte;
ese puntero, avanza con la estructura y libera el
Valor Ptr^ .info;
puntero auxiliar Si el puntero al inicio apunta a
NULO (cuando saca el ultimo valor), entonces
ColaFte ColaFte^.sgte;
tambien se hace apuntar al puntero auxiliar al
SI (ColaFte = NULO)
valor NULO. La unica vez que el puntero al final
ENTONCES
se modifica, cuando se saca, es en este ultimo
caso.
ColaFin = NULO
FIN_SI;
Destruir(Ptr);
FIN
Acciones y funciones para Listas Ordenadas enlazadas
CrearLista(Dato_Resultado Lista: TPNodo): una Accion
ALGORITMO
Lista = NULO;
FIN
InsertaNodo(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE
POS
Lista Apunta al Inicio o a NULO si esta vacia.

Lista apunta al primer elemento de la estructura.
No retorna la direccion del nodo creado, salvo si es el primero
La estructura queda perfectamente enlazada y ordenada creciente.
Ptr, PtrNuevo : TPNodo;
ALGORITMO
SI (lista = NULO o Valor < Lista^.info
ENTONCES
Nuevo(Ptr);
Ptr^ <Valor, Lista>;
Lista Ptr
SI_NO
Si la lista esta vacia, o el valor a guardar es

menor que el que esta en la primera posicin se
coloca delante del primero con un procedimiento
identico al de insertar en una pila.
Se pide memoria y se guarda la informacion
Nuevo(PtrNuevo);
PtrNuevo^ <Valor, NULO>;
Ptr = Lista;
MIENTRAS (Ptr^.sgte <>NULO y Valor > Ptr^.sgte^.info)
HACER
Pregunta anticipadamente por el valor contenido en el
Ptr ptr^.sgte
nodo siguiente al apuntado por ptr. Si la informacina
FIN_MIENTRAS
ingresar es mayor a la del nodo siguiente debe avanzar
una posicion
PtrNuevo`.sgte Ptr^.sgte;
Ptr^.sgte Ptrnuevo;
FIN_SI;
FIN.
Se enlazan los punteros, como se pregunta por

adelantado, el siguiente del nuevo sera el que es siguiente
al nodo donde salimos que es el inmediato anterior al
nueo valor. El siguiente de ese nodo sea ahora el nuevo.
El nuevo lo colocamos entre el que sealamos con ptr y el
siguiente
InsertaPrimero(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion

LEXICO
PRE
POS
Lista Apunta a NULO porque esta vacia.

Ptr: TPNodo;
ALGORITMO
Nuevo(Ptr);
Ptr^ <Valor, NULO>;
Lista Ptr
FIN.
InsertaDelante(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE
POS
Lista Apunta al Inicio y noesta vacia.

Ptr: TPNodo;
ALGORITMO
Nuevo(Ptr);
Lista Ptr
FIN.
InsertaEnMedio(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE Lista Apunta al Inicio no esta vacia.
POS Lista apunta al primer elemento de la estructura.
No retorna la direccion,queda perfectamente enlazada y ordenada.
ALGORITMO
Nuevo(PtrNuevo);
Ptr = Lista;
HACER
Ptr ptr^.sgte
FIN_MIENTRAS
Ptr^.sgte Ptrnuevo;
FIN.
InsertaAl Final(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion

LEXICO
PRE
POS

No retorna la direccion del nodo creado.
ALGORITMO
ENTONCES
Nuevo(Ptr);
Lista Ptr
SI_NO
Nuevo(PtrNuevo);
Ptr = Lista;
MIENTRAS (Ptr^.sgte <>NULO)
HACER
Ptr ptr^.sgte
FIN_MIENTRAS
Ptr^.sgte Ptrnuevo;
FIN_SI;
FIN.
InsertaNodoPorDosCampos(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una
accion
LEXICO
PRE
POS

Info es un recgistro con al menos dos campos para ordenar
ALGORITMO
SI (lista = NULO) o (Valor.C1 < Lista^.info.C1) o
(Valor.C1 =Lista^.info.C1)y(Valor.C2<Lista^.info.c2)
ENTONCES
Nuevo(Ptr);
Lista Ptr
SI_NO
Nuevo(PtrNuevo);
Ptr = Lista;
MIENTRAS (Ptr^.sgte <>NULO) y ((Valor > Ptr^.sgte^.info) o
((valor.C1 = Lista*.info.C1)y(Valor.C2 >Lista*.info.C2))

HACER
Ptr ptr^.sgte
FIN_MIENTRAS
Ptr^.sgte Ptrnuevo;
FIN_SI;
FIN.
BuscarNodo(Dato Lista: TPNodo; Dato Valor: Tinfo): TPNodo una funcion
LEXICO
PRE
POS
Lista Apunta al Inicio y no esta vacia.

Se busca encontrar el nodo que contenga valor como informacion
Retorna la direccion del nodo con el valor buscado o NULO esta
Ptr : TPNodo;
ALGORITMO
Ptr = NULO;
MIENTRAS (Lista <>NULO Y Ptr = NULO) HACER
SI valor = Lista ^.info
ENTONCES
Ptr = Lista {lo encontro y sale}
SINO
Lista = Lista ^.sgte {avanza al proximo nodo}
FIN_SI
FIN_MIENTRAS
BuscarNodo = Ptr;
FIN.
BuscaOInserta(Dato_Resultado Lista,Ptr: TPNodo; Dato Valor: Tinfo) una accion

LEXICO
PRE
POS

Retorna la direccion del nodo creado, salvo si es el primero
No se repite la clave
PtrNuevo : TPNodo;
ALGORITMO
ENTONCES
Nuevo(Ptr);
Lista Ptr
SI_NO
Ptr = Lista;
MIENTRAS (Ptr^.sgte <>NULO y Valor >= Ptr^.sgte^.info)
HACER
Similar al procedimiento inserta nodo, pero como no
Ptr ptr^.sgte
debe insertar siempre se cambia el orden de las
FIN_MIENTRAS
accines cuando se debe insertar en el medio. En este
caso se busca primero y si no esta se crea el nodo y se
SI (Ptr^.Info <> Valor)
enlazan los punteros. Como ptr en este estado no
ENTONCES
puede valer NULO y el siguiente si el ciclo de
PtrNuevo^.sgte Ptr^.sgte; repeticin se hace modificando el operador de relacion
por >= en lugar de >. Al salir del ciclo si el valor
Ptr^.sgte Ptrnuevo;
contenido en el nodo actual es distinto al buscado
Ptr PtrNuevo;
significa de ese dato no esta en la lista y se debe
FIN_SI;
inserta, de lo contrario no se inserta.
FIN_SI;
FIN.
InsertaNodo2(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE
POS

P,Q,Ptr : TPNodo;
ALGORITMO
Nuevo(Ptr);
Ptr^ <Valor, NULO>;
P Lista;
Q NULO;
MIENTRAS P <> NULO y Valor > p^.info HACER
Q P;
P P^.sgte;
FIN_MIENTRAS;
SI (P = Lista)
ENTONCES
Lista Ptr;
SI_NO
Q^.sgte Ptr;
FIN_SI;
Ptr^.sgte P;
FIN.
SuprimeNodo(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE Lista Apunta al Inicio y no esta vacia
POS Libera el nodo si encentra el valor.
P, Q : TPNodo;
ALGORITMO
P Lista;
Q NULO:
MIENTRAS (P <> NULO y Valor > P^.info) HACER
Q P;
P P^.sgte:
FIN_MIENTRAS;
SI (P <> NULO y Valor = P^.info
ENTONCES
SI Q <> NULO
ENTONCES
Q^.sgte P^.sgte
SI_NO
Lista P^.sgte;
FIN_SI:
Destruir(P):
FIN_SI;
FIN
InsertaNodoListaDoblementeEnlazada(Dato_Resultado Lista: TPNodo; Dato Valor:
Tinfo) una accion
// El Nodo tiene un puntero al nodo anterior y un puntero al nodo siguiente
LEXICO
PRE Lista Apunta al Inicio o a NULO si esta vacia.
<Valor,Siguiente,Anterior>
Se la puede recorrer en ambas direcciones
ALGORITMO
ENTONCES
Nuevo(Ptr);
Ptr^ <Valor, Lista,NULO>;
SI lista <> NULO
ENTONCES
Lista^.anterior Ptr
Lista Ptr
SI_NO
Nuevo(PtrNuevo);
PtrNuevo^ <Valor, NULO,NULO>;
Ptr Lista;
HACER
Ptr ptr^.sgte
FIN_MIENTRAS
PtrNuevo^.sgte Ptr^.sgte;
PtrNuevo^.ant Ptr;
Ptr^.sgte Ptrnuevo;
SI PtrNuevo^.sgte <> NULO
ENTONCES
PtrNuevo^.sgte.ant = PtrNuevo;
FIN_SI;
FIN_SI;
FIN.
ApareoDeListas(Dato_Resultado ListA,ListB,ListAB) una accion
LEXICO
PRE ListA y ListB Listas ordenadas simplemente enlazadas.
POS ListAB Lista enlazada producto del apareo de las listas dato.
Ptr : TPNodo; Puntero auxiliar para insertar como cola
VA,VB,VAB: TipoInfo el valor asociado a cada nodo de la lisra
ALGORITMO
ListAB = NULO;
Ptr = NULO;
MIENTRAS (ListA <> NULO) O (ListB <> NULO) HACER
SI ((ListB = NULO)O((ListA<>NULO)Y(ListA^.info<ListB^.info)))
ENTONCES
VAB = VA
SI_NO
VAB = VB
FIN_SI
Agregar(ListAB,Ptr,VAB);
FIN_MIENTRAS;
Ptr = NULO;
FIN.
ListaParalelaParaAgrupar(Dato_Resultado ListA, Dato ArchDatos,ArchProceso :
TipoArchivo) una accion
LEXICO
PRE ListA Lista Paralela al archivo de datos, con tantos nodos como registros tiene
ese archivo. Las restricciones del nodo no alcanzan para poner la clave de ordenamiento
y solo se puede poner un campo que agrupe datos del archivo de proceso.
ArchDatos es el archivo de datos personales, contiene todas las claves, esta ordenada
por esa por lo que es posible hacer bsqueda binaria. ArchProceso es el archivo a
procesar contiene la clave por la que se vincula con el archivo de datos con lo que esta
ordenado.
Se busca hacer una lista paralela para agrupar evitando busquedas secuenciales en
archivos.
POS ListA contendra el valor acumulado de cada clave del archivo de datos
relacionados posicionalmente.
ALGORITMO
ListA = NULO;
PARA I [1 .. CantidadRegistros(ArchDatos)] HACER
InsertaDelante(ListA, 0);
//Crea la lista con los contadores en cero//
FIN_PARA
MIENTRAS (HayaDatos(ArchProceso)) HACER
LeerRegistro(ArchProceso, Registro);
BusquedaBinaria(ArchDatos, Registro.Clave; Pos);
Ptr = Lista;
Para J [1 .. Pos] HACER
Ptr = Ptr*.sgte;
FIN_PARA
Incrementar(Ptr*.info, Registro.Agregado);
FIN_MIENTRAS;
FIN.
ListaParalelaParaBuscar(Dato_Resultado ListA, Dato ArchDatos,ArchProceso :
TipoArchivo) una accion
LEXICO
PRE ListA Lista Paralela al archivo de datos, con tantos nodos como registros tiene
ese archivo. Las restricciones del nodo no alcanzan para poner la posicin en el
archivoclave de ordenamiento y solo se puede poner un campo que agrupe datos del
archivo de proceso.
ArchDatos es el archivo de datos personales, contiene todas las claves, No esta
ordenado lo que no es posible hacer busqueda directa ni bsqueda binaria.Se lo carga
en una lista como cola para poder buscar en la lista y luego accedre al archivo segn el
numero de nodo
ArchProceso es el archivo a procesar contiene la clave por la que se vincula con el
archivo y hay que ir a buscar un valor.
Se busca hacer una lista paralela, cargada como cola para buscar evitando busquedas
secuenciales en archivos.
POS ListA contendra el la clave de busqueda y para cada clave del archivo de datos
se relacionan posicionalmente segn el numero de nodo.
ALGORITMO
ListA = NULO;
Aux = NULO
PARA I [1 .. CantidadRegistros(ArchDatos)] HACER
Leer(Registro(ArchDatos, Registro)
Agregar(ListA, Aux, Registro.clave);
//Crea la lista con la clave a buscar//
FIN_PARA
Aux = NULO // Para que el resultado sea una lista y no una cola
MIENTRAS (HayaDatos(ArchProceso)) HACER
LeerRegistro(ArchProceso, Registro);
Ptr = Lista;
NumeroNodo = 0;
MIENTRAS Ptr*.info <> Registro.clave HACER
Ptr = Ptr*.sgte;
Incrementar(NumeroNodo);
FIN_MIENTRAS
AccesoDirectoArchivo(ArchDatos, NumeroNodo);
LeerRegistro(ArchDatos, RegistroDatos);
Imprimir(Registrodatos.Otra clave);
FIN_MIENTRAS;
FIN.
InsertaNodoListaCircular(Dato_Resultado Lista: TPNodo; Dato Valor: Tinfo) una
accion
//El Puntero a una lista circular apunta al predecesor al primer elemento
LEXICO
PRE Lista Apunta al al predecesor al primer elemento.
Lista no vacia, al menos un nodo
Si hay un solo nodo apunta a si mismo
Ptr, Auxiliar : TPNodo; Salir Booleano;
ALGORITMO
Nuevo(Auxiliar);
Aux^ <Valor, NULO>;
Lista Ptr
SI (lista = NULO)
ENTONCES
Auxiliar^.sgte = Auxiliar;
Lista = Auxiliar;
SI_NO {La lista no esta vacia}
Ptr = Lista;
Salir = FALSO
REPETIR
SI (Ptr^.sgte^.info< Valor)
ENTONCES
Ptr ptr^.sgte
SINO
Salir = Verdadero
FIN_SI
HASTA Salir o Ptr = Lista
Auxiliar^.sgte Ptr^.sgte;
Ptr^.sgte Auxiliar;
SI (Salir = FALSO)
ENTONCES
Lista = Auxiliar
FIN_SI; {de la lista no vacia}

FIN.
Acciones y funciones para arboles
RecorrerEnOrdenArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion
//El Nodo tiene puntero al hijo izquierdo Y derecho
LEXICO
PRE Arbol Apunta al nodo raiz o es Nulo.
POS Recorre la estructura completa en orden.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
RecorrerEnOrdenArbol(Arbol^.izquierdo);
Imprimir(Arbol*.info);
RecorrerEnOrdenArbol(Arbol^.Derecho);
FIN_SI;
FIN.
RecorrerPreOrdenArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
POS Recorre la estructura completa en pre orden.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
RecorrerPreOrdenArbol(Arbol^.izquierdo);
RecorrerPreOrdenArbol(Arbol^.Derecho);
FIN_SI;
FIN.
RecorrerPosOrdenArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
Pre
Arbol Apunta al nodo raiz o es Nulo.
POS Recorre la estructura completa pos orden.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
RecorrerPosOrdenArbol(Arbol^.izquierdo);
RecorrerPosOrdenArbol(Arbol^.Derecho);
FIN_SI;
FIN.
RecorrerEnOrdenInArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion

LEXICO
POS Recorre la estructura completa en orden inverso.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
RecorrerEnOrdenInArbol(Arbol^.derecho);
RecorrerEnOrdenArbol(Arbol^.Izquierdo);
FIN_SI;
FIN.
RecorrerPreOrdenInArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
POS Recorre la estructura completa en pre orden inverso.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
RecorrerPreOrdenInArbol(Arbol^.Derecho);
RecorrerPreOrdenArbol(Arbol^.Izquierdo;
FIN_SI;
FIN.
RecorrerPosOrdenInArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
POS Recorre la estructura completa pos orden inverso.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
RecorrerPosOrdenArbol(Arbol^.derecho);
RecorrerPosOrdenArbol(Arbol^.izquierdo;
FIN_SI;
FIN.
RecorrerEnAnchoPrimero(Dato Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE Arbol Apunta al nodo raiz no es Nulo.
POS Recorre la estructura completa ancho primero.
Fte, Fin: TPNodo

// Saca el nodo del rbol y lo va cargando en una cola, un nodo hay. Luego recorre hasta
que la cola quede vaca. Por cada nodo que va recorriendo, y como solo puede tener dos
hijos por ser binario, si hay nodo izquierdo lo agrega en la cola, si hay derecho tambin
lo agrega (esto asegura el recorrido en ancho primero). Al colocar el nodo completo del
rbol en la cola, cuando se saca se tienen los enlaces a los hijos, si es que tiene.//
ALGORITMO
Fte = NULO;
Fin = NULO;
Agregar(Fte, Fin, Arbol);
Mientras (Fte <> NULO) HACER
Suprimir(Fte, Fin, Arbol);
SI (Arbol*.izq<>NULO
ENTONCES
Agregar(Fte, Fin, Arbol*.izq)
FIN_SI
SI (Arbol*.der<>NULO
ENTONCES
Agregar(Fte, Fin, Arbol*.der)
FIN_SI;
FIN_MIENTRAS;
FIN.
InsertarNodoArbol(Dato_Resultado Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
PRE Arbol Apunta al nodo raiz o es Nulo.<izquierdo, info, derecho>
Las Inserciones se hacen siempre en las hojas
POS Inserta un nodo ordenado
ALGORITMO
SI (Arbol = NULO)
ENTONCES
Nuevo(Arbol);
Arbol^ <NULO, Valor, NULO>;
SINO SI (Valor<Arbol^.info)
ENTONCES
InsertarNodoArbol(Arbol^.izquierdo, Valor)
SINO SI (Valor>Arbol^.info)
ENTONCES
InsertarNodoArbol(Arbol^.izquierdo, Valor)
SINO ERROR
FIN_SI
FIN_SI
FIN_SI;
FIN.
CantidadHojasArbol(Dato Arbol: TPNodo): Entero una funcion;
Eshoja(Dato Arbol): Booleano una funcion;
ALGORITMO
EsHoja (Arbol^.izquierdo = NULO) Y (Arbol^.derecho = NULO;
FIN /*EsHoja
ALGORITMO
SI (Arbol <> NULO)
ENTONCES SI (EsHoja(Arbol))
ENTONCES
CantidadHojas = 1;
SINO
CanidadHojas CantidadHojas(Arbol^.izquierdo) +
CantidadHojas(Arbol^.derecho);
SINO
CantidadHojas = 0;
FIN_SI;
FIN.
AlturaArbol(Dato Arbol: TPNodo): Entero una funcion;
Maximo(Dato A, B : Entero): Entero una funcion;
ALGORITMO
SI (A > B)
ENTONCES
Maximo = A;
SINO
Maximo = B;
FIN_SI
FIN /*Maximo
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
1
AlturaArbol
Maximo(AlturaArbol(Arbol^.izquierdo),AlturaArbol(Arbol^.derecho))
SINO
AlturaArbol -1
FIN_SI;
FIN.
BuscarEnArbol(Dato Arbol: TPNodo; Dato Valor: Tinfo): Booleano una funcion
LEXICO
Busca el dato contenido en Valor
POS Retorna Verdadero si lo encuentra o falso en caso contrario.
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
Si (Valor< Arbol^.info)
ENTONCES
BuscarEnArbol BuscarEnArbol(Arbol^.izquierda, valor)
ENTONCES
BuscarEnArbol BuscarEnArbol(Arbol^.derecho, valor)

SINO
BuscarEnArbol VERDADERO
FIN_SI
FIN_SI
SINO
BuscarEnArbol FALSO;
FIN_SI;
FIN.
Borrar(Dato_Resultado Arbol: TPNodo; Dato Valor: Tinfo) una accion
LEXICO
POS Busca el dato contenido en Valor y si lo encuentra libera el nodo
BorrarInOrder(Dato_Resultado Arbol)
ALGORITMO
SI (Arbol^.derecho<> NULO
ENTONCES
BorrarInOrder(Arbol^.derecho)
SINO
Auxiliar^.info Arbol^.info;
Auxiliar Arbol;
Arbol Arbol^.izquierdo;
FIN_SI
FIN
ALGORITMO
SI (Arbol <> NULO)
ENTONCES
Si (Valor< Arbol^.info)
ENTONCES
Borrar(Arbol^.izquierda, Valor)
ENTONCES
Borrar(Arbol^.derecho, valor)
SINO /* en este estado lo encontro*/
Auxiliar = Arbol;
SI (Arbol^.derecha = NULO)/* No tiene hijo derecho
ENTONCES
Arbol = Arbol^.Izquierda
SINO SI(Arbol^.izquierda = NULO)
ENTONCES
Arbol = Arbol^.derecha
SINO
BorrarInOrder(Arbol^.izquierdo)
FIN_SI
FIN_SI
Liberar(Auxiliar);
FIN_SI
FIN_SI
SINO
ERROR;
FIN_SI;
FIN.
Inserciones en arboles AVL
Insercion en el sularbol izquierdo de la rama izquierda de A
Rotacion Simple Izquierda Izquierda
N1^.izquierdo N1^.derecho (N es el nodo desbalanceado N1 su hijo izquierdo)
N1^.derecho N1
N N1
Insercion en el sularbol derecho de la rama izquierda de A
Rotacion Doble derecha Izquierda
N1^. izquierdo N2^. derecho
N2^. derecho N1
N^. derecho N2^. izquierdo
N2^.izquierdo N
N N2
Insercion en el sularbol derecho de la rama derecha de A
Rotacion Simple Derecha Derecha
N1^.derecho N1^. izquierdo (N es el nodo desbalanceado N1 su hijo derecho)
N1^.izquierdo N1
N N1
Insercion en el sularbol izquierdo de la rama derecha de A
Rotacion Doble Izquierda derecha
N1^. derecho N2^. izquierdo
N2^. izquierdo N1
N^.izquierdo N2^.derecho
N2^.derecho N
N N2
Funciones recursivas
El flujo de control de una funcin recursiva requiere tres condiciones para una
terminacin normal:
1. Un test para detener o continuar con la recursion.
2. Una llamada recursiva para continuar la recursion
3. Un caso base para terminar la recursion
Recursividad
SI (Es el caso base)
ENTONCES
Ejecutar la accion final
Terminr recursion
SINO
Ejecutar accion para cercar a la solucion

Invocar nuevamente a la funcion
Factorial
(Dato N : Entero): Entero una funcion;
ALGORITMO
SI (N = 0)
ENTONCES
Factorial = 1
SINO
Factorial = N * Factorial(N-1)
FINSI
FIN.
Fibonacci
(Dato N : Entero): Entero una funcion;
ALGORITMO
SI (N = 0) O (N = 1)
ENTONCES
Fibonacci = N
SINO
Fibonacci = Fibonaci(N-2)+Fibonacci(N-1)
FINSI
FIN.
EuclidesMaxCD
(Dato M,N : Entero): Entero una funcion;
ALGORITMO
SI (N <= M) Y (M Modulo N = 0)
ENTONCES
EuclidesMaxCD = N
SINO SI (M<N)
ENTONCES
EuclidesMaxCD(N,M)
SINO
EuclidesMaxCD(N, M Mod N)
FINSI
FIN.
Hanoi
(Dato Inicio, Medio, Centro : Crter: N : Entero): NULO una funcion;
ALGORITMO
SI (N = 1)
ENTONCES
Imprimir(Mover Disco N de inicial a final)
SINO
Hanoi(Inicial, Final, Central, N- 1);
Imprimir(Mover Disco N de inicial a final)
Hanoi(Central, Final, Inicial, N- 1);
FINSI
FIN.
Recursividad indirecta
Funcion mutuamente reursiva implementdas en C
Imprimir los carcteres del alfabeto ingles
# incluye <stdio.h>
void FuncionA(char c);
void FuncionB(char c);
int main()
{
FuncionA(Z);
Return 0;
}
void FuncionA(char c)
{
if( c > A )
FuncionB(c);
Printf(%c,c);
}
void FuncionB(char c)
{
FuncionA(--c);
}
Determinar si un numero es par
# incluye <stdio.h>
void FuncionPar(int n);
void FuncionImpar(int n);
int main()
{
if (FuncionPr(9))
printf(Es par);
else
printf(Es Impar);
return 0;
}
int FuncionPar(int n)
{
if (n == 0)
return 1;
else
return FuncionImpar(n-1);
}
int FuncionImpar(int n)
{
if (n == 0)
return 0;
else
return FuncionPar(n-1);
}
Archivos en pascal
Pascal Dispone del tipo de dato text que permite vincular a una variable interna con un
archivo de texto.
En el caso de C los nombres internos se declaran como un puntero a una struct FILE, y
la discriminacion del tipo, texto o binario se realiza en la apertura
Para trabajar con archivos de texto en Pascal se debe:
1.
Declarar el nombre lgico del archivo con un identificador de tipo text.
2.
Relacionar el nombre interno o lgico con l externo o fsico, mediante
Assign.
3.
Abrirlo con Reset o Rewrite segn corresponda.
En el ejemplo que sigue se desarrollan las acciones para lectura completa de un archivo
de texto. Se lee
1.
Carcter a carcter.
2.
Por lnea completa.
3.
Con formato
a.
En datos simples
b.
En registros
program LeerCaracteres;
{Lee un archivo de texto caracter a caracter y lo muestra por pantalla}
Arch : text;
Letra : char;
begin
Assign (Arch,'C:\....\archivo.txt');
Reset(Arch);
while not EOF(Arch) do
begin
{Lectura caracter a caracter}
read(Arch, Letra);
write(Letra);
end;
Close(Arch);
End.
program LeerPorLineas;
Arch : text;
Nombre : string;
begin
Assign (Arch,'C:\...\archivo.txt');
Reset(Arch);
begin
{Lectura por linea}

readln(Arch, nombre);
writeln(nombre);
end;
Close(Arch);
End.
program LeerConFormato;
var
Arch : text;
Entero : Integer;
Texto : string[10];
begin
Reset(Arch);
begin
{Lectura con formato}
readln(Arch, Entero, Texto);
writeln('Este es el entero : ', Entero:8);
writeln('Este es el texto : ', Texto:8);
end;
Close(Arch);
End.
program LeerConFormatoEnRegistro;
TipoRegistro = Record
Numero : Integer;
Cadena : string[10];
End;
var
Arch : text;
Registro : TipoRegistro;
begin
Reset(Arch);
begin
{Lectura con formato en regitro}
readln(Arch, Registro.Numero, Registro.Cadena);
writeln('El entero del reg.: ', Registro.Numero:8);
writeln('El texto del re. : ', Registro.Cadena:8);
end;
Close(Arch);
End.
Los archivos de tipo o de acceso directo es una coleccin de datos del mismo tipo con
almacenamiento sin interpretar y guardadas segn su representacin interna. Solo se
pueden comparar como iguales si son ledos del modo en que fueron escritos Requieren
en pascal que para poder utilizarlos se deba hacer y en orden los siguientes pasos
1.
2.
3.
El la clusula Type definir los tipos

a. Para el registro si corresponde, o podria evitarse se se utilizan archivo de
de tipos de datos primitivos
b. Para el archivo NombreDelTipo = FILE OF TIPO DE DATO
Declarar las variables en la clausula Var
a. Una para el archivo
b. Otra para el tipo de dato de cada posicin.
Asignar y abrir los archivos
a. La asignacin a traves de ASSIGN vinculando el nombre interno con el
externo.
b. La apertura segn corresponda con Reset o Rewrite
Lo disponible para archivos, una vez en condiciones de ser operados es:

1.
2.
3.
4.
5.
6.
7.
8.
Lectura Read(Archivo, TipoDeDato) En el caso de ser un registro se lee

completo.
Grabar Write(NombreInterno, TipoDeDato)
Seek(NombreInterno,Posicin), Ubica el Puntero a Pos Registros
desplazados desde el inicio del mismo
Flesize(NombreInterno) Indica cantidad de registros.
Filepos(NombreInterno) retorna la posicin actual del puntero. Tambien
cantidad de registros de desoplazamiento desde el inicio del archivo.
Tanto filepos como filesize retonan un tipo de dato entero largo, pero pueden
ser contenido en un entero de menor jerarquia mientras no se produzca
desbordamiento del mismo.
EOF(NombreInterno) Retorna true si se alcanzo la marca de fin de archivo y
False en caso contrario.
Truncate(NombreInterno) pone la marca de fin de archivo en el lugar donde
esta el puntero. Trunca el archivo
program ConvierteTextoABinario;
Type
Numero : Integer;
End;
TipoArchivo = FILE OF TipoRegistro;
var
Arch : text;
Binario : TipoArchivo;
I
: Integer;
begin
clrscr;
Assign (Arch,'C:\borlandc\archivo.txt');
Reset(Arch);
Assign (Binario,'C:\...\Binario.Dat');
Rewrite(Binario);
begin
{Lectura con formato en regitrode un archico de texto

y lo almacena en un archivo binario}
readln(Arch, Registro.Numero, Registro.Cadena);
write(Binario,Registro);
end;
Close(Arch);
Close(Binario);
End.
program RecorrerBinario;
uses crt;
Type
Numero : Integer;
End;
var
Arch : text;
begin
Reset(Binario);
while not EOF(Binario) do
begin
{Lectura con formato en regitro del archivo Binario}
read(Binario, Registro);
writeln('El entero del Bin.: ', Registro.Numero:8);
writeln('El texto del Bin. : ', Registro.Cadena:8);
end;
Close(Binario);
end.
program RecorreBinarioInverso;
Type
Numero : Integer;
End;
Var
I
: Integer;
Begin
Reset(Binario);
For i := FileSize(Binario) - 1 downto 0 do
begin
{Lectura con formato en regitro del archivo Binario

en orden inverso}
Seek(Binario,I);
read(Binario, Registro);
writeln('El entero del Bin.: ', Registro.Numero:8);
writeln('El texto del Bin. : ', Registro.Cadena:8);
end;
Close(Arch);
Close(Binario);
end.
Ejemplo en C con aplicaciones de estructuras enlzadas

/* Toma una cadena que representa una expresin aritmtica y la convierte a notacin
sufijo usando procedimientos de pilas*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef char TipoInfo;
typedef struct tiponodo {
TipoInfo
Info;
struct tiponodo *sgte;
} TipoNodo;
typedef TipoNodo* TipoPuntero;
void Meter(TipoPuntero *pila , TipoInfo valor);
void Sacar(TipoPuntero *pila , TipoInfo *valor);
void Sufijo(char * cadena, char * suf);
int main()
{
char cad1[10];
clrscr();
Sufijo("5*8+3",cad1);
printf("%s\n", cad1);
getchar();
return 0;
}
void Sufijo(char * cadena, char * suf)
{
char c;
int i = 0,j=0;
TipoPuntero pila=NULL;
c = cadena[i];
while (c) {
switch(c) {
case '+':
case '-':
case '*':
case '(':
case '/': Meter(&pila, c); break;
case ')': Sacar(&pila, &c);
while (c != '(') {
suf[j++] = c;
Sacar(&pila, &c);
} break;
default : suf[j++]= c; break;
}
i++;
c=cadena[i];
}
while(pila){
Sacar(&pila,&c);
suf[j++]=c;
}
suf[j] = '\0';
}
void Meter(TipoPuntero *pila , TipoInfo valor)

{
TipoPuntero ptr;
ptr =(TipoPuntero) malloc(sizeof(TipoNodo));
ptr -> Info = valor;
ptr -> sgte = *pila;
*pila
= ptr;
}
void Sacar(TipoPuntero *pila , TipoInfo *valor)
{
TipoPuntero ptr;
ptr = *pila;
*pila = (*pila)->sgte;
*valor = ptr->Info;
free(ptr);
}
ANEXO 1 Representaciones grficas de algoritmos

Diagrama de Nassi-Sneiderman
Condicin 1
T
Accin 1
Accin 5
Accin 2
Mientras condicin 3
Condicin 2
T
Accin 6
F
Accin 3
Accin 7
Accin 8
Accin 9
Accin 4
Accin 10
Accin 11
Accin 12
Repetir hasta condicin 4
Diagramas de Jackson
Diagramas de Lindsay.
PASCAL
DIAGRAMA DE DETALLE
Variable expresin
Variable = expresin
READ (var1, var2,....var n)
var1, var2,....
WRITELN var 1 var 2

(
, ..... )
WRITE
liter1 liter2
var 1
liter1
IF condicin
THEN
sentencia 1
ELSE
sentencia 2
,....
liter2
Condicin
Instruccin 1
Instruccin 2
Condicin
WHILE condicin
DO
sentencia
Instruccin
REPEAT
sentencia;
:
:
sentencia n
UNTIL condicin
FOR variable: expres1
var 2
Instruccin 1
:
:
Instruccin n
Condicin
TO
expres2
DOWNTO
Var: exp1, exp2
Instruccin
DO sentencia
CASE expresin
OF
const1....... const n : instruccin1
:
:
const1...... const p : instruccin m
END
Cualquier sentencia puede ser reemplazada por
un bloque:
BEGIN
sentencias 1;
:
:
sentencias n
END
Expresin
Const1... Const n
Const1... Const p
Instruccin1
Instruccin m
Correspondiendo en el diagrama de detalle

la secuencia:
instruccin 1;
:
:
instruccin n
Llaves de Warniel
HacerUnaCosa)
Si
Condicin
Exclusin
No
1
Algoritmo
Case
Ordinal
Mientras
Condicin
HacerOtraCosa
Vacio
2
HacerUnaCosa;
HacerOtraCosa;
HacerAlgoMas
Notacin Algoritmica
Accin 1
ALGORITMO
Equivalencias entre notacin algortmica y lenguajes de programacin

CONDICIONAL
Formato
SI Condicion
ENTONCES
S
SI_NO
R
FIN_SI
Pascal
If expresion condicional
Then
S
Else
R;
C
If (expresion)
S;
Else
R;
Formato
SEGN expr
V1 : S1
V2 : S2
EN_OTRO_CASO : Sn
FIN_SEGN
Pascal
Case selector of
Valor1 : S1;
.........................
else Ve: Se;
end;
C
switch (selector) {
case etiqueta:S; break;
..............................
default: R;
}
ITERACION
Formato
S
FIN_MIENTRAS
Pascal
While Expresion logica do
S;
C
while(expresion)
S;
Formato
REPETIR
S
HASTA Cond
Efecto
Repeat
S
Until expresion logica
do
S;
while(expresion)
Formto
S
FIN_PARA
Efecto
For i:=Vi to vf do
S;
for(i=0;i<vf;i++)
S;
Estilos de Indentacin
Recomendacion de estilos de indentacion para desarrollos ms claros y legibles.(Ing. J.
M. Sola)
Estilo The One True Brace Style
HacerUnaCosa();
HacerOtraCosa();
}
BSD/Allman.
{
HacerUnaCosa();
HacerOtraCosa();
}
Estilo Whitesmiths
{
HacerUnaCosa();
HacerOtraCosa();
}
Estilo GNU
{
HacerUnaCosa();
HacerOtraCosa();
}
Estilo Pico
while( SeaVerdad()
{
HacerUnaCosa();
HacerOtraCosa(); }
Estilo Banner
HacerUnaCosa();
HacerOtraCosa();
}
BIBLIOGRAFIA
Behrouz Forouzan. Introduccin a la ciencia de la computacin. 2005. Ciencias e
Ingenieria.
De Giusti. Algoritmos datos y programas. 2001. Prentice Hall.
Garcia Molina. Una introduccin a la programacin. 2005. Thomson.
Kernighan - Ritchie. El lenguaje de programacion C. 1988. Pearson
Kerighan Pike. La practica de la programacion. 2000. Pearson
Perkins David. La baera de Arquimedes y otras historias del descubrimiento
cientifico. Paidos 2004
Iranzo, j. Logica simbolica para informaticos. 2006. Alfaomega.
Perez M. Matematica discreta y algoritmos. 2005. Answer.
Joyanes Aguilar, L.Algoritmos y estructura de datos, una perspectiva en C. 2004
Mc Graw Hill
El Autor
Oscar Ricardo Bruno
Formacin Academica
Doctorando en educacin UnTref
Licenciado en Sistemas (Instituto Tecnologico de Buenos Aires)
Magster en Docencia Universitaria UTN FRBA
Especialista en Ingenieria en Sistemas (Maestrando) UTN FRBA
Especialista en Docencia Universitaria UTN FRBA
Profesor en Docencia Universitaria en Sistema INSPT UTN FRBA
Espeialista en Investigacin Operativa ESIO DIGID.
Miembro de la Sociedad Argentina de Estudios Comparados en Educacion
Actividad Docente
Director IAFIP. Instituto Argentino de Formacin e Investigacin en Programacion
Profesor Adjunto Algoritmos y Estructura de Datos y Sintaxis y Semntica de Lengujes
UTN FRBA .
Profesor Adjunto Estructura de Datos Univeridad del Salvador
Profesor Titular Laboratorio II y III Escuela Tecnica Nro 1 Otto Krause
Coordinador Area Computacin EIOK
Director y jurado de tesis UTN FRBA
Ex Consejero Departamental docente UTN FRBA departamento Sistemas.
Menciones
Finalista premios Sadosky 2006 - 2007 a la inteligencia argentina categora calidad
docente

LibroProgramacion PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

LibroProgramacion PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Programacin y

Lic. Oscar Ricardo Bruno, MDU

Acceso a datos mediante apuntadores _________________________________ 53

Diagramas de Jackson _____________________________________________ 116

2. Diseo de la solucin: Lo primero es la modularizacin del problema, es decir la

Durante la tarea de integracin final, se descartan aquellas primeras ideas provisionales

algoritmo logre el objetivo, es necesario ponerlo a prueba; a esto se le llama

Medidas de eficiencia para N = 10.0000

Representaciones grficas de algoritmos

Repetir hasta condicin 4

READ (var1, var2,....var n)

WRITELN var 1 var 2

Var: exp1, exp2

Correspondiendo en el diagrama de detalle

Asignacin - Control Iteracin

Almacena en una direccin de memoria un valor obtenido desde un dispositivo o flujo

Estructura de decisin simple completa. Procesa acciones por la condicin de

Estructura de decisin Mltiple. Es una estructura de seleccin entre varios valores,

Ejemplos con uso de acciones primitivas de asignacin, entrada- salida y

Ejemplos con anlisis de casos

PROBLEMA: Comprobar si una fecha es correcta

Solucin alternativa utilizando la propuesta Jorge Muchnik [JDM]

Composiciones iterativas No Exactas

Pre-condicionales. Estas evalan la condicin y si es verdadera se ejecuta el bloque de

Pos-condicionales. Primero se ejecuta el bloque de acciones y luego se evala la

ALGORITMO // Composicin iterativa mientras

ALGORITMO // Composicin iterativa repetir hasta

N N + 1 ; // Cuenta los alumnos

ALGORITMO // Composicin iterativa para

N N + 1 ; // Cuenta los alumnos

El analisis es simple desde el punto de vista

Datos de salida M identificador que contendr al valor mximo

//Bsqueda con una cantidad conocida de datos

Alternativa de solucin reemplazando el anlisis de casos con la notacin [JDM]

Equivalencias entre notacin algortmica y lenguajes de programacin

Alcance de los datos

Un parmetro tambin cuenta con una caracterstica: la direccin de memoria en la que

El programador solo debe preocuparse por que se cumpla la precondicin al invocar la

Beneficios del uso de acciones

Funcin que obtenga el mayor de tres nmeros

Las funciones siempre retornan un unico

1. Crear una estructura

//Define un puntero que en cada instancia generara un nodo.

Para la creacin de un nuevo objeto apuntado dispondremos de la accin Nuevo. Esta

Acceso a datos mediante apuntadores

Apilar : Pila X TipoBase Pila

Algoritmo de la funcin "push" Apilar:

2. Ultimo^,siguiente apunte a nodo.

El proceso es muy simple

Insertar un elemento en la primera posicin de una lista:

Si la lista slo tiene un nodo, el proceso es tambin vlido, ya que el valor de

Si el nodo a eliminar es el ltimo, es procedimiento es igualmente vlido, ya que

ltimo elemento de una lista:

Implementacin de algoritmos para listas

PRE { 1 pos Long(lis) }

Operaciones bsicas con listas circulares

El proceso es muy simple:

Aadir elemento en una lista circular no vaca:

El proceso sigue siendo muy sencillo:

Aadir elemento en una lista circular, caso general:

Eliminar el nico nodo en una lista circular:

1. Se copia el contenido del nodo^.siguiente sobre el contenido de nodo.

Nodo = (header, comn) // enumera dos valores posibles si es header o comn.

((valor.C1 = Lista.info.C1)y(Valor.C2 >Lista.info.C2))