Portafolio Jonathan

CARRERA DE INGENIERIA EN SISTEMAS INFORMATICOS
UNIVERSIDAD TECNICA DE MANABI FACULTAD DE CIENCIAS INFORMATICAS
PORTAFOLIO DE ESTRUCTURA DE DATOS

Alumno: MOREIRA VASQUEZ JONATHAN RICARDO
Docente: ING. CRISTIAN TORRES
2013
FACULTAD DE CIENCIAS INFORMTICAS
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS TABLA DE CONTENIDOS
FASE 1: Prontuario del curso FASE 2: Carta de presentacin FASE 3: Autorretrato FASE 4: Diario meta cognitivo FASE 5: Materiales relacionados con la clase
UNIVERSIDAD TCNICA DE MANAB

CARRERA DE INGENIERA EN SISTEMAS INFORMTICOS
FACULTAD DE CIENCIAS INFORMTICAS SYLLABUS
I.- INFORMACIN GENERAL FACULTAD/DEPARTAMENTO: FACULTAD DE CIENCIAS INFORMTICAS CARRERA: INGENIERA EN SISTEMAS INFORMTICOS ASIGNATURA/MDULO: ESTRUCTURA DE DATOS CDIGO: OF-0201 Nivel / Semestre: 2 N de Crditos:5 Modalidad : Presencial Paralelo: 2do. B Perodo Acadmico: Sept. 25/2012 Feb 14/2013 rea Acadmica: SOFTWARE PRERREQUISITO (S): CORREQUISITO (S):
CONTENIDOS DISCIPLINARES QUE DEBEN SER APROBADAS ANTES DE CURSAR ESTE CONTENIDO DISCIPLINAR CDIGO CONTENIDOS DISCIPLINARES QUE DEBEN SER CURSADOS AL MISMO TIEMPO QUE ESTE CONTENIDO DISCIPLINAR CDIGO
PROGRAMACIN I
OC-0100
DOCENTE: Ing. CHRISTIAN RONALD TORRES MORN Ttulo: MAGITER EN GERENCIA EDUCATIVA E-mail: crtorres@utm.edu.ec Datos personales: Profesor contratado a tiempo completo de la asignatura Estructura de Datos, y Herramientas Web
Director de Tesis de Ingeniera en Sistemas Informticos, miembro de los equipos de Vinculacin con la sociedad, Docente Tutor de pasantas pre profesionales, coautor del manual de Estructura de Datos junto a la Ing. Esthela San Andrs Lz, coautor del folleto de flujogramas para NBU.
II.- RUTA FORMATIVA a.- DEL PERFIL DE EGRESO: Competencia/Resultado de Aprendizaje: Competencia: Resultado de Aprendizaje:
3. Construye soluciones informticas de calidad que mejoren la eficiencia y eficacia de una organizacin haciendo uso correcto de la tecnologa. a. Capacidad de planificar, disear, conducir e interpretar resultados de experimentos orientados a la informtica.
b.- OBJETIVO GENERAL DE LA ASIGNATURA: c.- DESCRIPCIN DE LA ASIGNATURA:
Capacitar al estudiante con los conocimientos significativos en administracin de memoria dinmica y herramientas tiles en los diseos, construcciones y usos principales de algoritmos en la estructuracin de datos lineales y no lineales La materia introduce al estudiante a los conceptos y aplicacin en la administracin de memoria, aplicando programacin estructurada y orientada a objetos, permite conocer la estructura bsica operacional de la memoria RAM y de los grandes diseos de software, aplicando C++ el estudiante desarrollar proyectos cientficos tanto con interfaces en modo grfico y en modo texto, tomando como referencia aplicaciones en el campo general de otras carreras.
III.- RESULTADOS DE APRENDIZAJE DE LA ASIGNATURA Resultados del Aprendizaje (Objetivos Especficos) Formas de Evidenciarlos
(Apreciacin)
Niveles del resultado de aprendizaje
Ponderacin
Describir la definicin de la estructura de datos, los tipos de datos simples, bsicos y compuestos en un ensayo tcnico con: descripcin general del tema clara; ideas que tienen relacin, claridad y objetividad con el tema; y una conclusin clara con aporte personal.
NIVEL ALTO: 86-100
1.- Identificar los tipos estructurados de datos estticos y dinmicos empleados en la creacin de aplicaciones, considerando los lenguajes de programacin. (Nivel Taxonmico: Conocimiento)
1.- Pruebas escritas, orales (fotos), talleres, informes de ensayo, investigacin y Prcticas en el Lenguaje de programacin C++.
Describir la definicin de la estructura de datos, los tipos de datos simples, bsicos y compuestos en un ensayo tcnico con: descripcin general del tema confusa; pocas ideas que tienen relacin, claridad y objetividad con el tema; y una conclusin confusa con aporte personal.
NIVEL MEDIO 71-85
Describir la definicin de la estructura de datos, los tipos de datos simples, bsicos y compuestos en un ensayo tcnico con: descripcin general del tema confusa; poca o ninguna idea que tienen relacin, claridad y objetividad con el tema; y una conclusin confusa sin aporte personal.
NIVEL BSICO 70
2.- Elaborar aplicaciones dinmicas de estructura lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales. (Nivel Taxonmico: Aplicacin)
Comparar con la utilizacin de un cuadro comparativo tres semejanzas y tres diferencias entre los tipos de datos que permiten almacenar ms de un dato; reflejando las relaciones de las comparaciones con ideas claras.
NIVEL ALTO: 86-100
Comparar con la utilizacin de un cuadro comparativo tres semejanzas y tres diferencias entre los tipos de datos que permiten almacenar ms de un dato; reflejando las relaciones de las comparaciones con ideas pocos claras.
NIVEL MEDIO 71-85
Comparar con la utilizacin de un cuadro comparativo dos semejanzas y dos diferencias entre los tipos de datos que permiten almacenar ms de un dato; reflejando las relaciones de las comparaciones con ideas confusas.
NIVEL BSICO 70
3.Implementar aplicaciones dinmicas de estructura Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales (Nivel Taxonmico: Aplicacin)
Implementar aplicaciones dinmicas de estructura Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales.
NIVEL ALTO: 86-100
Implementar aplicaciones dinmicas de estructura Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones comerciales.
NIVELMEDIO 71-85
Implementar aplicaciones dinmicas de estructura No Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento.
NIVEL BSICO 70
4.Implementar aplicaciones dinmicas de estructura no Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales (Nivel Taxonmico: Aplicacin)
Elaborar un programa con estructuras dinmicas no lineales bien detallado.
NIVEL ALTO: 86-100
Elaborar un programa con estructuras dinmicas no lineales con poca claridad.
NIVEL MEDIO 71-85
Elaborar un programa con estructuras dinmicas no lineales de forma confusa.
NIVEL BSICO 70
Elaborar un programa que emplee estructuras arborescentes de forma AVL uso de forma clara.
NIVEL ALTO: 86-100
5.- Organizar la informacin en algoritmos y estructuras AVL y su relacin con los gestores de Base de Datos (Nivel Taxonmico: Aplicacin)
Elaborar un programa que emplee estructuras arborescentes de forma AVL de forma poco clara.
NIVEL MEDIO 71-85
Elaborar un programa que emplee estructuras arborescentes de forma AVL de forma confusa.
NIVEL BSICO 70
IV.- PROGRAMACIN
PROGRAMA DEL CONTENIDO DISCIPLINAR (ASIGNATURA, UNIDAD, CURSO, TALLER, OTRO) POR TEMAS N TOT AL HOR AS P-A
46 23 Experiencia: Aplicando concretar lluvia de ideas
HORAS PRESENCIALES
HORAS AUTNOMAS
ESTRATEGIAS PARA EL TRABAJO AUTNOMO
1.
UNIDAD I: GENERALIDADES Y
DEFINICIONES DE ESTRUCTURA DE DATOS
conocimientos
Definicin Variables, Tipos de datos. Representacin Grfica de las estructura de datos Acceso a las estructura de Datos (Estticas) Tipos de Estructuras de Datos Diferencia Operaciones punteros Asignacin memoria Liberacin memoria La constante NULL Ventajas punteros y desventajas de dinmica de dinmica de entre con gestin varios Esttica y Dinmica
relativo a la memoria y sus diferentes importancias en el funcionamiento computador Reflexin: En equipos de trabajo, analizar el funcionamiento general del computador y de los programas, considerando las siguientes aplicaciones: Procesadores de texto, Hojas de clculo, Reproductores, Tareas del sistema operativo como Impresin, etc. Conceptualizacin: Elaboracin conceptuales, de la memoria. Aplicacin: Resolucin demostrativos de ejercicios y de de mapas de del
23 Tareas extraclases. Investigacin del tema de la unidad Tareas en el lenguaje de programacin C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Tcnica de Manab, Internet. Guardar la evidencia en el Portafolio Digital.
-Formarn equipos de 2 estudiantes -Del taller o tarea respectivas se escogern ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicar la tcnica de procesos. -Al final de la tarea se interrogarn, as: Qu cosas fueron difciles? Qu cosas fueron fciles? Qu aprend hoy da? Qu aporte a mi equipo? -Aplicarn un ASAT. (Aporte Significativo de Aprendizaje de la Tarea o Taller). -Para el ensayo del tema respetivo se Tomarn lo lineamientos ms importantes de la introduccin llamativa, fundamentacin y conclusin crtica.
cuadros
funcionamiento y estructurales
planteamiento de problemas.
2.
UNIDAD II: ESTRUCTURAS SIMPLES

Y COMPUESTAS
60
30 Experiencia: Aplicando lluvia a de ideas
Listas Abiertas
concretar relativo
conocimientos problemas
30 Tareas extraclases. Investigacin del tema de la unidad Tareas en el lenguaje de
-Formarn equipos de 2 estudiantes -Del taller o tarea respectivas se escogern ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicar la tcnica de procesos. -Al final de la tarea se
Definicin de listas abiertas Declaracin e implementacin de una lista
informticos planteados
Reflexin: En grupos de trabajo, analizar el funcionamiento general de los diferentes las algoritmos diferentes considerando
Operaciones con Listas Insercin de un nodo Bsqueda de un nodo Recorridos de una lista Eliminacin de un nodo Listas y Archivos Variaciones de listas Pilas y Colas
aplicaciones.
programacin C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Tcnica de Manab, Internet. Guardar la evidencia en el Portafolio Digital.
interrogarn, as: Qu cosas fueron difciles? Qu cosas fueron fciles? Qu aprend hoy da? Qu aporte a mi equipo? -Aplicarn un ASAT. (Aporte Significativo de Aprendizaje de la Tarea o Taller). -Para el ensayo del tema respetivo se Tomarn lo lineamientos ms importantes de la introduccin llamativa, fundamentacin y conclusin crtica.
Conceptualizacin: Elaboracin de conclusiones conceptuales, cuadros de funcionamiento y alternativas
Listas circulares o cerradas Declaracin e implementacin de una lista circular
estructurales de solucin.
Operaciones con Listas Insercin de un nodo Bsqueda de un nodo Recorridos de una lista Eliminacin de un nodo
Aplicacin: Resolucin demostrativos de ejercicios y de
Listas doblemente enlazadas abiertas y cerradas Declaracin e implementacin de una lista doblemente enlazada
Operaciones con Listas Insercin de un nodo Bsqueda de un nodo Recorridos de una lista Eliminacin de un nodo
3.
UNIDAD
III:
ESTRUCTURAS
26
13 Experiencia: Aplicando la debates de
ARBORESCENTES
Definicin, implementacin
definir
importancia
aplicar algoritmos generales de
13 Tareas extraclases. Investigacin del tema de la unidad Tareas en el
-Formarn equipos de 2 estudiantes -Del taller o tarea respectivas se escogern ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicar la tcnica de procesos.
rboles Tipos de PreOrden InOrden PostOrden recorridos:
binarios
su
importancia en la agilidad y seguridad de los datos en el campo empresarial en general. Reflexin:
Operaciones con rboles Binarios de Bsqueda
trabajo, principales avance
En
grupos analizar
de el
funcionamiento general de los Bsqueda de Insercin de Borrado de * Nodo hoja. *Nodo rama. Movimiento a travs del rbol. Comprobacin de rboles vacos. Comprobacin del nodo hoja. Clculo de: Nmero de nodos. Altura del rbol. Altura de un nodo. elementos. elementos. elementos. sistemas tecnolgico del informticos, considerando el software en la base de datos Conceptualizacin: Elaboracin de
lenguaje de programacin C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Tcnica de Manab, Internet. Guardar la evidencia en el Portafolio Digital.
-Al final de la tarea se interrogarn, as: Qu cosas fueron difciles? Qu cosas fueron fciles? Qu aprend hoy da? Qu aporte a mi equipo? -Aplicarn un ASAT. (Aporte Significativo de Aprendizaje de la Tarea o Taller). -Para el ensayo del tema respetivo se Tomarn lo lineamientos ms importantes de la introduccin llamativa, fundamentacin y conclusin crtica.
propuestas resolucin. Aplicacin:
algortmicas,
prcticas y de alternativas de
Resolucin
de
ejercicios demostrativos y de planteamiento de problemas. 28 14 Experiencia: Aplicando el planteamiento de problemas, dificultades y de necesidad identificar generar la encontrar
rboles degenerados.
4.
UNIDAD IV: TIPOS DE RBOLES

ESPECIALES rboles equilibrados. Definicin. Operaciones en AVL. Factor de equilibrio. Rotacin simple de nodos. Rotacin simple a la derecha. Rotacin simple a la izquierda. Rotacin doble de nodos a la derecha. Rotacin doble de nodos s la izquierda. Reequilibrados de rboles AVL. Reequilibrados en rboles AVL por insercin de un nodo.
soluciones algortmicas. Reflexin: En grupos de trabajo, analizar el funcionamiento de los diferentes propuestos. Conceptualizacin: Elaboracin de propuestas de funcionamiento y alternativas estructurales de solucin. Aplicacin: algoritmos
14 Tareas extraclases. Investigacin del tema de la unidad Tareas en el lenguaje de programacin C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Tcnica de Manab, Internet. Guardar la evidencia en el Portafolio Digital.
-Formarn equipos de 2 estudiantes -Del taller o tarea respectivas se escogern ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicar la tcnica de procesos. -Al final de la tarea se interrogarn, as: Qu cosas fueron difciles? Qu cosas fueron fciles? Qu aprend hoy da? Qu aporte a mi equipo? -Aplicarn un ASAT. (Aporte Significativo de Aprendizaje de la Tarea o Taller). -Para el ensayo del tema respetivo se Tomarn lo lineamientos ms importantes de la introduccin llamativa, fundamentacin y conclusin crtica.
Reequilibrados en rboles AVL por borrado de un nodo.
Resolucin demostrativos
de
ejercicios y de
V.- METODOLOGA Y RECURSOS

Se aplicar un PEA, Dinmica de integracin y socializacin, documentacin, presentacin de los temas de clase y objetivos, lectura de motivacin y video del tema, tcnica lluvia de ideas, para interactuar entre los receptores, aplicando el ciclo del aprendizaje. Se aplicaran talleres con ASAT (aporte significativos de los aprendizajes de tareas o talleres) Revisin de la clase programada antes del da sealado para la sesin correspondiente (blog-docente) Consultas, tareas y talleres se entregarn en archivo escrito al docente y en archivo lgico al rea de contacto del curso. Los recursos disponibles para el curso sern: pizarra tiza lquida(4), proyector, internet inalmbrico, dispensador de agua, aire acondicionado, mesas de trabajo en equipo, proyector para equipos de trabajos en su lugar respectivo, sistema de audio, impresora de ltima generacin, computadores(2) del aula,1 porttiles por equipo del estudiante, libros-CD-interactivo- pdf., blog. del estudiante y del docente para interactividad y fortalecimiento contino.
Las evaluaciones estarn orientadas a los procesos, lo que conlleva a que ninguna evaluacin tenga una ponderacin determinante para la acreditacin. Durante el periodo acadmico, el estudiante de la Universidad Tcnica de Manab, se someter obligatoriamente a los siguientes parmetros de evaluacin de los aprendizajes: evaluacin de medio ciclo, evaluacin de final de ciclo, evaluacin de actividades varias y evaluaciones de investigaciones.
VI.- PLANEACIN DE LA EVALUACIN
ACREDITACIN
EXMENES (30%) ACT. EN EL AULA (40%) Tareas Ejercicios de aplicacin Lecciones orales Pruebas escritas Participacin Exposiciones ACTIVIDADES DE INVESTIGACIN PORTAFOLIO PROYECTO INFORME FINAL (30%) TOTAL
MEDIO CICLO
15 5 2.5 2.5 5 2.5 2.5 5 10 50%
FINAL DE CICLO
15 5 2.5 2.5 5 2.5 2.5 5 10 50%
EXAMEN DE RECUPERACIN
ASISTENCIA
100%
VI.- BIBLIOGRAFA a.- Bibliografa Bsica:

AUTOR
TTULO DE LIBRO
EDICIN
AO PUBLICACIN
EDITORIAL
MARTNEZ, Romn
TORRES, Christian
Estructura de Datos, Referencia practica con objetos orientados a objetos Manuales de estructura de Datos en C++
TTULO DE LIBRO EDICIN
7 1
2008 2010
Elda Quiroga Estudiantil-FCI-UTM. Ecuador

EDITORIAL
b.- Bibliografa Recomendada:

AUTOR
AO PUBLICACIN
Garrido Antonio
c.- Lecturas complementarias:

Abstraccin y Estructura de Datos en C++
2006
Delta Publicaciones S. L.
http://c.conclase.net/edd/. http//www.utm.edu.ec http://evirtual.utm.edu.ec/course/view.php?id=25 robotica.uv.es/pub/Libro/PDFs/CAPI5.pdf www.dc.uba.ar ... Algoritmos y Estructuras de Datos II http://www.programacion.com/articulo/estructuras_de_datos_y_algoritmos_en_java_309/2 http://www.youtube.com/watch?v=tOOEff1r-tk
VII.- COMPROMISO TICO

Escuchar y respetar democrticamente el criterio de los dems. Hacer silencio cuando alguien est haciendo uso de la palabra. Mantener el aula limpia, evitando botar basura en el piso No deteriorar ni rayar, las paredes, mesas y sillas. Procurar en todo momento la correcta manipulacin y utilizacin de los equipos informticos. La asistencia es obligatoria a todas las actividades programadas en esta asignatura. El estudiante ingresar a clase a la hora establecida y solo por una ocasin se aceptar el retraso de 10 minutos. El estudiante por ningn concepto utilizar celulares en el aula, igual comportamiento tendr el docente. El intento de copia de cualquier estudiante ser sancionado con la calificacin de cero y no habr oportunidad de recuperacin, independiente de las sanciones establecidas por la universidad. Los trabajos se entregarn en la fecha establecida y no se recibir en otra oportunidad. El estudiante ingresar al aula sin gorra y no consumir alimentos dentro del aula. El trabajo escrito ser realizado con las propias palabras e ideas del estudiante. Si se descubre la copia textual de un prrafo o un texto se calificar con cero.
Lugar y fecha: Portoviejo, 6 de Mayo del 2013
Ing. Christian Ronald Torres Morn (f) Docente ANEXO. N 1
(f) Coordinador
RESULTADOS DE APRENDIZAJE DE LA CARRERA ESPECFICOS A LOS QUE APUNTA LA MATERIA (ABET).

a. b. c. Capacidad de realizar anlisis, sntesis y aplicacin de las matemticas y ciencias bsicas en la solucin de problemas de ingeniera en sistemas informticos. Capacidad de planificar, disear, conducir e interpretar resultados de experimentos orientados a la informtica. La capacidad de disear sistemas, procesos, modelos y componentes informticos que cumplan los estndares nacionales o internacionales, tomando en cuenta las limitaciones econmicas, ambientales, sociales, polticas, de salud y seguridad del entorno, y cumpliendo satisfactoriamente con las especificaciones y restricciones existentes o indicadas por los interesados o por los criterios de sostenibilidad. Capacidad para funcionar como parte de un equipo de profesionales de distintas reas del conocimiento, demostrando una efectiva cooperacin, comunicacin, con habilidades para resolver conflictos y contribuyendo proactivamente en la propuesta de lneas estratgicas desde el punto de vista informtico, para la solucin de problemas. Capacidad para identificar, formular, evaluar y resolver tcnicamente problemas de ingeniera planteados de acuerdo a las necesidades del medio. Capacidad para comprender, reconocer y aplicar valores y cdigos de tica profesional, que le permitan desenvolverse sin perjudicar a sus clientes y contribuyendo al desarrollo de la sociedad. Habilidad para presentar efectivamente, ideas, proyectos, informes de investigaciones, documentos de trabajo de manera escrita, oral y digital, utilizando las herramientas de las nuevas tecnologas de la informacin. Habilidad y capacidad para comprender el impacto de las soluciones informticas a la realidad local, nacional e internacional en un contexto econmico global, ambiental y social. Habilidad y aptitud para ser un profesional con el compromiso del aprendizaje continuo, con capacidad para reconocer las oportunidades para mejorar en su campo profesional. Habilidad para identificar temas y problemas de actualidad con respecto al entorno local, regional y global, con el fin de relacionarlos con propuestas de soluciones creativas y eficientes. Capacidad y destreza para utilizar tcnicas, habilidades y herramientas en el desarrollo de software y hardware para implementar soluciones a problemas de su profesin. Contribucin de la materia a los resultados de aprendizaje de la carrera: A: Alta M: Medio B: Baja a b A c d e M f B g h i j k
d.
e. f.
g.
h. i. j. k.
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS AUTORRETRATO
Mi nombre es MOREIRA VASQUEZ JONATHAN RICARDO soy estudiante de la asignatura de ESTRUCTURA DE DATOS, actualmente curso el segundo semestre en la facultad de Ciencias Informticas de la Universidad Tcnica de Manab. Soy una persona responsable, organizada, humilde trabajar en equipo. y me gusta
Mis metas son convertirme en profesional como Ingeniero en Sistemas Informticos ya que ese es mi sueo desde que era pequeo por eso le doy gracias a dios y a mis padres por estar siempre pendiente de m dndome consejos para salir adelante. Cuando obtenga mi ttulo de profesional lo primero que hara es ayudar a mis padres para poder pagarles todo aquello que ellos han hecho por m ya que desde pequeo me han enseado que cuando ms humilde es la persona puede salir adelante sin importar el grado econmico en que se encuentre, por eso debemos seguir el ejemplo de Jesucristo ya que a l no le import entregar su vida por cada uno de nosotros. Y en esta nueva etapa de mi vida anhelo seguir adelante y espero llevarme bien con todos mis compaeros.
UNIVERSIDAD TCNICA DE MANAB MISIN:

Formar acadmicos, cientficos y profesionales responsables, humanistas, ticos y solidarios, comprometidos con los objetivos del desarrollo nacional, que contribuyan a la solucin de los problemas del pas como universidad de docencia con investigacin, capaces de generar y aplicar nuevos conocimientos, fomentando la promocin y difusin de los saberes y las culturas, previstos en la Constitucin de la Repblica del Ecuador.
VISIN:
Ser institucin universitaria, lder y referente de la educacin superior en el Ecuador, promoviendo la creacin, desarrollo, transmisin y difusin de la ciencia, la tcnica y la cultura, con reconocimiento social y proyeccin regional y mundial.
FACULTAD DE CIENCIAS INFORMTICAS
MISIN:
Ser una unidad con alto prestigio acadmico, con eficiencia, transparencia y calidad en la educacin, organizada en sus actividades, protagonistas del progreso regional y nacional.
VISIN:
Formar profesionales eficientes e innovadores en el campo de las ciencias informticas, que con honestidad, equidad y solidaridad, den respuestas a las necesidades de la sociedad elevando su nivel de vida.
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS Diario Metacognitivo
Clase 1:
PERIODO: TIEMPO: FECHA: DOCENTE GUIA: Del 6 de Mayo al 14 Septiembre del 2013 3 HORAS Lunes, 6 de mayo del 2013. Ing. Cristian Torres
Realizar un programa que nos cree un array que contenga 8 elementos 1, 1,2, 3,5, 8, 13, 21
#include<conio.h> #include<stdio.h>
void main() { clrscr(); int vec[]={1,1,2,3,5,8,13,21}; printf("\nLos numeros del array son:"); for(int i=0;i<8;i++) printf("\nvec[%d]=%d",i,vec[i]); getch(); } Realizar un ejercicio que permita mostrar una matriz identidad 3 x 3
#include"stdio.h" #include"conio.h" void main() { clrscr(); int matriz[3][3]; for(int x=0;x<3;x++) for(int y=0;y<3;y++) { if(x==y) matriz[x][y]=1; else matriz[x][y]=0; } for(x=0;x<3;x++) { for(y=0;y<3;y++) printf("%d",matriz[x][y]); printf("\n"); } getch(); }
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS
Clase N 2:
Del 6 de Mayo al 14 Septiembre del 2013 2 HORAS. Mircoles, 08 de Mayo del 2013. Ing. Cristian Torres
PERIODO: TIEMPO: FECHA: DOCENTE GUIA:
Contenido: Generalidades y definiciones de estructuras de datos

struct palabra reservada que nos permite crear una estructura. Sintaxis: struct [etiqueta] // nombre que se le va a dar a la estructura { Campo 1; // campos o miembros de la Campo 2; // estructura (no variables) Campo 3; . . }; //termina en punto y coma
La estructura no es una matriz. Los campos o miembros se los define como las variables pero no son variables. Ejemplo: # includestring.h struct tnotas{ char nomb_est[30];
float calif; } Las estructuras van antes del void main(), mai(). Para acceder a los miembros de la estructura se debe hacer uso del punto y un nombre del campo.
Ejemplo: # includestring.h struct tnotas{ char nomb_est[30]; float calif; } void main() { struct tnotas c; c.calif=7.5; strcpy(c.nom_est,Juan Flores); getch(); } strcpy: Permite que a la primera cadena separada por la coma (,) se le almacena la segunda. c.nom_est=Juan Flores; //esto es un error strcpy(c.nom_est,Juan FLores); // Correcto
Clase N 3:
Del 6 de Mayo al 14 Septiembre del 2013 3 HORAS. Lunes, 13 de Mayo del 2013. Ing. Cristian Torres
Tema: Acceso a las estructura de Datos

Asignar Se puede asignar en cualquier lugar del programa Usa el = algunos casos como el string se una strcpy , strcat Los mecanismos de i/o son partes de esta asignacin, get, printf, y cin. Aqu no es importante el orden
Inicializar Solo es posible cuando se crea la variable Se usa el = y las { }; detallando cada elemento y separado por la coma Debe tener en cuenta al ser usado por la estructura por la variedad de datos Cadena de formato para el printf Es importante el orden que se guardan los datos
Disee una estructura que permita almacenar cedula, nombres, apellidos, cuidad y departamento del empleado de una empresa pblica y el sueldo #include<stdio.h> #include<conio.h> #include<iostream.h> struct empleados{ char nombre[15],apellido[30];
int long cedula; char ciudad[18]; float sueldo; char depa[20]; }; char mat[1][6][35]={"Kenia","Navarrete","1315717643","Portoviejo","700.50","Gerente"}; void main() { clrscr(); struct empleados e={"Ramon","Alvares",1311764177,"Portoviejo",700.50,"Tecnico"}; int c; cout<<"Informacion de la matriz:\n\n"; for(c=0;c<6;c++) cout<<mat[0][c]<<"\t"; cout<<"\n"; cout<<"\nInformacion de la variable estructurada:\n\n"; cout<<e.nombre<<"\t"; cout<<e.apellido<<"\t"; cout<<e.cedula<<"\t"; cout<<e.ciudad<<"\t"; cout<<e.sueldo<<"\t"; cout<<e.depa<<"\t\n"; cout<<"\nMatriz= "<<mat<<"\n"; cout<<"\nVariable estructurada= "<<&e<<"\n"; cout<<"\n***************************************************"; printf("\nDireccion de memoria de la matriz:\n\n") ; for(c=0;c<6;c++) cout<<&mat[0][c]<<"\t"; cout<<"\nDirecciones de memoria de la variable estructurada:\n\n"; cout<<&e.nombre<<"\t"; cout<<&e.apellido<<"\t"; cout<<&e.cedula<<"\t"; cout<<&e.ciudad<<"\t"; cout<<&e.sueldo<<"\t"; cout<<&e.depa<<"\t\n"; getch(); }
Clase N 4:
Del 6 de Mayo al 14 Septiembre del 2013 2 HORAS. Mircoles, 15 de Mayo del 2013. Ing. Cristian Torres
Tema: Acceso a las estructura de Datos

Crear un programa que nos permita almacenar nombre, sueldos, junto con el valor de ventas. #include<conio.h> #include<stdio.h> #include<iostream.h> struct almacenar { char nombre[30]; float sueldos; float val_vent; }; void main() {clrscr(); //ingreso de datos a la variable estructurada struct almacenar A[5]; for(int x=0;x<5;x++) { cout<<"\nIngrese nombre: ";cin>>A[x].nombre; cout<<"\nIngrese sueldo: "; fflush(stdin); cin>>A[x].sueldos; cout<<"\nIngrese valor de ventas: "; fflush(stdin);cin>>A[x].val_vent; } //imprimir la informacion de la variable estructurada. clrscr(); for(x=0;x<5;x++)
printf("\n************************\nNombre: %s\nSueldo: %.2f\nValor de ventas: %.2f\n************************\n",A[x].nombre,A[x].sueldos,A[x].val_vent); getch(); }
Clase N 5:
PERIODO: TIEMPO: FECHA: DOCENTE GUIA: Del 6 de Mayo al 14 Septiembre del 2013 3 HORAS. Lunes, 20 de mayo del 2013. Ing. Cristian Torres
Tema: Pasos de parmetros por referencia y por valor

#include"stdio.h" #include"conio.h" #include"iostream.h" #include"iomanip.h" #include"string.h" struct control_asistencia {char est[45],nivel[30],paralelo,aula[7],hinicio[6],hfin[6]; int dia,mes,anio; }; void registrar(control_asistencia c[], int n); void imprimir(control_asistencia c[], int n); //implementacion void registrar(control_asistencia c[],int n ) { clrscr(); for(int i=0;i<n;i++) { printf("\nIngreso de informacion" ); printf("\nIngrese el nombre del estudiante: "); fflush(stdin);cin>>c[i].est; printf("\nIngrese el nivel: ");fflush(stdin); cin>>c[i].nivel; printf("\nIngrese el paralelo del estudiante: ");fflush(stdin); cin>>c[i].paralelo; printf("\nIngrese el codigo de aula : ");fflush(stdin); cin>>c[i].aula; printf("\nIngrese la hora de inicio: ");fflush(stdin); cin>>c[i].hinicio; printf("\nIngrese la hora final: "); fflush(stdin); cin>>c[i].hfin; char ch;
printf("\nIngrese la fecha en fomrato dd/mm/yyyy: "); fflush(stdin); cin>>c[i].dia>>ch>>c[i].mes>>ch>>c[i].anio; } } void imprimir(control_asistencia c[], int n) {cout<<"Datos ingresados\n"; cout<<"Estudiante "<<"Nivel"<<"Paralelo"<<"\t"<<"Aula"<<"\t"<<"Hora inicio"<<"\t"<<"Hora fin"<<"\t"<<"Fecha\n"; for(int i=0;i<n;i++){ cout<<c[i].est<<"\t\t"<<c[i].nivel<<"\t"<<c[i].paralelo<<"\t"<<c[i].aula<<setw(5)<<c[i].hini cio<<setw(6)<<c[i].hfin<<setw(2)<<c[i].dia<<"/"<<setw(2) <<c[i].mes<<"/"<<setw(4)<<c[i].anio<<endl; }} void main() { clrscr(); control_asistencia E[5]; registrar(E,2); imprimir(E,2); getch(); };
Clase N 6:
Del 6 de Mayo al 14 Septiembre del 2013 4 HORAS EN DOS JORNADAS DE DOS HORAS. Mircoles, 22 de mayo del 2013. Ing. Cristian Torres
Tema: Minga en la Universidad.
Clase N 7:
Del 6 de Mayo al 14 Septiembre del 2013 3 HORAS. Lunes, 27 de mayo del 2013. Ing. Cristian Torres
Tema: Punteros
#include<iostream.h> #include<stdio.h> #include<conio.h> main() { clrscr(); int mat[5]={20,3,8,90,10}; int i, *punt; for(i=0;i<5;i++) { cout<<"Direccion: "<<&mat[i]<<" -----> Contenido de esta direccion de memoria: "<<mat[i]<<"\n"; } cout<<"\n"; for(i=0;i<5;i++) { cout<<"Direccion: "<<(mat+i)<<" -----> Contenido de esta direccion de memoria: "<<*(mat+i)<<"\n"; } punt=mat; //punt=&mat[0] cout<<"\n";
for(i=0;i<5;i++) { cout<<"Direccion: "<<punt<<" -----> Contenido de esta direccion de memoria: "<<*(punt)<<"\n"; punt++; } getch(); return 0; }
#include<iostream.h> #include<stdio.h> #include<conio.h> #include<iomanip.h> struct fecha {int dia; int mes; int anio; }; void pide_fecha(struct fecha &f); void ver_fecha(struct fecha f); void suma(int d); void pide_fecha(struct fecha &f) { char ch; cout<<"Ingrese la fecha:\n"<<"Escriba fecha de la forma dd/mm/aa: "; cin>>f.dia>>ch>>f.mes>>ch>>f.anio; } void ver_fecha(struct fecha f) { cout<<"La fecha es: "<<setfill('0') <<setw(2) <<f.dia <<'/' <<setw(2) <<f.mes <<'/' <<setw(4) <<f.anio; } main() { struct fecha datos; pide_fecha(datos);
ver_fecha(datos); getch(); return 0; }
Clase N 8:
Del 6 de Mayo al 14 Septiembre del 2013 2 HORAS. Mircoles, 29 de mayo del 2013. Ing. Cristian Torres
Tema: Punteros
Crear una estructura que permita manejar nmeros de horas trabajadas, valor de hora, valor hora extra, nombre del empelado.
#include<stdio.h> #include<conio.h> #include<iostream.h> } struct empleado { char nombre[30]; int n_h_tra; float v_hora, v_h_extra, salario; }; void ingreso(struct empleado &f); void calcular(struct empleado &f); void mostrar(struct empleado f); main() { struct empleado datos[5]; for(int x=0;x<5;x++) ingreso(datos[x]); for(int x=0;x<5;x++)
calcular(datos[x]); for(int x=0;x<5;x++) mostrar(datos[x]); getch(); } void ingreso(struct empleado &f) { cout<<"\n\n Ingrese el nombre del empleado: "; cin>>f.nombre; cout<<"\n Ingrese las horas trabajadas: "; cin>>f.n_h_tra; cout<<"\n Ingrese el valor de la hora: "; cin>>f.v_hora; cout<<"\n Ingrese el valor de la hora extra: "; cin>>f.v_h_extra; } void calcular(struct empleado &f) { struct empleado *punt; punt=&f; int extras; if(punt->n_h_tra>40) { extras=punt->n_h_tra-40; punt->salario=extras*punt->v_h_extra; punt->salario+=40*punt->v_hora; } else punt->salario+=punt->n_h_tra*punt->v_hora; } void mostrar(struct empleado f) { cout<<"\n\n El nombre del empleado es: "<<f.nombre; cout<<"\n El salario es: "<<f.salario; }
Clase N 9:
PERIODO: TIEMPO: FECHA: DOCENTE GUIA: Del 6 de Mayo al 14 Septiembre del 2013 3 HORAS. Lunes, 03 de junio del 2013. Ing. Cristian Torres
Tema: Punteros
#include"stdio.h" #include"conio.h" #include"iostream.h" #include"iomanip.h" #include"string.h" struct control_asistencia {char est[45],nivel[30],paralelo,aula[7],hinicio[6],hfin[6]; int dia,mes,anio; }; void registrar(control_asistencia c[], int n); void imprimir(control_asistencia c[], int n); //implementacion void registrar(control_asistencia c[],int n ) { clrscr(); for(int i=0;i<n;i++) { printf("\nIngreso de informacion" ); printf("\nIngrese el nombre del estudiante: "); fflush(stdin);cin>>c[i].est; printf("\nIngrese el nivel: ");fflush(stdin); cin>>c[i].nivel; printf("\nIngrese el paralelo del estudiante: ");fflush(stdin); cin>>c[i].paralelo; printf("\nIngrese el codigo de aula : ");fflush(stdin); cin>>c[i].aula; printf("\nIngrese la hora de inicio: ");fflush(stdin); cin>>c[i].hinicio; printf("\nIngrese la hora final: "); fflush(stdin); cin>>c[i].hfin; char ch;
printf("\nIngrese la fecha en fomrato dd/mm/yyyy: "); fflush(stdin); cin>>c[i].dia>>ch>>c[i].mes>>ch>>c[i].anio; } } void imprimir(control_asistencia c[], int n) {cout<<"Datos ingresados\n"; cout<<"Estudiante "<<"Nivel"<<"Paralelo"<<"\t"<<"Aula"<<"\t"<<"Hora inicio"<<"\t"<<"Hora fin"<<"\t"<<"Fecha\n"; for(int i=0;i<n;i++){ cout<<c[i].est<<"\t\t"<<c[i].nivel<<"\t"<<c[i].paralelo<<"\t"<<c[i].aula<<setw(5)<<c[i].hini cio<<setw(6)<<c[i].hfin<<setw(2)<<c[i].dia<<"/"<<setw(2) <<c[i].mes<<"/"<<setw(4)<<c[i].anio<<endl; }} void main() { clrscr(); control_asistencia E[5]; registrar(E,2); imprimir(E,2) ; getch(); };
Clase N 10:
PERIODO: TIEMPO: FECHA: DOCENTE GUIA: Del 6 de Mayo al 14 Septiembre del 2013 2 HORAS. Mircoles, 05 de junio del 2013. Ing. Cristian Torres
Tema: Aporte
Clase N 11:
Tema: Definicin de listas abiertas

#include"stdio.h" #include"conio.h" #include"iostream.h" #include"string.h" #include"stdlib.h" //primera forma de utilizar el typedef typedef struct _alumnos{ char nom[30]; struct _alumnos *sig; }tipoalumno; typedef tipoalumno *pnodo; //*pnodo es un puntero typedef tipoalumno *lista; // *lista es unalista //funciones prototipo void almacenar(lista *l, char c[]); //*l es un puntero para pasar datos por referencia void ver_lista(lista l); //l me sirve para leer la lista void main() { clrscr(); lista l1=NULL; //lista esta definido como un puntero int op; do{ clrscr(); printf("\n1. Registrar nombre"); printf("\n2.
Mostrar lista"); printf("\n3. Salir"); printf("\n"); do{ cin>>op; }while((op>3)||(op<1)); if (op==1) {char nombre[25]; clrscr(); printf("\nREGISTRO DE NUEVO CLIENTE"); printf("\nIngrese un nombre: "); fflush(stdin); gets(nombre); //permite ingresar cadenas con espacios hata 25 caracteres almacenar(&l1,nombre); } else if(op==2) {clrscr(); ver_lista(l1); } } while(op!=3); } void almacenar(lista *l,char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoalumn o)); if(nodo==NULL) { cout<<"\nSin espacio de memoria"; return; } //se llena la informacion del nodo strcpy(nodo->nom,c); //procedo hacer los enlaces if (! *l) {//es el primer nodo que va a ingresar a los nodos nodo->sig=NULL; *l=nodo;} else {nodo->sig=*l; *l=nodo; } } void ver_lista(lista l) {pnodo n=l; while(n) {cout<<"\n"<<n->nom; n=n->sig;} getch(); }
Clase N 12:
Tema: Insercin de un nodo al inicio y al final

#include"stdio.h" #include"conio.h" #include"iostream.h" #include"string.h" #include"stdlib.h" typedef struct _alumnos{ char nom[30]; struct _alumnos *sig; }tipoalumno; typedef tipoalumno *pnodo; //*pnodo es un puntero typedef tipoalumno *lista; // *lista es unalista //funciones prototipo void almacenar(lista *l, char c[]); //*l es un puntero para pasar datos por referencia void ver_lista(lista l); //l me sirve para leer la lista void almacenar_fin(lista *l, char c[]); void main() { clrscr(); lista l1=NULL; //lista esta definido como un puntero int op; do{ clrscr(); printf("\n1. Registrar nombre al inicio"); printf("\n2. Ingresar nombre al finla"); printf("\n3. Mostrar lista");
printf("\n4. Salir"); printf("\n"); do{ cin>>op;
}while((op>4)||(op<1)); if (op<=2) {char nombre[25]; clrscr(); printf("\nREGISTRO DE NUEVO CLIENTE"); printf("\nIngrese un nombre: "); fflush(stdin); gets(nombre); //permite ingresar cadenas con espacios hata 25 caracteres if (op==1) almacenar(&l1,nombre); else almacenar_fin(&l1,nombre); } else if(op==3) {clrscr(); ver_lista(l1); } } while(op!=4); } void almacenar(lista *l,char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoalumno)); if(nodo==NULL) { cout<<"\nSin espacio de memoria"; return; } //se llena la informacion del nodo strcpy(nodo->nom,c); { //procedo hacer los enlaces nodo->sig=*l; *l=nodo; } } void almacenar_fin(lista *l,char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoalumn o)); if(nodo==NULL) { cout<<"\nSin espacio de memoria"; return; } //se llena la informacion del nodo strcpy(nodo->nom,c); //procedo hacer los enlaces if (! *l) {nodo->sig=*l; *l=nodo;} else { pnodo aux=*l; while(aux->sig!=NULL) // (AUX->SIG) aux=aux->sig; aux->sig=nodo; nodo->sig=NULL; }
} void ver_lista(lista l) {pnodo n=l; while(n) {cout<<"\n"<<n->nom; n=n->sig;} getch(); }
Clase N 13:
Tema: Insercin de un nodo de manera ordenada

#include<conio.h> #include<stdio.h> #include<iostream.h> #include<stdlib.h> #include<string.h> typedef struct _alumnos{ char nom[25]; struct _alumnos *sig; }tipoAlumno ; typedef tipoAlumno *pnodo; typedef tipoAlumno *Lista; //funciones prototipos void almacenar(Lista *l, char c[]); void almacenar_fin(Lista *l, char c[]); void almacenar_ord(Lista *l, char c[]); void ver_lista(Lista l); void main() {Lista L1=NULL; int op; do{ clrscr(); printf("\n1. Registrar Nombre al inicio");
printf("\n2. Registrar Nombre al final"); printf("\n3. Registrar Nombre ordenadamente"); printf("\n4. Mostrar Lista"); printf("\n5. Salir\n"); do{ cin>>op; }while ((op>5) ||(op<1)); if (op<=3) { char nombre[25]; clrscr(); printf("\nREGISTRO DE NUEVO CLIENTE\n"); printf("\n Ingrese un Nombre: "); fflush(stdin); gets(nombre); if(op==1) almacenar(&L1,nombre) ; else if(op==2) almacenar_fin(&L1,nombre); else almacenar_ord(&L1,nombr e); } else if(op==4) {clrscr(); ver_lista(L1); }}while(op!=5); } void almacenar(Lista *l, char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoAlumno)); if (nodo==NULL) { cout<<"\n Sin espacio de memoria"; return; } //Se llena la informacion del nodo strcpy(nodo->nom,c); //Procedo hacer los enlaces //pasos para almacenar al inicio de la lista //******************************** nodo->sig=*l; *l=nodo; //******************************** } //****** void almacenar_fin(Lista *l, char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoAlumn o)); if (nodo==NULL) { cout<<"\n Sin espacio de memoria"; return;
} //Se llena la informacion del nodo strcpy(nodo->nom,c); //Procedo hacer los enlaces if(!*l) {nodo->sig=*l; *l=nodo; } else {pnodo aux=*l; while(aux->sig!=NULL) // (aux->sig) aux=aux->sig; //pasos para almacenar al final de la lista //******************************** aux->sig=nodo; nodo->sig=NULL; //******************************** } } //****** void almacenar_ord(Lista *l, char c[]) {pnodo nodo,aux=*l; nodo=(pnodo)malloc(sizeof(tipoAlumn o)); if (nodo==NULL) { cout<<"\n Sin espacio de memoria"; return; } //Se llena la informacion del nodo strcpy(nodo->nom,c); //Procedo hacer los enlaces //pasos para almacenar ordenadamente //******************************** if(!*l) //1A { nodo->sig=*l; *l=nodo; } else {if(strcmp(aux->nom,c)>0) //2A { nodo->sig=*l; *l=nodo; } else //2B { while((aux->sig!=NULL)&&(strcmp(aux->sig->nom,c)<0)) aux=aux->sig; nodo->sig=aux->sig; aux->sig=nodo; }} //******************************** }
void ver_lista(Lista l) {pnodo n=l; while (n) {cout<<"\n"<<n->nom; n=n->sig;
} getch(); }
Clase N 14:
Tema: Cmo eliminar un nodo y una lista?

#include<conio.h> #include<stdio.h> #include<iostream.h> #include<stdlib.h> #include<string.h> typedef struct _alumnos{ char nom[25]; struct _alumnos *sig; }tipoAlumno; typedef tipoAlumno *pnodo; typedef tipoAlumno *lista; //funciones prototipos void almacenar(lista *l, char c[]); void almacenar_fin(lista *l, char c[]); void almacenar_ord(lista *l, char c[]); void ver_lista(lista l); void eliminar(lista *l); void eliminar_nodo(lista *l, char[]); void filtro_nombre(lista *l); void main() { lista l1=NULL; int op; char nombre[25];
do{
clrscr(); printf("\n1. Registrar Nombre al inicio");
printf("\n2. Registrar Nombre al final"); printf("\n3. Registrar ordenadamente"); printf("\n4. Mostrar Lista"); printf("\n5. Eliminar un elemento"); printf("\n6. Eliminar lista"); printf("\n7. Filtrar nombres repetidos"); printf("\n8. Salir\n"); do{ cout<<"Opcion: ";cin>>op; }while ((op>8) ||(op<1)); if (op<=3) { //char nombre[25]; clrscr(); printf("\nREGISTRO DE NUEVO CLIENTE\n"); printf("\n Ingrese un Nombre: "); fflush(stdin) ; gets(nombre ); if(op==1) almacenar(&l1,nombre); else if(op==2) almacenar_fin(&l1,nombre); else almacenar_ord(&l1,nombre);
} else if(op==4) {clrscr(); ver_lista(l1); } else if(op==5) { clrscr(); printf ("\nIngrese el nombre a eliminar: "); scanf("%s",nombre); eliminar_nodo(&l1,nombre); } else if(op==6) { clrscr();
} else if(op==7) { clrscr(); filtro_nombre(&l1); printf ("\nNombres filtrados correctamente"); getch(); } }
eliminar(&l1); printf ("\nLista eliminada completamente"); getch();
while(op!=8); } void almacenar(lista *l, char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoAlumno)); if (nodo==NULL) { cout<<"\n Sin espacio de memoria"; return; } //Se llena la informacion del nodo strcpy(nodo->nom,c); //Procedo hacer los enlaces //pasos para almacenar al inicio de la lista nodo->sig=*l; *l=nodo; } void almacenar_fin(lista *l, char c[]) {pnodo nodo; nodo=(pnodo)malloc(sizeof(tipoAlumno)); if (nodo==NULL) { cout<<"\nSin espacio de memoria"; return; } //Se llena la informacion del nodo strcpy(nodo->nom,c); //Procedo hacer los enlaces if(!*l) {nodo->sig=*l; *l=nodo; } else {pnodo aux=*l; while(aux->sig!=NULL) // (aux->sig) aux=aux->sig; //pasos para almacenar al final de la lista aux->sig=nodo; nodo->sig=NULL; } } void almacenar_ord(lista *l, char c[]) {pnodo nodo,aux=*l; nodo=(pnodo)malloc(sizeof(tipoAlumn o)); if (nodo==NULL) { cout<<"\n Sin espacio de memoria"; return; }
//Se llena la informacion del nodo strcpy(nodo->nom,c); //Procedo hacer los enlaces //pasos para almacenar ordenadamente if(!*l) //1A { nodo->sig=*l; *l=nodo; } else if(strcmp(aux->nom,c)>0) //2A { nodo->sig=*l; *l=nodo; } else //2B { while((aux->sig!=NULL)&&(strcmp(aux->sig->nom,c)<0)) aux=aux->sig; nodo->sig=aux->sig; aux->sig=nodo; } getch(); } void ver_lista(lista l) {pnodo n=l; while (n) {cout<<"\n"<<n->nom; n=n->sig; } getch(); } void eliminar_nodo(lista *l,char c[]) { pnodo nodo,aux; if(!*l) printf("\nLista vacia....\nImposible eliminar elementos"); else { if(strcmp((*l)->nom,c)==0) { aux=*l; *l=aux->sig; free(aux); } else { aux=*l; while((aux->sig)&&(strcmp(aux->sig->nom,c))!= 0) aux=aux->sig;
} }
if(aux->sig) { nodo=aux->sig; aux->sig=nodo->sig; free(nodo); printf("\nSe elimino elemento %s con exito",c); } }
void eliminar(lista *l) {pnodo aux; while(*l) { aux=*l; *l=aux->sig; free(aux); } } void filtro_nombre(lista *l) { pnodo aux, aux2, nodo; aux=*l; while(aux->sig) { aux2=aux; while(aux2->sig) { if (strcmp(aux->nom,aux2->sig->nom)==0) { nodo=aux2->sig; aux2->sig=nodo->sig; free(nodo) ; } else aux2=aux2->sig; } aux=aux->sig; } }
Clase N 15:
Tema: Listas
El Ministerio de Interior ha elaborado para el segundo semestre del ao 2013 una lista de delincuentes buscados por la justicia ecuatoriana. Los datos que contienen esta lista son: apellidos, nombres, lugar de procesamiento, delito, valor de recompensa y nmero de aos de sentencia. Se necesita que el listado este en funcin de los ms peligrosos, esto est determinado por el valor de recompensa que se ofrece. Elabore un programa que permita contar con un men para registrar a los ms buscados, para capturar y en dicho proceso debe ser retirado de la lista de ms buscados y llevarlo a la lista de capturados, mostrar la lista de ms buscados, mostrar la lista de capturados, monto que invierte el estado en la captura de los ms buscados, salir del programa.
#include "stdio.h" #include "conio.h" #include "stdlib.h" #include "string.h" #include "iostream.h" typedef struct nodo{ char apellido[30]; char nombre[30]; char lugar_proceso[30]; char delito[30];
float valor_recompensa; int anio_sentencia; struct nodo *sig; }tiponodo; typedef tiponodo *lista; typedef tiponodo *pnodo; lista lmb=NULL; // lista para los mas buscados lista lca=NULL; // listas para los capturados void registrar(lista *l, char apellido[], char nombre[],char lugar_proceso[],char delito[], float valor, int anio); void capturar(lista *l, lista *m, char apellido[], char nombre[],char lugar_proceso[],char delito[], float valor_recompensa, int anio_sentencia); void mostrar(lista l); void eliminar(lista *l, char ap[], char nom[], char lugar[], char delito[], float valor, int anio); float monto(lista l); void main() { clrscr(); char apellido[30], nombre[30],lugar[30],delito[30]; float valor; int anio; int op; do{ clrscr(); cout<<"****************************************************"; cout<<"\n1. Registrar"; cout<<"\n2. Capturar"; cout<<"\n3. Mostrar lista de los mas buscados"; cout<<"\n4. Mostrar lista de los capturados"; cout<<"\n5. Monto que invierte el estado"; cout<<"\n6. Salir"; do{ cout<<"\nOpcion: ";cin>>op; } while((op>6)||(op<1)); if (op==1) { cout<<"\n****** Registro de datos ******"; cout<<"\nApellido: ";cin>>apellido; cout<<"\nNombre: ";cin>>nombre; cout<<"\nLugar procesamiento: "; fflush(stdin); cin>>lugar; cout<<"\nDelito: "; fflush(stdin); cin>>delito; cout<<"\nValor de recompensa"; fflush(stdin); cin>>valor; cout<<"\nAnio sentencia: "; fflush(stdin); cin>>anio;
registrar(&lmb, apellido, nombre, lugar, delito, valor, anio); } if (op==2) { cout<<"\nApellido: ";cin>>apellido; cout<<"\nNombre: ";cin>>nombre; cout<<"\nLugar procesamiento: "; fflush(stdin); cin>>lugar; cout<<"\nDelito: "; fflush(stdin); cin>>delito; cout<<"\nValor de recompensa"; fflush(stdin); cin>>valor; cout<<"\nAnio sentencia: "; fflush(stdin); cin>>anio; capturar(&lmb, &lca, apellido, nombre, lugar, delito,valor,anio); } if (op==3) { cout<<"****** Lista de los mas buscados ******"; mostrar(lmb); } if (op==4) { cout<<"****** Lista de los capturados******"; mostrar(lca); } if (op==5) { cout<<"****** Monto invertido por le estado ******"; cout<<"Hasta el momento el Ministerio de Interior invierte "<<monto(lmb)<<" en la captura de delincuentes."; getch(); } }while(op!=6); } void registrar(lista *l, char apellido[], char nombre[],char lugar_proceso[],char delito[], float valor, int anio) { pnodo nodo, aux=*l; nodo=(pnodo)malloc(sizeof(tiponodo)); strcpy(nodo->apellido,apellido); strcpy(nodo->nombre,nombre); strcpy(nodo->lugar_proceso,lugar_proceso); strcpy(nodo->delito,delito); nodo->valor_recompensa=valor; nodo->anio_sentencia=anio; if(!*l) { nodo->sig=NULL; *l=nodo; }
else if(aux->valor_recompensa < valor) { nodo->sig=*l; *l=nodo; } else { while((aux->sig!=NULL)&&(aux->sig->valor_recompensa > valor)) aux=aux->sig; nodo->sig=aux->sig; aux->sig=nodo; } getch(); } void capturar(lista *l, lista*m, char apellido[], char nombre[],char lugar_proceso[],char delito[], float valor_recompensa, int anio_sentencia) { char op='d'; lista p=*l; if (!p) printf("\n\nLa lista esta vacia"); else { do{ if((!strcmp(p->apellido,apellido))&&(!strcmp(p->nombre,nombre))&&(!strcmp(p>lugar_proceso,lugar_proceso))&&(!strcmp(p->delito,delito))&&(p>valor_recompensa==valor_recompensa)&&(p->anio_sentencia==anio_sentencia)) { registrar(&lca, p->apellido, p->nombre, p->lugar_proceso, p->delito, p>valor_recompensa, p->anio_sentencia); eliminar(&lmb,p->apellido, p->nombre, p->lugar_proceso, p->delito, p>valor_recompensa, p->anio_sentencia); }else { cout<<"No aparece en la lista de mas buscados\nDesea agregar el registro a capturados? (S/N)"; do{ cin>>op; }while(op!='s' && op!='S' && op!='n' && op!='N'); if (op=='s'){registrar(&lca, apellido, nombre, lugar_proceso, delito, valor_recompensa, anio_sentencia); } } p=p->sig; }while (p!=NULL); } getch(); }
void mostrar(lista l) { lista p=l; if (!l) printf("\n\nLa lista esta vacia"); else { do{ cout<<"\nApellido: "<<p->apellido; cout<<"\nNombre: "<<p->nombre; cout<<"\nLugar procesamiento: "<<p->lugar_proceso; cout<<"\nDelito: "<<p->delito; cout<<"\nValor de recompensa: "<<p->valor_recompensa; cout<<"\nAnio sentencia: "<<p->anio_sentencia<<endl<<endl; p=p->sig; }while (p!=NULL); getch();
} void eliminar(lista *l, char ap[], char nom[], char lugar[], char delito[],float valor, int anio) { pnodo nodo,aux; if(!*l) printf("\nLista vacia."); else { if((strcmp((*l)->apellido,ap)==0)&&(strcmp((*l)>nombre,nom)==0)&&(strcmp((*l)->lugar_proceso,lugar)==0)&&(strcmp((*l)>delito,delito)==0)&&((*l)->valor_recompensa==valor)&&((*l)>anio_sentencia==anio)) { aux=*l; *l=aux->sig; free(aux); } else { aux=*l; while((aux->sig)&&(strcmp(aux->sig->apellido,ap))!= 0&&(strcmp(aux->sig>nombre,nom))!= 0&&(strcmp(aux->sig->lugar_proceso,lugar))!= 0&&(strcmp(aux>sig->delito,delito))!= 0&&(aux->sig->valor_recompensa!=valor)&&(aux->sig>anio_sentencia!=anio)) aux=aux->sig; if(aux->sig) { nodo=aux->sig;
} } float monto(lista l) { float inversion=0; lista p=l; if (!l) {printf("\n\nLa lista esta vacia\n"); return(inversion); } else { do{ inversion+=p->valor_recompensa; p=p->sig; }while (p!=NULL); return(inversion); } }
} }
aux->sig=nodo->sig; free(nodo);
Clase N 16:
Tema: Aporte
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS Diario Metacognitivo Clase N 17:
PERIODO: TIEMPO: FECHA: DOCENTE GUIA: Del 6 de Mayo al 14 Septiembre del 2013 3 HORAS. Lunes, 01 de julio del 2013. Ing. Cristian Torres
Tema: Examen primer ciclo

DEFINICIONES DE ESTRUCTURA DE DATOS Definicin Variables, Tipos de datos. Representacin Grfica de la estructura de datos Acceso a las estructura de Datos Esttica y Dinmica Operaciones con vario punteros Asignacin dinmica de memoria Liberacin dinmica de memoria La constante NULL Ventajas y desventajas de punteros
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS
Materiales Relacionados Con La Clase
UNIVERSIDAD TECNICA DE MANAB FACULTAD DE CIENCIAS INFORMATICAS
ESTRUCTURA DE DATOS I
PROGRAMACIN EN C++
Lo importante en un individuo, no es lo que piensa, sino lo que hace J. Watson
FACULTAD DE CIENCIAS INFORMATICAS FCI - 2008 Autores: Ing. Esthela San Andres Ing. Christian Torres
Universidad Tecnica de Manab
Facultad de Ciencias Informaticas
ESTRUCTURA DE DATOS I
PROGRAMACIN EN C++
Sistema de Informacin
Introduccin.Un sistema de informacin es un conjunto de elementos que interactan entre s con el fin de apoyar las actividades de una empresa o negocio. El equipo computacional: el hardware necesario para que el sistema de informacin pueda operar. El recurso humano que interacta con el Sistema de Informacin, el cual est formado por las personas que utilizan el sistema. Un sistema de informacin realiza cuatro actividades bsicas: entrada, almacenamiento, procesamiento y salida de informacin.
Entrada de Informacin: Es el proceso mediante el cual el Sistema de Informacin toma los datos que requiere para procesar la informacin. Las entradas pueden ser manuales o automticas. Las manuales son aquellas que se proporcionan en forma directa por el usuario, mientras que las automticas son datos o informacin que provienen o son tomados de otros sistemas o mdulos. Esto ltimo se denomina interfases automticas.
Las unidades tpicas de entrada de datos a las computadoras son las terminales, las cintas magnticas, las unidades de diskette, los cdigos de barras, los escners, la voz, los monitores sensibles al tacto, el teclado y el mouse, entre otras. Almacenamiento de informacin: El almacenamiento es una de las actividades o capacidades ms importantes que tiene una computadora, ya que a travs de esta propiedad el sistema puede recordar la informacin guardada en la seccin o proceso anterior. Esta informacin suele ser almacenada en estructuras de informacin denominadas archivos. La unidad tpica de almacenamiento son los discos magnticos o discos duros, los discos flexibles o diskettes y los discos compactos (CD-ROM).
Salida de Informacin: La salida es la capacidad de un Sistema de Informacin para sacar la informacin procesada o bien datos de entrada al exterior. Las unidades tpicas de salida son las impresoras, terminales, diskettes, cintas magnticas, la voz, los graficadores y los plotters, entre otros. Es importante aclarar que la salida de un Sistema de Informacin puede constituir la entrada a otro Sistema de Informacin o mdulo. En este caso, tambin existe una interfase automtica de salida. Por ejemplo, el Sistema de Control de Clientes tiene una interfase automtica de salida con el Sistema de Contabilidad, ya que genera las plizas contables de los movimientos procesales de los clientes. Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
ESTRUCTURADE DATOS I -- FCI
Procesamiento de Informacin: Es la capacidad del Sistema de Informacin para efectuar clculos de acuerdo con una secuencia de operaciones preestablecida. Estos clculos pueden efectuarse con datos introducidos recientemente en el sistema o bien con datos que estn almacenados. Esta caracterstica de los sistemas permite la transformacin de datos fuente en informacin que puede ser utilizada para la toma de decisiones, lo que hace posible, entre otras cosas, que un tomador de decisiones genere una proyeccin financiera a partir de los datos que contiene un estado de resultados o un balance general de un ao base.
A continuacin se muestran las diferentes actividades que puede realizar un Sistema de Informacin de Control de Clientes:
Actividades que realiza un Sistema de Informacin: Entradas: Datos generales del cliente: nombre, direccin, tipo de cliente, etc. Polticas de crditos: lmite de crdito, plazo de pago, etc. Facturas (interfase automtico). Pagos, depuraciones, etc. Proceso: Clculo de antigedad de saldos. Clculo de intereses moratorios. Clculo del saldo de un cliente. Almacenamiento: Salidas: Reporte de pagos. Estados de cuenta. Plizas contables (interfase automtica) Consultas de saldos en pantalla de una terminal. Movimientos del mes (pagos, depuraciones). Catlogo de clientes. Facturas.
Las diferentes actividades que realiza un Sistema de Informacin se pueden observar en el diseo conceptual ilustrado en la en la figura 1.1.
ESTRUCTURA DE DATOS I -- FCI
Actividades que realiza un Sistema de Informacin, figura 1.1
Manual de Estructura de Datos
Tipos y Usos de los Sistemas de Informacin Durante los prximos aos, los Sistemas de Informacin cumplirn tres objetivos bsicos dentro de las organizaciones: 1. Automatizacin de procesos operativos. 2. Proporcionar informacin que sirva de apoyo al proceso de toma de decisiones. 3. Lograr ventajas competitivas a travs de su implantacin y uso.
Los Sistemas de Informacin que logran la automatizacin de procesos operativos dentro de una organizacin, son llamados frecuentemente Sistemas Transaccionales, ya que su funcin primordial consiste en procesar transacciones tales como pagos, cobros, plizas, entradas, salidas, etc. Por otra parte, los Sistemas de Informacin que apoyan el proceso de toma de decisiones son los Sistemas de Soporte a la Toma de Decisiones, Sistemas para la Toma de Decisin de Grupo, Sistemas Expertos de Soporte a la Toma de Decisiones y Sistema de Informacin para Ejecutivos. El tercer tipo de sistema, de acuerdo con su uso u objetivos que cumplen, es el de los Sistemas Estratgicos, los cuales se desarrollan en las organizaciones con el fin de lograr ventajas competitivas, a travs del uso de la tecnologa de informacin.
Los tipos y usos de los Sistemas de Informacin se muestran en la figura 1.2.
A continuacin se mencionan las principales caractersticas de estos tipos de Sistemas de Informacin.
Sistemas Transaccionales. Sus principales caractersticas son: A travs de stos suelen lograrse ahorros significativos de mano de obra, debido a que automatizan tareas operativas de la organizacin. Con frecuencia son el primer tipo de Sistemas de Informacin que se implanta en las organizaciones. Se empieza apoyando las tareas a nivel operativo de la organizacin. Son intensivos en entrada y salid de informacin; sus clculos y procesos suelen ser simples y poco sofisticados. Tienen la propiedad de ser recolectores de informacin, es decir, a travs de estos sistemas se cargan las grandes bases de informacin para su explotacin posterior. Son fciles de justificar ante la direccin general, ya que sus beneficios son visibles y palpables. ESTRUCTURADE DATOS I -- FCI
Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
Sistemas de Apoyo de las Decisiones. Las principales caractersticas de estos son: Suelen introducirse despus de haber implantado los Sistemas Transaccionales ms relevantes de la empresa, ya que estos ltimos constituyen su plataforma de informacin. La informacin que generan sirve de apoyo a los mandos intermedios y a la alta administracin en el proceso de toma de decisiones. Suelen ser intensivos en clculos y escasos en entradas y salidas de informacin. As, por ejemplo, un modelo de planeacin financiera requiere poca informacin de entrada, genera poca informacin como resultado, pero puede realizar muchos clculos durante su proceso. No suelen ahorrar mano de obra. Debido a ello, la justificacin econmica para el desarrollo de estos sistemas es difcil, ya que no se conocen los ingresos del proyecto de inversin. Suelen ser Sistemas de Informacin interactivos y amigables, con altos estndares de diseo grfico y visual, ya que estn dirigidos al usuario final. Apoyan la toma de decisiones que, por su misma naturaleza son repetitivos y de decisiones no estructuradas que no suelen repetirse. Por ejemplo, un Sistema de Compra de Materiales que indique cundo debe hacerse un pedido al proveedor o un Sistema de Simulacin de Negocios que apoye la decisin de introducir un nuevo producto al mercado. Estos sistemas pueden ser desarrollados directamente por el usuario final sin la participacin operativa de los analistas y programadores del rea de informtica. Este tipo de sistemas puede incluir la programacin de la produccin, compra de materiales, flujo de fondos, proyecciones financieras, m od el os d e si mul aci n de n eg oci os, mod el os d e in v enta r ios, etc .
Sistemas Estratgicos. Sus principales caractersticas son: Su funcin primordial no es apoyar la automatizacin de procesos operativos ni proporcionar informacin para apoyar la toma de decisiones. Suelen desarrollarse in house, es decir, dentro de la organizacin, por lo tanto no pueden adaptarse fcilmente a paquetes disponibles en el mercado. Tpicamente su forma de desarrollo es a base de incrementos y a travs de su evolucin dentro de la organizacin. Se inicia con un proceso o funcin en particular y a partir de ah se van agregando nuevas funciones o procesos. Su funcin es lograr ventajas que los competidores no posean, tales como ventajas en costos y servicios diferenciados con clientes y proveedores. En este contexto, los Sistema Estratgicos son creadores de barreras de entrada al negocio. Por ejemplo, el uso de cajeros automticos en los bancos en un Sistema Estratgico, ya que brinda ventaja sobre un banco que no posee tal servicio. Si un banco nuevo decide abrir sus puertas al pblico, tendr que dar este servicio para tener un nivel similar al de sus competidores. Apoyan el proceso de innovacin de productos y proceso dentro de la empresa debido a que buscan ventajas respecto a los competidores y una forma de hacerlo en innovando o creando productos y procesos.
Tipos de datos Bit. U nid ad de in fo rm ac i n ms s e nci ll a en el s istem a bi na r io. B yte. Un idad d e i nf o r maci n qu e c onst a d e 8 bits e qu i va le nt e a u n ni co car ct er , c omo un a let r a, n m er o o si gn o d e p untu aci n. Ca rct e r. Es u n el em ent o to mad o d e u n con ju nto d e s mb ol os . E jem p lo : a,b,c,0 ,1,%= Pa lab r a. C o nju nt o d e bi ts q ue p ue de n s e r ma ni pu lad o s p o r u na c om pu tado ra . La l o ngit ud de u na p a lab ra e n un a c om put a do ra p ue de se r: 8, 16 , 31, etc. De p end e d e l Mic r op r oc esad o r Manipulacin de bits Digit al iz aci n de la in f or mac i n. Se c o nv i ert e te xt o, so ni do o img e nes e n f o rmat o q ue p ue de s e r ent e ndid o p or l a PC. Los m ic ro p ro ces ad or es ent ie nd en e l f o rmat o d e 0,1s . Los m ic ro p r oc esad o res det ect an cu and o un b it s e c ar ga y su va lo r es igu al a 1 Se p u ed en r e pr es ent a r u na g ran di v e rsid ad de va l or es: fem en in o y m ascu li n o, etc. ve rd a d y fa lso,
La e fic i enc ia d e las pc s no se basa e n l a c om pl ej id ad d e s u l g ica La e fic i enc ia d e las pc s se b asa en la v e loc id ad d e t rab aj o. Ej em p lo de co mbi nac io nes p osib l es: 2 bits , 8 bits Si s e uti li zan 8 bits pa ra re p r ese nta r u n ca r cte r, se pu ed en re p r es ent ar h asta 256 ca ract e res d if e re n tes, p u esto qu e ex iste n 256 p at ro n es o co m bina ci on es dif e re ntes d e 8 b its. Los com p utad o res d if i e re n co n r es pe cto a l nm er o d e bits uti li zad os p a ra r ep r es enta r un ca rct e r Clasificacin de los tipos de datos En fu nc i n d e qu i en los def in e: o o Ti p os d e d atos est nd a r. Ti p os d e d atos de fi nid o s p or e l us ua r io
En fu nc i n d e l a r ep r es ent aci n int e rn a: o o ESTRUCTURADE DATOS I -- FCI Ti p os d e d atos esc al ar es o sim p les Ti p os d e d atos est ruct u rad os.
Los ti p os d e d atos sim pl es s on l os si gui e ntes : Num r ic os ( Int eg e r, R e al ) Lg icos ( B oo le an ) Ca rct e r (C ha r, St ri ng )

Representacin de datos simples
Dato. R e pr es ent aci n f or ma d e hec hos , c onc e ptos o inst r ucci o nes Ti p o de dat o. Un co nj u nto d e va l or es, a q ue ll o s qu e p ue de to ma r cua lq ui e r dat o de d ich o t ip o. Las va r iab les y co nsta ntes qu e fo rm an pa rte de un p r og ram a p e rte nec e n a u n ti p o de d a t os d et er mi nad o. De esta f or ma, los va l or es as oci ad o s a dichas va r iab les (o co nsta ntes ) p ue de n o pe r ar c on ot r os d e ac ue rd o a s u nat ur al ez a ( p . e. d os n me r os e nte r o s pu ed en s e r mu lti pl ic ados p er o n o ti e ne s e ntid o ha ce r esa o pe r aci n co n c ad e nas d e c a ract e res ). NU M ER O S EN T ER O S Si ut ili za mos 32 bits pa ra re p r ese nta r n me ro ent e ros, dis p on em o s d e 2^32 c ombi nac io n es d i fe r ent es d e 0 y 1`s: 4294967 296 va l or es. C omo te n em os qu e r ep r es enta r nm e ro n egat i vos y e l c e ro: -2 147 483 6 48 a l +2 147 483 647 NU M ER O S R E A L ES . (+|-) mantisa x 2 e x p o n e n t e En l a not aci n d el pu nto fl ota nt e u n n me r o r eal es t r e p res e nta do p o r u na hil e ra d e 32 bits f o rma da p o r un a ma ntisa d e 24 bits seg uid a de un ex p on ent e de 8 bits. La bas e se f ij a com o 10. Ta nt o la m ant isa como el e x po ne nt e son ent e ro s bina r ios de co mp l em en to d obl e.
Tipos de datos abstractos Un tipo de datos abstracto TDA defi n e u na nu e va c las e de ob j eto o c onc e pt o qu e p ue de ma ne ja rs e co n i nd e pe nd enc ia de la est ruct u ra de datos p a ra r ep r es enta r lo . Pa r a e ll o es nec es ar io es pec if ica r: Las o p e rac io n es qu e s e pu ed e r ea li za r c on l os obj etos . El e fe cto q ue se p r odu c e a l a ctua r c o n l as o p e rac io n es so br e los mis mos. ESTRUCTURA DE DATOS I -- FCI . U n TD A enc a psu la la d efi ni ci n de l ti p o y t oda s l as o pe r aci on es c o n e ste ti p o. Los l en gua j es de p ro gr amac i n e ntr eg an al pr og ram ad or c ie rt os ti po s de dat o s bsic os o pr imit i vos, e sp ecif ic and o e l co nj unt o de va lo r es q u e un a v ar iab le d e un o d e es os t i pos p u e de t om ar y el c on ju nto de o p e rac io n es r ea li z abl es s ob re los m ism os. P or e je mp l o, si s e dec l ar a e n C/ C++ unsigned int x, y;
La i nstr ucc i n n = 9+10 de un p r og ram a d ond e = es el o pe ra do r d e asig nac i n , el co nte ni do de la l oca l idad de al mac en ami e nt o da do p o r n ser e l va l or 19. Cad a tip o d e datos : es rec on oc ido p or l os e l e ment os de d atos qu e p ued e tom a r y po r las o pe ra ci on es asoc ia das a l. (su dom in io ) E jem p lo : en p asca l Dom ini o ent e r o D= {0, 1, 2.ma x } O pe r aci on es
Los T D As so n ge n er al i zac io nes de los ti p os de dat os bs ic os y d e las o p e rac io nes p rim iti vas . U n TD A en caps ul a ti p os d e dat o s en el s e ntid o qu e e s pos ibl e p on e r l a def in ici n de l ti p o y todas las o pe ra ci on es con es e ti p o e n u n a secc i n d e u n p ro gr ama . P or ej em pl o, s e p ue de def in ir un ti p o de d ato s abstra cto C O NJ UNT O [ Ah o198 8] c on e l cua l se p u ed en d ef in i r l as sig ui ent es o pe r aci o nes: AN UL A ( A ) Hac e v ac o a l c on ju nto A UNI ON ( A, B, C ) Co nstr u y e el c o nju nt o C a p art i r d e la un i n de los co nj unt os A y B. T A M A O( A ) Ent r eg a l a ca nti dad de el em ent os d e l co nj unt o A. El co mp o ne nt e bs ico de una est r uctu ra de d atos es la c el da. La c eld a a lma ce na un v al or tom ad o d e a lg n t i po d e dat o s im pl e o c o mpu est o El m eca nism o de ag r e gaci n d e c el das ll am ado a r re gl o es una c o lec ci n de el em ent os d e t ip o hom og n eo . A r re gl o b idim e nsi on al en C/ C++ int w[5][3] w[ i ] [j ] = b [ i * n + j] n es la c ant ida d d e col umn as d el a r re gl o w[ 2] [0 ] = b [6 ] ESTRUCTURADE DATOS I -- FCI
Estructuras de datos So n datos elementales aquellos que se consideran indivisibles en unidades ms simples. Un a est ru ctu ra d e dat os es u na c las e de d atos qu e s e pu ed e ca ract e ri za r po r s u or ga ni zac i n y o pe r aci on es d ef in idas s ob r e e lla . Al gun as v eces a es tas est ru ctu ras s e les ll ama ti pos d e dat o s. Los ti pos d e d atos p ro gr amac i n s on : ms fr ec u ent es uti li z ados en los d if er e nt es l eng ua jes de
Lgicas de datos.- En un p r og ram a, c ada v a r iabl e p e rt en ec e a al gu na es t ruct u ra d e datos e xp lc ita o im p lc itam ent e d ef in ida, la c ual det e rmi na el c o nju nto d e op e rac i on e s va lid as pa ra e ll a. Primitivas y simples.- A qu e ll as q ue no est n com p uest as p o r ot r as est ruct u ras d e datos p o r ej em pl o, ent e ros, bo ol ea n os y ca r ac ter es. Lineales: pilas , c olas y listas li gad as l in ea l es. No lineales incluyen grafos y rb ol es. Organizacin de archivos.- Las tcnic as de estr uctu ra ci n d e datos a pl ica das a con ju ntos de dat os qu e los s iste mas o p e rati v os ma n eja n c o mo ca jas ne g ras com nm ent e s e lla ma n O rg a ni za c i n de A rc h iv o s.
CLASIFICACIN DE LAS ESTRUCTURAS DE DATOS

Se clasifican en: a) Por su almacenamiento b) Por su organizacin c) Por su comportamiento a) Por su almacenamiento.- Se clasifican en: Internas Externas Internas.- Son aquellas cuyas estructuras se almacena en la memoria principal. Externas.- Son aquellas que se almacenan en las memorias secundarias de un sistema de computadoras. b) Por su organizacin.- Se clasifican en: Estticas Dinmicas Estticas.- son aquellas cuya agrupacin de memoria no se disminuye o aumenta estas son: cadenas, conjuntos, escalares, entre otros. Dinmicas.- Son aquellas cuya agrupacin de memoria pueden aumentar o disminuir durante la ejecucin del programa, estas son: pila, colas, listas. ESTRUCTURA DE DATOS I -- FCI d) Por su comportamiento.- Se clasifican en: Simples Compuesto o Estructurados Simples.-Son aquellas que almacenan un valor y son: Enteros Real Lgicos Caracteres
Escalares
Compuesto.- Son aquellos que almacenan mltiples valores en su estructura y son los siguientes: Cadenas Arreglos Conjuntos Registros Listas Pilas Colas rboles Archivos Base de datos
Clasificacin de las estructuras de Datos
Simples
Enteros Reales Caracteres Cadena Booleano Arreglo Conjunto Registro Listas Pilas Colas
Esttico
Estructurados Dinmicos
Lineales
No Lineales rboles Grafos
Los ti pos d e dat os sim pl es pu ed en s er o rga ni zad os e n di fe r ent es est ruct u ras d e dat os : estt icas y di nm icas.
Las estructuras de datos estticas:

So n a q ue ll as en las q ue el t ama o oc u pad o en m em o ri a se d e fin e a ntes de q ue e l p ro gr ama se ej ecut e y n o pu ed e m od if ica rs e dic ho tam a o d u rant e la e j ecuc i n de l p ro gr ama . Est as est r uctu ras est n im p le me ntad as en c a si tod o s los l en gua j es. Su pr inc i pa l c a ract e rs tica es qu e ocu p an so lo u na casi ll a de m em or ia, po r l o t ant o una v a ria bl e sim p l e h ace r ef e re nc ia a u n n ico v al o r a la v ez , d en tro de est e g r up o
de d atos s e en cu ent ra : ent e ros , re al es, c a ract e res, bo l an os, en um e r ados y s ub ra ng os (l os lti mos n o e x iste n en al gu nos l eng ua jes d e p rog r amac i n )
Las estructuras de datos dinmicas:

No ti en e n las lim itac io nes o r est ri cci on es en el ta ma o d e m em or ia ocu p ada qu e s o n p ro p ias d e las est ruct u ras estt icas . M edi ant e el us o de u n ti p o d e dat os es pe cifi co, d en omi na do p u nte r o, es p osib l e const r ui r est ru ctu ras d e dat os di nm icas qu e no s on so p o rtad as p o r la ma y o ra d e l os le ngu aj es, p er o qu e en aq u el los q ue s i ti en en estas c ar act er stic as o f r ece n so lu ci on es efi cac es y ef ect iv as en la s ol uci n d e pr ob lem as co mp l ej os. Se c a ract e ri za po r el h ech o d e q ue c o n un n omb re s e ha ce r ef er e n cia a u n g ru p o de casi llas d e m emo r ia. E s dec i r u n dat o est ruct ur ad o ti en e va r ios com po n ent es.
VARIABLES ESTRUCTURADAS O ARREGLOS CONJUNTO DE DATOS DEL MISMO DEL MISMO TIPO AGRUPADOS BAJO UN SOLO NOMBRE
Pa r a r ef e ri r nos a un o de el los s e ha ce r ef er enc ia a la p osic i n qu e oc u pa el d at o r esp ect o a los ot ros. Pu ed en s e r u ni dems io na les ( v ecto r es ) mu ltid ime nsi o nal es ( matr ic es ) Ej : vo ca l= {a, e,i ,o, u } La l ista d e c las e c o n n otas VECTORES A r re gl os u ni dim ens in al es: Ej em p lo: Lista d e Cl ase Co la p ar a c om p ra r ti ck est Voca les d el abe ce da ri o .
OPERACIONES CON VECTORES P ode mos hac e r c on un v ecto r: ESTRUCTURA DE DATOS I -- FCI Lle na r Most r ar O rd en ar Busc a r: Se cu enc ia l Bi na ri a
10

Estructuras
Supongamos que queremos hacer una agenda con los nmeros de telfono de nuestros amigos. Necesitaramos un array de Cadenas para almacenar sus nombres, otro para sus apellidos y otro para sus nmeros de telfono. Esto puede hacer que el programa quede desordenado y difcil de seguir. Y aqu es donde vienen en nuestro auxilio las estructuras. Para definir una estructura usamos el siguiente formato: struct nombre_de_la_estructura { campos de estructura; }; NOTA: Es importante no olvidar el ';' del final, si no a veces se obtienen errores extraos. Para nuestro ejemplo podemos crear una estructura en la que almacenaremos los datos de cada persona. Vamos a crear una declaracin de estructura llamada amigo: struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; char edad; }; A cada elemento de esta estructura (nombre, apellido, telfono) se le llama campo o miembro. (NOTA: He declarado edad como char porque no conozco a nadie con ms de 127 aos. Ahora ya tenemos definida la estructura, pero aun no podemos usarla. Necesitamos declarar una variable con esa estructura. struct estructura_amigo amigo; Ahora la variable amigo es de tipo estructura_amigo. Para acceder al nombre de amigo usamos: amigo.nombre. Vamos a ver un ejemplo de aplicacin de esta estructura. (NOTA: En el siguiente ejemplo los datos no se guardan en disco as que cuanda acaba la ejecucin del programa se pierden). #include <stdio.h> struct estructura_amigo {/* Definimos la estructura estructura_amigo */ char nombre[30]; char apellido[40]; char telefono[10]; char edad; }; struct estructura_amigo amigo; void main() { printf( "Escribe el nombre del amigo: " ); fflush( stdout ); scanf( "%s", &amigo.nombre ); printf( "Escribe el apellido del amigo: " ); fflush( stdout ); scanf( "%s", &amigo.apellido ); printf( "Escribe el nmero de telfono del amigo: " ); fflush( stdout ); scanf( "%s", &amigo.telefono ); printf( "El amigo %s %s tiene el nmero: %s.\n", amigo.nombre, amigo.apellido, amigo.telefono ); } Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
11
Este ejemplo estara mejor usando gets que scanf, ya que puede haber nombres compuestos que scanf no cogera por los espacios.
Se podra haber declarado directamente la variable amigo: struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; } amigo; Arrays de estructuras Supongamos ahora que queremos guardar la informacin de varios amigos. Con una variable de estructura slo podemos guardar los datos de uno. Para manejar los datos de ms gente (al conjunto de todos los datos de cada persona se les llama REGISTRO) necesitamos declarar arrays de estructuras. Cmo se hace esto? Siguiendo nuestro ejemplo vamos a crear un array de ELEMENTOS elementos: struct estructura_amigo amigo[ELEMENTOS]; Ahora necesitamos saber cmo acceder a cada elemento del array. La variable definida es amigo, por lo tanto para acceder al primer elemento usaremos amigo[0] y a su miembro nombre: amigo[0].nombre. Veamoslo en un ejemplo en el que se supone que tenemos que meter los datos de tres amigos: #include <stdio.h> #define ELEMENTOS 3 struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo[ELEMENTOS]; void main() { int num_amigo; for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf( "\nDatos del amigo nmero %i:\n", num_amigo+1 ); printf( "Nombre: " ); fflush( stdout ); gets(amigo[num_amigo].nombre); printf( "Apellido: " ); fflush( stdout ); gets(amigo[num_amigo].apellido); printf( "Telfono: " ); fflush( stdout ); gets(amigo[num_amigo].telefono); printf( "Edad: " ); fflush( stdout ); scanf( "%i", &amigo[num_amigo].edad ); while(getchar()!='\n'); } /* Ahora imprimimos sus datos */ for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf( "El amigo %s ", amigo[num_amigo].nombre ); printf( "%s tiene ", amigo[num_amigo].apellido );
12
printf( "%i aos ", amigo[num_amigo].edad ); printf( "y su telfono es el %s.\n" , amigo[num_amigo].telefono ); } } IMPORTANTE: Quizs alguien se pregunte qu pinta la lnea esa de while(getchar()!='\n');. Esta lnea se usa para vaciar el buffer de entrada. Para ms informacin consulta Qu son los buffer y cmo funcionan.
Inicializar una estructura

A las estructuras se les pueden dar valores iniciales de manera anloga a como hacamos con los arrays. Primero tenemos que definir la estructura y luego cuando declaramos una variable como estructura le damos el valor inicial que queramos. Recordemos que esto no es en absoluto necesario. Para la estructura que hemos definido antes sera por ejemplo: struct estructura_amigo amigo = { "Juanjo", "Lopez", "592-0483", 30 }; NOTA: En algunos compiladores es posible que se exiga poner antes de struct la palabra static. Por supuesto hemos de meter en cada campo el tipo de datos correcto. La definicin de la estructura es: struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; por lo tanto el nombre ("Juanjo") debe ser una cadena de no ms de 29 letras (recordemos que hay que reservar un espacio para el smbolo '\0'), el apellido ("Lopez") una cadena de menos de 39, el telfono una de 9 y la edad debe ser de tipo char.
Vamos a ver la inicializacin de estructuras en accin: #include <stdio.h> struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo = { "Juanjo", "Lopez", "592-0483", 30 }; int main() { printf( "%s tiene ", amigo.apellido ); printf( "%i aos ", amigo.edad ); printf( "y su telfono es el %s.\n" , amigo.telefono ); Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
13

}
Tambin se puede inicializar un array de estructuras de la forma siguiente: struct estructura_amigo amigo[] = { "Juanjo", "Lopez", "504-4342", 30, "Marcos", "Gamindez", "405-4823", 42, "Ana", "Martinez", "533-5694", 20 };
En este ejemplo cada lnea es un registro. Como suceda en los arrays si damos valores iniciales al array de estructuras no hace falta indicar cuntos elementos va a tener. En este caso la matriz tiene 3 elementos, que son los que le hemos pasado. Paso de estructuras a funciones Las estructuras se pueden pasar directamente a una funcin igual que hacamos con las variables. Por supuesto en la definicin de la funcin debemos indicar el tipo de argumento que usamos:
int nombre_funcin ( struct nombre_de_la_estructura nombre_de_la variable_estructura )
En el ejemplo siguiente se usa una funcin llamada suma que calcula cual ser la edad 20 aos ms tarde (simplemente suma 20 a la edad). Esta funcin toma como argumento la variable estructura arg_amigo. Cuando se ejecuta el programa llamamos a suma desde main y en esta variable se copia el contenido de la variable amigo.
Esta funcin devuelve un valor entero (porque est declarada como int) y el valor que devuelve (mediante return) es la suma. #include <stdio.h> struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; ESTRUCTURA DE DATOS I -- FCI struct estructura_amigo amigo = { "Juanjo", "Lopez", "592-0483", 30 }; int suma( struct estructura_amigo arg_amigo ) { return arg_amigo.edad+20; } int main()
14

{ printf( "%s tiene ", amigo.apellido ); printf( "%i aos ", amigo.edad ); printf( "y dentro de 20 aos tendr %i.\n", suma(amigo) ); }
Si dentro de la funcin suma hubisemos cambiado algn valor de la estructura, dado que es una copia no hubiera afectado a la variable amigo de main. Es decir, si dentro de 'suma' hacemos arg_amigo.edad = 20; el valor de arg_amigo cambiar, pero el de amigo seguir siendo 30. Tambin se pueden pasar estructuras mediante punteros o se puede pasar simplemente un miembro (o campo) de la estructura. Si usamos punteros para pasar estructuras como argumentos habr que hacer unos cambios al cdigo anterior (en negrita y subrrayado): int suma( struct estructura_amigo *arg_amigo ) { return arg_amigo->edad+20; } int main() { printf( "%s tiene ", amigo.apellido ); printf( "%i aos ", amigo.edad ); printf( "y dentro de 20 aos tendr %i.\n", suma(&amigo) ); } Lo primero ser indicar a la funcin suma que lo que va a recibir es un puntero, para eso ponemos el * (asterisco). Segundo, como dentro de la funcin suma usamos un puntero a estructura y no una variable estructura debemos cambiar el '.' (punto) por el '->'. Tercero, dentro de main cuando llamamos a suma debemos pasar la direccin de amigo, no su valor, por lo tanto debemos poner '&' delante de amigo. Si usamos punteros a estructuras corremos el riesgo (o tenemos la ventaja, segn cmo se mire) de poder cambiar los datos de la estructura de la variable amigo de main.
Pasar slo miembros de la estructura

Otra posibilidad es no pasar toda la estructura a la funcin sino tan slo los miembros que sean necesarios. Los ejemplos anteriores seran ms correctos usando esta tercera opcin, ya que slo usamos el miembro 'edad': int suma( char edad ) { return edad+20; } int main() { printf( "%s tiene ", amigo.apellido ); printf( "%i aos ", amigo.edad ); printf( "y dentro de 20 aos tendr %i.\n", suma(amigo.edad) ); } Por supuesto a la funcin suma hay que indicarle que va a recibir una variable tipo char (amigo->edad es de tipo char).
15

Estructuras dentro de estructuras (Anidadas)
Es posible crear estructuras que tengan como miembros otras estructuras. Esto tiene diversas utilidades, por ejemplo tener la estructura de datos ms ordenada. Imaginemos la siguiente situacin: una tienda de msica quiere hacer un programa para el inventario de los discos, cintas y cd's que tienen. Para cada ttulo quiere conocer las existencias en cada soporte (cinta, disco, cd), y los datos del proveedor (el que le vende ese disco). Podra pensar en una estructura as:
struct inventario { char titulo[30]; char autor[40]; int existencias_discos; int existencias_cintas; int existencias_cd; char nombre_proveedor[40]; char telefono_proveedor[10]; char direccion_proveedor[100]; };
Sin embargo utilizando estructuras anidadas se podra hacer de esta otra forma ms ordenada: struct estruc_existencias { int discos; int cintas; int cd; }; struct estruc_proveedor { char nombre[40]; char telefono[10]; char direccion[100]; }; struct estruc_inventario { char titulo[30]; char autor[40]; struct estruc_existencias existencias; struct estruc_proveedor proveedor; } inventario;
Ahora para acceder al nmero de cd de cierto ttulo usaramos lo siguiente: inventario.existencias.cd ESTRUCTURA DE DATOS I -- FCI y para acceder al nombre del proveedor: inventario.proveedor.nombre
16

Tipos de datos definidos por el usuario
Typedef
Ya conocemos los tipos de datos que nos ofrece C: char, int, float, double con sus variantes unsigned, arrays y punteros. Adems tenemos las estructuras. Pero existe una forma de dar nombre a los tipos ya establecidos y a sus posibles variaciones: usando typedef. Con typedef podemos crear nombres para los tipos de datos ya existentes, ya sea por capricho o para mejorar la legibilidad o la portabilidad del programa.
Por ejemplo, hay muchos programas que definen muchas variables del tipo unsigned char. Imaginemos un hipottico programa que dibuja una grfica: unsigned char x0, y0; unsigned char x1, y1; unsigned char x, y; int F; int i; /* Coordenadas del punto origen */ /* Coordenadas del punto final */ /* Coordenadas de un punto genrico */
/* valor de la funcin en el punto (x,y) */ /* Esta la usamos como contador para los bucles */
La definicin del tipo unsigned char aparte de ser larga no nos da informacin de para qu se usa la variable, slo del tipo de dato que es. Para definir nuestros propios tipos de datos debemos usar typedef de la siguiente forma: typedef tipo_de_variable nombre_nuevo; En nuestro ejemplo podramos hacer: typedef unsigned char COORD; typedef int CONTADOR; typedef int VALOR;
y ahora quedara: ESTRUCTURADE DATOS I -- FCI COORD x0, y0; /* punto origen */ COORD x1, y1; /* punto final */ COORD x, y; VALOR F; CONTADOR i; /* punto genrico */ /* valor de la funcin en el punto (x,y) */
17
Ahora, nuestros nuevos tipos de datos, aparte de definir el tipo de variable nos dan informacin adicional de las variables. Sabemos que x0, y0, x1, y1, x, y son coordenadas y que i es un contador sin necesidad de indicarlo con un comentario.
Realmente no estamos creando nuevos tipos de datos, lo que estamos haciendo es darles un nombre ms cmodo para trabajar y con sentido para nosotros.
Punteros Tambin podemos definir tipos de punteros: int *p, *q; Podemos convertirlo en: typedef int *ENTERO; ENTERO p, q; Aqu p, q son punteros aunque no lleven el operador '*', puesto que ya lo lleva ENTERO incorporado. Arrays Tambin podemos declarar tipos array. Esto puede resultar ms cmodo para la gente que viene de BASIC o PASCAL, que estaban acostumbrados al tipo string en vez de char: typedef char STRING[255]; STRING nombre; donde nombre es realmente char nombre[255];. Estructuras Tambin podemos definir tipos de estructuras. Antes, sin typedef: struct _complejo { double real; double imaginario; }; struct _complejo numero; Con typedef: typedef struct { double real; double imaginario; } COMPLEJO; COMPLEJO numero;
18

Asignacin de Memoria Dinmica Mtodos de Asignacin de Memoria
Cules son los mtodos de asignacin de memoria utilizados por el S.O.? Cabe destacar que el almacenamiento y procesamiento de todos los datos es realizado en memoria RAM, en un segmento destinado a ello (DS), por ello, es importante conocer los mtodos de asignacin de memoria utilizados para su almacenamiento. Por un lado, se tiene la asignacin esttica de memoria en donde se reserva la cantidad necesaria para almacenar los datos de cada estructura en tiempo de compilacin. Esto ocurre cuando el compilador convierte el cdigo fuente (escrito en algn lenguaje de alto nivel) a cdigo objeto y solicita al S.O. la cantidad de memoria necesaria para manejar las estructuras que el programador utiliz, quien segn ciertos algoritmos de asignacin de memoria, busca un bloque que satisfaga los requerimientos de su cliente. Por otro lado se tiene la asignacin dinmica en donde la reserva de memoria se produce durante la ejecucin del programa (tiempo de ejecucin). Para ello, el lenguaje Pascal cuenta con dos procedimientos: NEW() y DISPOSE() quienes realizan llamadas al S.O. solicitndole un servicio en tiempos de ejecucin. El procedimiento NEW ,por su parte, solicita reserva de un espacio de memoria y DISPOSE la liberacin de la memoria reservada a travs de una variable especial que direccionar el bloque asignado o liberado segn sea el caso.
Ejemplo : Cuando se compilan las sgtes. Lneas de cdigo se produce una asignacin esttica de memoria: var linea: string [80]; (*Se solicita memoria para 80 caracteres --> 80 bytes) operatoria: Array[1..100,1..100] of real; (*Se solicita memoria para 100x100 reales -> 100 x 100 x 4 bytes)
(*Se solicita memoria para 1 entero --> 2 bytes) Cuntos bytes se reservaran para:? datos: array [1..25] of double; Para explicar con mayor detalle el concepto de memoria dinmica es necesario conocer el concepto PUNTEROS!
interes : integer;
19
Punteros
Son tipos de datos simples capaces de almacenar la posicin de una variable en memoria principal. Se dice que ellos direccionan a otras variables. Ejemplo:
Se dice que las variables ubicadas en las posiciones 1003 y 1006 son punteros, pues direccionan o "apuntan a" las posiciones 1000 y 1007 respectivamente.
Otra explicacin.Un pu nte r o es u n obj et o q ue a p unta a otr o ob jet o. Es d eci r, u na va ri abl e cu yo va lo r es la d i rec ci n de mem o ri a d e ot ra va ri abl e. No h a y qu e c o nfu ndi r una di r ecc i n d e m em or ia co n el co nte ni do d e esa d i re cci n d e mem or ia . i nt x = 2 5; D i rec ci n 15 02 1504 1 506 1508
La di r ecc i n d e la va r ia ble x ( & x) es 1502 El co nt en ido d e l a va ri a ble x es 2 5 Las di rec ci on es de m e mo ria d e p end en d e l a ar q uit ectu r a de l o rd en ado r y de l a gest i n qu e e l sist ema o p e rati v o h aga de e ll a. En l en gua j e e nsam bla d or se deb e ind ica r num ric ame nt e l a pos ici n fsic a d e m em or i a en qu e qu e re mos a lma cen a r un d ato. D e a h qu e est e l en gu aj e de p end a tant o d e l a m qui na e n l a qu e s e a pl i qu e. En C n o d eb em os, n i p od emos , i nd ica r num r icam ent e la di r ecc i n de m em o ri a, s i n o qu e ut il iz amos una eti qu et a q ue c on oc em os com o va r iab le ( en su da d efi ni mos l as va r iab les com o di r ecci on es d e m em o ri a) . L o qu e n os i nte r esa es al mace na r un dat o, y no la l oca li zac i n ex act a d e es e d ato e n m em o ri a.
20
Un a v ar iab l e p unt e ro s e dec la r a com o tod as l as va r iab les. D eb e se r del m ismo t ip o qu e la va r iab le a pu ntad a. S u id e ntif ica do r va p r ec edi do de un ast e risc o ( *): i nt * p u nt; Es un a v ar iab l e pu nt er o q ue a pu nta a va ri ab le qu e c o nti en e un d a to d e ti po ent e ro lla mad a pu nt. ch a r *c ar: Es un p unt e ro a va ri abl e d e ti p o c ar ct er . l o ng f lo at *n um; f lo at * mat[ 5] ; // . . .
Es d eci r: ha y ta ntos tip os d e p unt e ros c omo t ip os d e dat os, aun q u e tambi n pu ed en de cla r ars e pu nt er os a estruct ur as ms c om p le jas ( func i on es, st r uct , fich e ros ... ) e i ncl uso p u nte r os vac os ( v oid ) y pu nt er os nu los (N ULL ). Dec la rac i n d e v ar iab le s pu nt er o: S ea un f rag ment o d e p r og ram a e n C: cha r dat o; cha r * p unt; // v a riab l e q ue al mac en a r un c a r cte r. //d ec la r aci n de p unt e ro a c ar cte r.
pu nt = & dat o; // e n l a va r iab le p unt gu ar dam o s la d i re cci n // d e m em o ria d e l a va r iab le dat o; pu nt a p u nta // a d ato . Ambas so n del mism o t ip o, ch ar. int * p unt = N ULL, va r = 14; pu nt = & va r; p ri ntf ( %# X, %# X , pu nt, & va r ) // la m ism a s ali da: di r ecci n //sa lid a: 1 4, 14
p ri ntf ( \n% d, %d , * pu nt, va r );
H a y qu e t en e r c uid ad o c on las di r ecci on es a pu ntad as: p ri ntf ( %d, %d , * ( pu n t+1), v a r+1 ); *( pu nt + 1 ) r e pes e nta el v al o r co nt en ida e n la d i rec ci n de m em o ri a a um enta da en una p osi ci n ( int=2 by tes) , qu e s e r un v al or n o d ese ad o. Si n emb ar go v ar +1 r ep r es enta e l va lo r 15. pu nt + 1 r e p r ese nta l o m ism o qu e &v a r + 1 ( a van ce en la d ir ecc i n d e m em o ria d e va r ). Al tr aba ja r c on p unt e r o s se em pl ea n d os o pe r ado r es esp ec f icos : O pe r ado r d e d i r ecci n : qu e l e sig u e: & R e p r ese nta la di r ecc i n de m em o ri a de la va r iab le ESTRUCTURADE DATOS I -- FCI
&fn um r e p res en ta la di r ecc i n d e f num . O p er ad o r d e c o nte nid o o i nd ir ecc i n: * El o p er ad o r ap unt ada: * a pl ic ado al nomb r e d e u n pu nt er o i nd ica el va l or de la va r iab le
flo at alt ur a = 2 6.92, *ap unt a;
21

ap unt a = &a ltu r a; // in i cia li zac i n d el p unt e ro flo at alt ur a = 2 6.92, * ap unt a; ap unt a = &a ltu r a; // in i cia li zac i n d el p unt e ro .p ri ntf ( \n %f , a ltu r a) ; .p ri ntf ( \n %f , * a punt a ); //sa li da 2 6.92
No s e d eb e co nf und i r e l o p e rad o r * en l a d ecl ar aci n de l pu nt er o: int * p; Co n el o pe r ad or * en la s inst ru cci on es: * p = 27; p ri ntf ( \ n Co nte ni do = %d , *p ); Veam os c on u n e j em pl o en C la dif e r enc ia e ntr e to dos est os c onc e pt o s Veam os el a rch i vo - p unt0 .c pp - p unt1 .c pp Es d ec i r: int x = 25, *p int; pi nt = & x; La va ri abl e p int c onti e ne l a d ir ecc i n de m em or ia d e la v ar iab l e x. L a ex p r esi n: * pi nt r ep r es enta el va lo r de la v a riab l e ( x) a p unt ad a, es dec i r 25. La v a ri abl e p int tamb i n tie ne su p ro p ia di r ecci n: & pi nt Veam os c on ot r o ej em p lo e n C la di fe r enc ia e n tre tod os est os c onc e pt os vo id mai n ( vo id ) { int a, b, c , * p1, *p 2; vo id *p ; p1 = & a; *p1 = 1; p2 = & b; *p2 = 2; ESTRUCTURA DE DATOS I -- FCI p1 = p 2; *p1 = 0; p2 = & c; *p2 = 3; // P aso 1. La di r ecci n d e a es asig nad a a p 1 // P as o 2. p1 (a ) es i gu al a 1. E qu i va le a a = 1; / / Pas o 3. La d i re cci n de b es asig nad a a p2 // P aso 4. p 2 (b) es ig ua l a 2. E qu i va le a b = 2; // Pas o 5. El va l or de l p1 = p2 // P aso 6. b = 0 / / Pas o 7 . La d i rec ci n de c es a sign ada a p2 // Pas o 8 . c = 3 / / Pas o 9. Q u se im p rim e ?
p ri ntf (" %d % d %d \n ", a, b, c ); p = p1 ; p = p2 ;
/ / Pas o 1 0. p co nti e ne la di r ecci n de p1 // Pas o 11. p1= p2;
22

*p1 = 1; / / Pas o 12. c = 1
p ri ntf (" %d % d %d \n ", a, b, c ); }
// Pas o 13 . Qu s e i mp r im e?
Vamos a h ac er un se g uim ie nto de las di r ecc i on es d e m em o ria y de los v al or es d e las va r iab les e n cad a pas o. Su p on em os qu e l a va r iab le a es co lo cad a e n l a di r ecc i n 0000, b e n l a sig ui e n te, es d eci r 0 002, co n u n o ffs et d e 2 b yt e s, p o r se r v al o res int eg er . Se t rat a d e un sist em a de pos ici o nes re lat i va s de mem o ri a. S e v e r e n ar itm tic a d e pu nt er os. Se obti en e e l s igu i ent e cu ad ro. En l r ef l eja m os las di r ecci o nes re lat iv as d e me mo r ia y los c amb ios e n ca da un o d e l os pas os m a rcad o s:
Inic ia li zac i n d e pu nt er os( I) :
Si < Al mac en ami e nto> es aut o, ent on ces < E x p res io n> p u ed e s er cu al qu i er e x p res i n del < Ti p o> esp ec if icad o. Ej em p los: 1) La co nstant e ent e ra 0, NULL (c er o ) p r o po rc io n a un pu nte r o nu l o a cu al qu i er ti p o de d ato: int *p;
Si < Alm ac en ami ent o> es e xte r n o stat ic, <E x p res io n> deb e r s e r u na e x p res i n const ant e d el ti p o < Ti p o> ex p r esad o.
23

p = NUL L; // actu al iz aci n
2) El no mb re d e un a r ra y d e a lma ce nam i ent o stati c o ext e rn s e t r ansf o rma s eg n la ex p r esi n: a ) f l oat m at [12 ]; fl oat * p unt = mat; b) fl o at mat [12 ]; f lo at * p unt = & mat [0 ]; 3) U n cast pu nt er o a pu nt er o: int *p unt = ( int *) 123. 456; Inic ia li za e l pu nte r o c o n e l ent e ro . 4) U n punt e r o a ca rct e r pu ed e i nic ia li za rs e e n l a f or ma: cha r *c ad en a = Est o e s un a cad e na ; 5) S e p u ede n suma r o r esta r v al o res e nt er os a las dir ecc io n es de m e mo ria en l a fo rma : (a rit mt ica de p unt e r os) st atic int x; int * pu nt = & x+2, *p = & x-1; 6) E qu i va le nci a: D os ti pos de fi nid os c omo p u nte r os a o bj eto P y pu n ter o a obj et o Q so n e qu iv al e ntes s lo s i P y Q s on de l m ism o ti p o. A pl ica do a m atr ic es: nomb r e_ pu nte r o = nom br e_m atr i z;
24

PUNTEROS Y ARRAYS Se a el a rr a y d e una di mens i n: i nt mat [ ] = { 2, 16 , - 4, 29, 234, 1 2, 0, 3 };
en e l qu e c ada e le me nt o, po r s e r t ip o int, oc u p a dos b ytes de me mo ri a. Su p on em os qu e la di re cci n d e m em o ri a d el p rim e r el em ent o, es 1 50 0: & mat [0 ] es 1 500 & mat [1 ] s er 1502 & mat [7 ] s er 1514 int mat [ ] = {2 , 16, -4 , 29, 2 34, 12 , 0, 3} ; En tot al los 8 el em ent o s ocu p an 16 b yt es. P ode mos r e p res ent a r l as di r ecci o nes de mem or ia q u e oc u pa n l os el e ment os d e l a r ra y , los dat os qu e c ont ie n e y las p osic io n es d el a rr ay e n l a f o rma: Di rec ci n 1 500 1 502 1 504 1506 1 508 1510 151 2 1514
El em e nto mat [0 ] mat [1 ] mat [2 ] mat [3 ] mat [4 ] mat [5 ] mat [6 ] m at[ 7] El acc es o po dem os hac e rl o m edi ant e el n dic e: x = mat [3 ]+m a t[5 ]; // x = 2 9 + 1 2
pa ra sum ar l os el em ent os d e l a c ua rta y s e xta pos ic io nes . C om o h em os d ich o q ue p od em os acc ede r p or pos ici n y p or di r ec ci n: Es lo mism o &mat [0 ] y mat? Y &mat [1 ] = mat ++ ? Veam os el c dig o d e un ej em p lo: #inc lu de <stdi o.h > #inc lu de <co ni o.h > int m at[ 5] ={ 2, 16 , -4, 2 9, 234, 12, 0 , 3 }, i; // d ecl a rad as c omo gl oba l e s vo id mai n () { ESTRUCTURADE DATOS I -- FCI // res ult ad o: 15 00 ( di r ecci n d e m em ) / /r es ulta do: 1 500 ( " " " " " ) //i =1 // r esu ltad o: 1 502 ( " " " " " ) // r esu ltad o: 16 ( va lo r de mat [1 ] o val o r
p ri ntf (" \n% d", &mat [0 ] ); p ri ntf (" \n% p ", m at ); i ++; p ri ntf (" \n% p ", m at+ i); p ri ntf (" \n% d", * (ma t+i) ); g etch ( ); Ej em p lo }
25
Pa r ec e d edu ci rs e qu e a cced em os a l os e l em en tos d el a rr a y d e d os f o r mas: - m ed iant e e l sub nd ice. - m ed iant e s u d ir ecc i n d e m em or ia. El em e nto mat[ 0] mat [1 ] mat [2 ] m at[ 3] mat [4 ] mat [ 5] mat [6 ] m at[ 7]
Analizando las direcciones de memoria del array:
De lo ant e ri o r s e obt i en en v ar ias co ncl usi on es: - Es lo mism o &m at[ 0] q ue mat, & mat [2 ] q ue mat + 2 - Pa r a pasa r de un e l em ent o a l si gu ie nte , es lo mism o:
Qu e el c dig o:
A esta fo rm a d e d es pl a za rs e e n m em o ria se l e ll ama
26

Aritmtica de punteros
A un a va ri abl e pu nt er o se l e p ue de asi gna r la dir ec ci n d e cua l qu i er obj eto . A un a v ar iab l e pu nt er o se le pu ed e asi gna r l a dir ec ci n d e otr a v ar ia ble pu nte r o (si em p re qu e l as d os s e al en e l m ismo ob jet o ) A un p unt e ro s e le p u e de in ici al iz ar co n el v al or N ULL Un a v a riab l e p unt e ro pu ed e se r rest ada o com pa ra da c on ap unt an a el em ent os d e u n m ismo a r ra y. ot ra si amba s
Se p ue de s uma r o rest ar va l or es ent e ros : p + +, p v+3 , te ni en do e n c ue nta qu e el des pl az ami e nto ( offs et ) de p end e d e l ti p o d e d a to a pu nta do: p++; // p a pu nta a l a sigu ie nt e di r ecc i n
p v+=3 // p v a p unta 3* n b ytes de l d ato a pu nt ado ( of fset ) Si t e nem os: flo at *d ec ima l; / /su po nem os q ue a pu nta a 0 000 dec ima l++; //a p un ta a 0 004
Obs e rv a r l as si gui e ntes inst ru cci on es: i nt * p; d oub l e * q; v oid *r ; // p un ter o ge n r ic o ESTRUCTURADE DATOS I -- FCI
p = & 34; / / l a s const ant es no t i en en dir ec ci n p = & ( i+1 ); / / las ex p r esi on es no ti en en di r ecci n &i = p; // l as d ir ecc io n es n o s e pu ed e n camb ia r p = q; // il e gal // l ega l
p = ( int *) q;
27
Uti li za nd o la aritmtica de punteros nos despl az am os de u nas p osic io n es de mem or ia a ot r as. Pe r o. c m o ac ce de r a l os co nt en idos de es a s pos ic io nes util iz an do n otac i n d e pu nt er os?
Em p le amos el o pe ra do r * , indireccin que n os da e l co nt en ido d e la di r ecci n d e mem or ia a pu ntad a. Y... c m o s e a pl ica la a rit mt ica d e pu nte r os pa r a d es pl az ar nos e n un a r ra y bidim e nsi on al ?: f lo a t mat[ 2] [4 ]; //d ecl a rac i n d e l a r ra y
Uti li za nd o pu nte r os, la dec la rac i n s e r: fl o at ( *mat ) [4 ]; / /a r ra y b idim e nsi on al En d ond e mat es u n p unt e ro a u n g r up o co ntig u o d e a r r a ys mon od ime nsi o nal es ( ve cto r es) d e 4 el em en tos ca da un o.
E xist e, p or tant o un a e qu i va le nci a: Rec o rd emos que *mat r ep r es enta un puntero a la primera fila. A la se gund a fil a n os r ef e ri mos m e dia nte *(m at+1 )+j p a ra las dir ec ci on es y con *(* (m at+1 )+j ) p ar a los cont en id os. El segu nd o subndi ce actua sob re la co lu mna .
Si en x[ 10 ][ 20 ] q u ie r o acc ed e r al e le me nto d e l a fi la 3 y la c ol umn a 6, l o h ag o esc rib ie nd o x [2 ][ 5]. C o n n otac i n d e p unt e ros , es e qu i va le nte a * ( * ( x + 2 ) +5 )
28
ya qu e x + 2 es un pu nt er o a l a fi la 3. P or t ant o. E l co nt en ido de dich o pu nte r o, *( x+2 ), es la fi la 3. Si m e d esp la z o 5 p os ici on es e n es a fi la l l e go a l a p osi ci n *( x+2 )+5, cu y o c ont en i do es * (* ( x+2 )+5 ). V e r dibu jo:
Si en x[ 10 ][ 20 ] q u ie r o acc ed e r al e le me nto d e l a fi la 3 y la c ol umn a 6, l o h ag o esc rib ie nd o x [2 ] [5 ]. C on n otac i n de punt e r os, lo qu e hac em os es co nsid e ra r qu e es un a r ra y fo rm ad o p o r 10 ar ra ys u ni dim ens i o nal es (v ect o res ) d e 2 0 el em ent os cad a un o, d e m od o qu e acc e do a x [2 ] [5 ] m ed iant e l a e x p res i n: * ( * ( x + 2 ) + 5) ya qu e x + 2 es un pu nt er o a l a fi la 3. P or t ant o. E l co nt en ido de dich o pu nte r o, *( x+2 ), es la fi la 3. Si m e d esp la z o 5 p os ici on es e n es a fi la l l e go a l a p osi ci n *( x+2 )+5, cu y o c ont en i do es * (* (x +2 )+5 ). L as sigu ie nt es e x p res io n es con p unt e ros s o n v lid as: **x *(* x+1 ) Si e n int a rr a y[ fi las ] [c ol umn as] ; Qu i er o acc ed e r a l el e ment o a r ra y [ y ][ z ] p a ra asign a rl e un va l or , lo qu e e l com p il ad or hac e es : *(*array +columnas x y + z)) = 129; / /asig nac i n Si f ue r a int a r ra y [2 ] [5 ] y q uisi e ra as ig na r 12 9 al e le me nto d e l a fi l a 1 y co lu mna 2 , po nd r a: * (a r ra y + 5x1 + 1 )) = 129 ; es d eci r, des de e l or ig e n d el ar r a y a va n za 6 po sici on es d e m em o ri a: x [0 ] [0 ] ; x [0 ] [1 ]; *( *( x+1 ) ) ** (x +1 ) x [1 ] [0 ] x [1] [0 ]
29

PUNTEROS A ARRAYS MATRICES
Un a r ra y m ult idim e nsi on al es, en r e ali dad, una co l ecci n d e vect or es. S eg n est o, po de mos d ef in ir un ar ra y b idi me nsi on al c o mo u n p unt e r o a u n g ru p o co nti gu o d e ar ra ys un id ime nsi o nal e s. Las d ec la rac io n es si gui ent es s on e q ui va l en tes: int dat [fi l ] [co l ] En g en e ra l: tip o_d ato no mb re [d im1 ] [dim 2] . . . . . [di mp ]; e q ui va le a: tip o_d ato (* no mb re ) [di m2] [d im3 ]. . . . . [d im p ]; i nt (*d at) [c ol ]
El a r ra y:
i nt va l or [ x ][ y ] [z ];
Pu ed e s e r re p r ese nta d o en la fo rm a: i nt (* va lo r ) [y ] [ z] ;
O c om o u n AR R A Y D E P UN T ER O S: int * v al or [ x ][ y ];
s in p a r nt esis En su nu e va dec la r aci n d esa pa r ec e l a ltim a de s us di me nsi on es. Veam os m s d ecl a rac io nes de a rr a ys d e p unt e ros :
int x [10 ] [20 ]; flo at p [10 ] [20 ] [30 ];
int * x[ 10 ]; int * p[ 10 ][ 20 ];
30

Punteros a CADENAS DE CARACTERES
Un a c ad ena d e c ar act e r es es u n ar r ay d e c ar a cte res . La f or ma de d e fin i r u n pu nt er o a una cad e na d e c a ract e r es: c ha r *ca de na; El id ent if icad o r d el ar ra y es l a di r ecc i n d e comi e nz o d el a rr a y. Pa r a sab e r d nd e ter mi na la c ad en a, el c om pi lad o r a ad e el ca r cte r \0 ( A SCI I 0, N UL L): cha r * nomb r e = P E P E P ER E Z ;
ARRAYS DE PUNTEROS A CADENAS DE CARACTERES

En un a r ra y d e pu nte r o s a cade nas d e ca r acte r es cad a el em e nto a p u nta a u n ca rct e r. La d ecl a rac i n s er : cha r *c ad [10 ]; // po r e jem p lo Gr fic am ent e p od ra se r:
si l as di me nsi on es no son c o noc idas , sab r em os d nd e c om ie n zan l a s cad en as, p er o no d nde t e rm ina n. Pa ra el l o se ef ect a la l la mad a reserva dinmica de memoria (funci o nes ma ll oc, c al loc ( ), r ea ll oc ( ) y fr e e () de stdl ib.h al l oc.h ): cha r c ad[ 10 ][ 80 ]; E qu i va le a ch ar **ca d r es er v and o 8 00 b yt es
31

La d ecl a rac i n: c ha r ca d[10 ] [80 ];
Res e rv a me mo ri a p ar a 10 cade nas de c ar ac ter es d e80 ca ra cte r es cada un a. P er o en l a d ecl ar ac i n com o a r ra y d e p unt e ros : c ha r * cad [10 ]; El co mp il ad or d esco n oc e el t ama o de l as cad en as: cu nta me mo ri a r ese r va ? si e l a r ra y es stat ic y s e i nic ia li za n l as c ade nas e n e l p ro pi o cdi go , e l com pi lad o r c alc ul a l a d ime nsi n n o ex p lic itad a (a r ra ys s in dim e nsi n ex p lc ita ).
OTRAS CLASES DE PUNTEROS:

P unt e ros ge n r ic os: S on t i po v oi d: v oid *g en e ric o; Los p unt e r os ti po v oid pu ed en a pu nta r a ot r o tip o d e dat os. Es un a op e rac i n del ica da q u e d e pe nd e d el ti p o d e c om pi la do r. Es c o nv e ni ent e em pl ea r e l cast in g pa ra l a c on v e rsi n. A n as , n o tod a s las c on v e rsi on es estn p er miti das. P unt e ro nu lo: En C u n pu nte r o qu e a pu nte a un o bj et o v li do n un ca tend r un va lo r ce r o. E l va lo r c e r o s e ut il iz a pa ra i ndic a r qu e ha oc ur r id o a lg n e r r or (e s dec ir , qu e a lg un a o p e ra ci n n o s e h a po did o r e ali za r ) int * p = N UL L; // int * p =0;
Pu nte r os c onst ant es : U na d ec la ra ci n de p u nte r o pr ec ed ida de co n st hac e qu e e l ob j eto a pu ntad o sea un a c onst ant e (a u nq u e n o el p unt e ro ): co nst ch a r * p = V al lad ol id ; p [0 ] = f // e r ro r. La c ad ena a pu nta da po r + es cte . p = Puc el a //Ok . p a p unta a ot ra cade na . Si l o qu e qu e r emos es dec la ra r un p unt e ro co nstant e; cha r *co nst p = M edi na ; ESTRUCTURA DE DATOS I -- FCI p [0 ] = s; // e rr o r: el ob jet o Me di n a, es cte. p = P e af ie l ; //e r ro r: e l pu nte r o p e s const ant e. Punt e r os a p unt e ros: Ve r ej em p4.c p p, ej e mp11 .c pp y ej em p12.c p p
int ** pu nte r o; // pu nt er o a punt e r o a un obj eto i nt. El ti p o de ob jet o a pu ntad o des pu s d e un a dobl e in d i re cci n pu e de se r de cua lq ui e r c las e.
32
P er mit e ma ne ja r a r ra ys d e m lti p les d im e nsi on es c on n otac io ne s d el t i p o ***mat, d e mlt i pl e ind i re cci n q ue pu ed en g en e ra r p r obl e mas si el trat ami ent o no es el adec ua do. O j o a los p unt er os lo cos . Punt e r os a dat os c o mp le jos: S e pu ed en d ecl a ra pu nte r os a d at os de fi nid os po r e l us ua ri o (t y pe de f( ) ), a dat os st ruct, a fun ci on es, c om o a rg u ment os d e func i on es... Dec la rac io n es c om pl ej as: U na d ec la rac i n c om pl ej a es un id ent ifi cad o r con ms d e d e u n op e r ado r. P ar a int er p r eta r estas d ecl a rac io nes hac e f a lta sab e r qu e los c o r chet es y pa r nt esis (o p e rad o r es a la de r ech a de l ide n tific ad or ti en e n p ri or i dad sob re los aste ris cos (o p e ra do res a l a iz q ui e rda d el id e ntif ica do r. L os p ar nt es is y co rch etes ti en e n l a m i sma p ri or id ad y s e e va la n d e i z qui e rd a a d e r echa . A la iz q ui er da de l t od o el t ip o d e dat o. Em pl e and o p ar ntes is s e pu ed e cambi ar el or de n d e p ri o ri dad es. Las e x pr esi o nes ent r e pa r nt esis s e e v al an p rim e ro , de ms i nte r nas a ms e xt e rnas . Pa r a i nte r p r eta r d ecl a r aci on es c om pl ej as p od em os se gu ir e l or de n: 1) Em p ez ar c on e l i dent if icad o r y ve r si haci a la d er ec ha ha y co rch etes o pa r nt esis . 2) I nte r p r eta r es os c or ch etes o p ar ntes is y v e r si ha cia la i z q ui er da h ay aste risc os. 3 ) D ent ro de cad a ni v el d e pa r nt esis , d e ms int e rn os a m s ext e rn os, ap lic a r pu ntos 1 y 2. Veam os un ej em p lo: cha r *(* (* va r ) ( ) )[ 10 ]
La i nte r p r etac i n es: 1. La v ar iab l e va r es d e cla rad a c om o 2. u n punt e r o a 3. u na f un ci n q ue d ev ue l ve ESTRUCTURADE DATOS I -- FCI 4. u n punt e r o a 5. u n a r ra y d e 1 0 el em ent os, los cua l es so n 6. p unt e ros a 7. ob jet os d e t i po cha r.
33
Punteros a estructuras Cmo no, tambin se pueden usar punteros con estructuras. Vamos a ver como funciona esto de los punteros con estructuras. Primero de todo hay que definir la estructura de igual forma que hacamos antes. La diferencia est en que al declara la variable de tipo estructura debemos ponerle el operador '*' para indicarle que es un puntero. Creo que es importante recordar que un puntero no debe apuntar a un lugar cualquiera, debemos darle una direccin vlida donde apuntar. No podemos por ejemplo crear un puntero a estructura y meter los datos directamente mediante ese puntero, no sabemos dnde apunta el puntero y los datos se almacenaran en un lugar cualquiera. Y para comprender cmo funcionan, nada mejor que un ejemplo. Este programa utiliza un puntero para acceder a la informacin de la estructura: #include <stdio.h> struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo = { "Juanjo", "Lopez", "592-0483", 30 }; struct estructura_amigo *p_amigo; int main() { p_amigo = &amigo; printf( "%s tiene ", p_amigo->apellido ); printf( "%i aos ", p_amigo->edad ); printf( "y su telfono es el %s.\n" , p_amigo->telefono ); }
Has la definicin del puntero p_amigo vemos que todo era igual que antes. p_amigo es un puntero a la estructura estructura_amigo. Dado que es un puntero tenemos que indicarle dnde debe apuntar, en este caso vamos a hacer que apunte a la variable amigo: p_amigo = &amigo; No debemos olvidar el operador & que significa 'dame la direccin donde est almacenado...'. Ahora queremos acceder a cada campo de la estructura. Antes lo hacamos usando el operador '.', pero, como muestra el ejemplo, si se trabaja con punteros se debe usar el operador '->'. Este operador viene a significar algo as como: "dame acceso al miembro ... del puntero ...". Ya slo nos queda saber cmo podemos utilizar los punteros para introducir datos en las estructuras. Lo vamos a ver un ejemplo: #include <stdio.h> struct estructura_amigo { char nombre[30];
34
char apellido[40]; int edad; }; struct estructura_amigo amigo, *p_amigo; void main() { p_amigo = &amigo; /* Introducimos los datos mediante punteros */ printf("Nombre: ");fflush(stdout); gets(p_amigo->nombre); printf("Apellido: ");fflush(stdout); gets(p_amigo->apellido); printf("Edad: ");fflush(stdout); scanf( "%i", &p_amigo->edad ); /* Mostramos los datos */ printf( "El amigo %s ", p_amigo->nombre ); printf( "%s tiene ", p_amigo->apellido ); printf( "%i aos.\n", p_amigo->edad ); } NOTA: p_amigo es un puntero que apunta a la estructura amigo. Sin embargo p_amigo->edad es una variable de tipo int. Por eso al usar el scanf tenemos que poner el &.
ESTRUCTURADE DATOS I -- FCI Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
35
Punteros a Arrays de estructuras Por supuesto tambin podemos usar punteros con arrays de estructuras. La forma de trabajar es la misma, lo nico que tenemos que hacer es asegurarnos que el puntero inicialmente apunte al primer elemento, luego saltar al siguiente hasta llegar al ltimo. #include <stdio.h> #define ELEMENTOS 3 struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo[] = { "Juanjo", "Lopez", "504-4342", 30, "Marcos", "Gamindez", "405-4823", 42, "Ana", "Martinez", "533-5694", 20 }; struct estructura_amigo *p_amigo; void main() { int num_amigo; p_amigo = amigo; /* apuntamos al primer elemento del array */ /* Ahora imprimimos sus datos */ for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf( "El amigo %s ", p_amigo->nombre ); printf( "%s tiene ", p_amigo->apellido ); printf( "%i aos ", p_amigo->edad ); printf( "y su telfono es el %s.\n" , p_amigo->telefono ); /* y ahora saltamos al siguiente elemento */ p_amigo++; } }
En vez de p_amigo = amigo; se poda usar la forma p_amigo = &amigo[0];, es decir que apunte al primer elemento (el elemento 0) del array. La primera forma creo que es ms usada pero la segunda quizs indica ms claramente al lector principiante lo que se pretende. Ahora veamos el ejemplo anterior de cmo introducir datos en un array de estructuras mediante punteros: ESTRUCTURA DE DATOS I -- FCI #include <stdio.h> #define ELEMENTOS 3 struct estructura_amigo { char nombre[30]; char apellido[40]; int edad; }; struct estructura_amigo amigo[ELEMENTOS], *p_amigo; void main()
36

{ int num_amigo; /* apuntamos al primer elemento */ p_amigo = amigo;
/* Introducimos los datos mediante punteros */ for ( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf("Datos amigo %i\n",num_amigo); printf("Nombre: ");fflush(stdout); gets(p_amigo->nombre); printf("Apellido: ");fflush(stdout); gets(p_amigo->apellido); printf("Edad: ");fflush(stdout); scanf( "%i", &p_amigo->edad ); /* vaciamos el buffer de entrada */ while(getchar()!='\n'); /* saltamos al siguiente elemento */ p_amigo++; } /* Ahora imprimimos sus datos */ p_amigo = amigo; for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf( "El amigo %s ", p_amigo->nombre ); printf( "%s tiene ", p_amigo->apellido ); printf( "%i aos.\n", p_amigo->edad ); p_amigo++; } }
Es importante no olvidar que al terminar el primer bucle for el puntero p_amigo apunta al ltimo elemento del array de estructuras. Para mostrar los datos tenemos que hacer que vuelva a apuntar al primer elemento y por eso usamos de nuevo p_amigo=amigo; (en negrita).
37
Introduccin:
Una de las aplicaciones ms interesantes y potentes de la memoria dinmica y los punteros son las estructuras dinmicas de datos. Las estructuras bsicas disponibles en C y C++ tienen una importante limitacin: no pueden cambiar de tamao durante la ejecucin. Los arreglos estn compuestos por un determinado nmero de elementos, nmero que se decide en la fase de diseo, antes de que el programa ejecutable sea creado. En muchas ocasiones se necesitan estructuras que puedan cambiar de tamao durante la ejecucin del programa. Por supuesto, podemos hacer 'arrays' dinmicos, pero una vez creados, tu tamao tambin ser fijo, y para hacer que crezcan o diminuyan de tamao, deberemos reconstruirlas desde el principio. Las estructuras dinmicas nos permiten crear estructuras de datos que se adapten a las necesidades reales a las que suelen enfrentarse nuestros programas. Pero no slo eso, como veremos, tambin nos permitir crear estructuras de datos muy flexibles, ya sea en cuanto al orden, la estructura interna o las relaciones entre los elementos que las componen. Las estructuras de datos estn compuestas de otras pequeas estructuras a las que llamaremos nodos o elementos, que agrupan los datos con los que trabajar nuestro programa y adems uno o ms punteros autoreferenciales, es decir, punteros a objetos del mismo tipo nodo. Una estructura bsica de un nodo para crear listas de datos seria: struct nodo { int dato; struct nodo *otronodo; }; El campo "otronodo" puede apuntar a un objeto del tipo nodo. De este modo, cada nodo puede usarse como un ladrillo para construir listas de datos, y cada uno mantendr ciertas relaciones con otros nodos. Para acceder a un nodo de la estructura slo necesitaremos un puntero a un nodo. Durante el presente curso usaremos grficos para mostrar la estructura de las estructuras de datos dinmicas. El nodo anterior se representar asi:
Las estructuras dinmicas son una implementacin de TDAs o TADs (Tipos Abstractos de Datos). En estos tipos el inters se centra ms en la estructura de los datos que en el tipo concreto de informacin que almacenan. Dependiendo del nmero de punteros y de las relaciones entre nodos, podemos distinguir varios tipos de estructuras dinmicas. Enumeraremos ahora slo de los tipos bsicos: Listas abiertas: cada elemento slo dispone de un puntero, que apuntar al siguiente elemento de la lista o valdr NULL si es el ltimo elemento.
38
Pilas: son un tipo especial de lista, conocidas como listas LIFO (Last In, First Out: el ltimo en entrar es el primero en salir). Los elementos se "amontonan" o apilan, de modo que slo el elemento que est encima de la pila puede ser ledo, y slo pueden aadirse elementos encima de la pila. Colas: otro tipo de listas, conocidas como listas FIFO (First In, First Out: El primero en entrar es el primero en salir). Los elementos se almacenan en fila, pero slo pueden aadirse por un extremo y leerse por el otro. Listas circulares: o listas cerradas, son parecidas a las listas abiertas, pero el ltimo elemento apunta al primero. De hecho, en las listas circulares no puede hablarse de "primero" ni de "ltimo". Cualquier nodo puede ser el nodo de entrada y salida. Listas doblemente enlazadas: cada elemento dispone de dos punteros, uno a punta al siguiente elemento y el otro al elemento anterior. Al contrario que las listas abiertas anteriores, estas listas pueden recorrerse en los dos sentidos. Arboles: 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. Arboles binarios: son rboles donde cada nodo slo puede apuntar a dos nodos. Arboles 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. Arboles AVL: son tambin rboles de bsqueda, pero su estructura est ms optimizada para reducir los tiempos de bsqueda. Arboles 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.
Al final del curso tambin veremos estructuras dinmicas en las que existen nodos de distintos tipos, en realidad no es obligatorio que las estructuras dinmicas estn compuestas por un nico tipo de nodo, la flexibilidad y los tipos de estructuras slo estn limitados por tu imaginacin como programador.
39
Listas Fundamentos
Las listas son secuencias de elementos, donde estos elementos pueden ser accedidos, insertados o suprimidos en cualquier posicin de la lista. No existe restriccin alguna acerca de la localizacin de esas operaciones. Se trata de estructuras muy flexibles puesto que pueden crecer o acotarse como se quiera. Matemticamente, una lista es una secuencia de cero o ms elementos de un tipo determinado (que por lo general denominaremos T). A menudo se representa una lista como una sucesin de elementos separados por comas: a(1), a(2), a(3), ... , a(n) donde a "n" (n >= 0) se le llama longitud de la lista. Al suponer n>=1, se dice que a (1) es el primer elemento de la lista y a(n) el ltimo elemento. Si n=0, se tiene una lista vaca. Una propiedad importante de una lista es que sus elementos pueden estar ordenados en forma lineal de acuerdo con sus posiciones en la lista. Se dice que a(i) precede a a(i+1), para i=1,2, .., n-1, y que a(i) sucede a a(i-1), para i=2, 3, .., n. Tambin se dice que el elemento a(i) est en la posicin i de la lista. Por lo que se ve, las estructuras pila y cola, estudiadas en el captulo anterior, no son ms que casos particulares de la estructura lista generalizada. Al igual que en los casos anteriores, se puede pensar en representar una lista mediante un array unidimensional, lo que permite un acceso eficiente a cada uno de los componentes de la estructura, lo que, en principio, parece proporcionar un esquema adecuado para representar las operaciones que normalmente se desean realizar sobre la lista: acceder a un elemento (nodo) arbitrario de la lista, insertar y borrar nodos, etc. Sin embargo, si bien todas estas consideraciones eran ciertas para las pilas y las colas, cuando se trata de otro tipo de listas, las operaciones a realizar sobre el array resultan bastante ms costosas. Por ejemplo, supongamos la siguiente lista: (Antonio, Bartolom, Carlos, David, Emilio, Germn, Jaime, Jos, Luis, Manuel) Si se desea aadir el valor 'Fernando' a esta lista ordenada de nombres, la operacin se debe realizar en la sexta posicin de la lista, entre los valores 'Emilio' y 'Germn'. Cuando la lista est representada con un array, dicha insercin implicar tener que desplazar una posicin hacia la derecha todos los elementos situados ya en la lista a partir de la posicin seis (Germn,...Manuel), para de esta forma dejar una posicin libre en el array y poder insertar all el nuevo valor. Por otro lado, si suponemos que lo que se desea es borrar de la lista el elemento 'Carlos', de nuevo es necesario desplazar elementos para mantener la estructura secuencial de la lista. En este caso es preciso mover una posicin hacia la izquierda todos los elementos situados a partir de la cuarta posicin. Cuando el problema es manipular diferentes listas de tamao variable, la representacin secuencial prueba ser, de nuevo, poco apropiada. Si se decide almacenar en distintos arrays cada una de las listas, se tendrn grandes necesidades de almacenamiento. Si, por el contrario, se toma la decisin de usar un nico array, se necesitar una cantidad mucho mayor de desplazamientos de informacin. Una solucin elegante al problema del desplazamiento de informacin en el almacenamiento secuencial se logra mediante la utilizacin de representaciones enlazadas (o ligadas). A diferencia de la representacin secuencial, en la representacin enlazada los elementos se pueden situar en cualquier posicin de memoria, y no necesariamente igualmente distantes dentro de ella. Tambin se puede decir que, si bien en la representacin con arrays el orden de los elementos es el mismo que el orden en la lista, en una representacin enlazada la secuencia de orden de la lista no tiene porque coincidir con la secuencia de almacenamiento en memoria.
40
Universidad Tecnica de Manab Listas abiertas o Simples
La forma ms simple de estructura dinmica es la lista abierta. En esta forma los nodos se organizan de modo que cada uno apunta al siguiente, y el ltimo no apunta a nada, es decir, el puntero del nodo siguiente vale NULL. En las listas abiertas existe un nodo especial: el primero. Normalmente diremos que nuestra lista es un puntero a ese primer nodo y llamaremos a ese nodo la cabeza de la lista. Eso es porque mediante ese nico puntero podemos acceder a toda la lista. Cuando el puntero que usamos para acceder a la lista vale NULL, diremos que la lista est vaca. El nodo tpico para construir listas tiene esta forma: struct nodo { int dato; struct nodo *siguiente; }; En el ejemplo, cada elemento de la lista slo contiene un dato de tipo entero, pero en la prctica no hay lmite en cuanto a la complejidad de los datos a almacenar. Una lista lineal simplemente enlazada es una estructura en la que el cada elemento enlaza con el siguiente. El recorrido se inicia a partir de un puntero ubicado al comienzo de la lista. El ltimo elemento (nodo) de la lista apunta a una direccin vaca que indica el fin de la estructura.
Donde p=^Nodolista (apunta al sgte. nodo de la lista)
Declaraciones de tipos para manejar listas en C:

Normalmente se definen varios tipos que facilitan el manejo de las listas, en C, la declaracin de tipos puede tener una forma parecida a esta: typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; ESTRUCTURADE DATOS I -- FCI typedef tipoNodo *pNodo; typedef tipoNodo *Lista; tipoNodo es el tipo para declarar nodos, evidentemente. pNodo es el tipo para declarar punteros a un nodo. Lista es el tipo para declarar listas, como puede verse, un puntero a un nodo y una lista son la misma cosa. En realidad, cualquier puntero a un nodo es una lista, cuyo primer elemento es el nodo apuntado.
41
Es muy importante que nuestro programa nunca pierda el valor del puntero al primer elemento, ya que si no existe ninguna copia de ese valor, y se pierde, ser imposible acceder al nodo y no podremos liberar el espacio de memoria que ocupa.
Localizar elementos en una lista abierta:

Muy a menudo necesitaremos recorrer una lista, ya sea buscando un valor particular o un nodo concreto. Las listas abiertas slo pueden recorrerse en un sentido, ya que cada nodo apunta al siguiente, pero no se puede obtener, por ejemplo, un puntero al nodo anterior desde un nodo cualquiera si no se empieza desde el principio. Para recorrer una lista procederemos siempre del mismo modo, usaremos un puntero auxiliar como ndice: 1. Asignamos al puntero ndice el valor de Lista. 2. Abriremos un bucle que al menos debe tener una condicin, que el ndice no sea NULL. 3. Dentro del bucle asignaremos al ndice el valor del nodo siguiente al ndice actual. Por ejemplo, para mostrar todos los valores de los nodos de una lista, podemos usar el siguente bucle en C: typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Lista; ... pNodo indice; ... indice = Lista; while(indice) { printf("%d\n", indice->dato); indice = indice->siguiente; } ... Supongamos que slo queremos mostrar los valores hasta que encontremos uno que sea mayor que 100, podemos sustituir el bucle por: ... indice = Lista; while(indice && indice->dato <= 100) { printf("%d\n", indice->dato); indice = indice->siguiente; } ... Si analizamos la condicin del bucle, tal vez encontremos un posible error: Qu pasara si ningn valor es mayor que 100, y alcancemos el final de la lista?. Podra pensarse que cuando indice sea NULL, si intentamos acceder a indice->dato se producir un error.
42
En general eso ser cierto, no puede accederse a punteros nulos. Pero en este caso, ese acceso est dentro de una condicin y forma parte de una expresin "and". Recordemos que cuando se evala una expresin "and", se comienza por la izquierda, y la evaluacin se abandona cuando una de las expresiones resulta falsa, de modo que la expresin "indice->dato <= 100" nunca se evaluar si indice es NULL. Si hubiramos escrito la condicin al revs, el programa nunca funcionara bien. Esto es algo muy importante cuando se trabaja con punteros.
Operaciones bsicas con listas:

Con las listas tendremos un pequeo repertorio de operaciones bsicas que se pueden realizar: Aadir o insertar elementos. Buscar o localizar elementos. Borrar elementos. Moverse a travs de una lista, anterior, siguiente, primero.
Cada una de estas operaciones tendr varios casos especiales, por ejemplo, no ser lo mismo insertar un nodo en una lista vaca, o al principio de una lista no vaca, o la final, o en una posicin intermedia.
Insertar elementos en una lista abierta:

Veremos primero los casos sencillos y finalmente construiremos un algoritmo genrico para la insercin de elementos en una lista.
Insertar un elemento en una lista vaca:

Este es, evidentemente, el caso ms sencillo. Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a l, adems el puntero a la lista valdr NULL: El proceso es muy simple, bastar con que: 1. nodo->siguiente apunte a NULL. 2. Lista apunte a nodo.
Insertar un elemento en la primera posicin de una lista:

Podemos considerar el caso anterior como un caso particular de ste, la nica diferencia es que en el caso anterior la lista es una lista vaca, pero siempre podemos, y debemos considerar una lista vaca como una lista. De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de una lista, en este caso no vaca: ESTRUCTURADE DATOS I -- FCI
El proceso sigue siendo muy sencillo: 1. Hacemos que nodo->siguiente apunte a Lista. 2. Hacemos que Lista apunte a nodo.
43
Insertar un elemento en la ltima posicin de una lista:

Este es otro caso especial. Para este caso partiremos de una lista no vaca:
El proceso en este caso tampoco es excesivamente complicado: 1. Necesitamos 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 NULL. 2. Hacer que nodo->siguiente sea NULL. 3. Hacer que ultimo->siguiente sea nodo.
Insertar un elemento a continuacin de un nodo cualquiera de una lista:

De nuevo podemos considerar el caso anterior como un caso particular de este. Ahora el nodo "anterior" ser aquel a continuacin del cual insertaremos el nuevo nodo:
Suponemos que ya disponemos del nuevo nodo a insertar, apuntado por nodo, y un puntero al nodo a continuacin del que lo insertaremos. El proceso a seguir ser: 1. Hacer que nodo->siguiente seale a anterior->siguiente. 2. Hacer que anterior->siguiente seale a nodo.
44

Funciones Prototipos
int ListaVacia(Lista l); void Insertar(Lista *l,int v); void InsertarC(Lista *l,int v); void InsertarF(Lista *l,int v); void Borrar(Lista *l,int v); void BorrarLista(Lista *l); void MostrarLista(Lista l);
Implementacion de las funciones Prototipos.-
Verificar si una lista abierta esta vacia

int ListaVacia(Lista lista) {return(lista==NULL); }
Insertar un elemento de forma ordenada en una lista abierta

void Insertar(Lista *lista, int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->dato=v; if(ListaVacia(*lista)||(*lista)->dator>v){ nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente && anterior->dator <=v) anterior=anterior->siguiente; nuevo->siguiente=anterior->siguiente; anterior->siguiente=nuevo; } }
Insertar un elemento al inicio de una lista abierta

void InsertarC(Lista *lista, int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->dato=v; nuevo->siguiente=*lista; *lista=nuevo; }
Insertar un elemento al final de una lista abierta

void InsertarF(Lista *lista, int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->dato=v; if(ListaVacia(*lista)){ nuevo->siguiente=*lista; *lista=nuevo; } else Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
45

{anterior=*lista; while(anterior->siguiente!=NULL) anterior=anterior->siguiente; anterior->siguiente=nuevo; nuevo->siguiente=NULL; } }
Borrar un elemento especfico de una lista abierta

void Borrar (Lista *lista, int v) {pNodo nodo, anterior; nodo*lista; anterior=NULL; while (nodo && nodo->dato < v) { anterior =nodo; nodo= nodo->siguiente; } If (!nodo || nodo->dato !=v) return; else { /* borra el nodo*/ If(!anterior) /* primer elemento*/ *lista=nodo->siguiente; else /* un elemeto cualquiera*/ anterior->siguiente=nodo->siguiente; free(nodo); } }
Borrar un una lista abierta

void Borrar_Lista(Lista *lista) { pNodo nodo; While(*lista) { nodo=*lista; *lista=nodo->siguiente; free(nodo); } }
Mostrar la informacin de una lista abierta

void MostrarLista(Lista lista) {pNodo nodo=lista; if(ListaVacia(lista)) printf("Lista vacia \n"); else{ while(nodo) { printf("%d-> ",nodo->dato); nodo=nodo->siguiente; } } }
46

PILAS Y COLAS
Las pilas y las colas son dos de las estructuras de datos ms utilizadas. Se trata de dos casos particulares de las estructuras lineales generales (secuencias o listas) que, debido a su amplio mbito de aplicacin, conviene ser estudiadas de manera independiente.
PILAS. FUNDAMENTOS
La pila es una lista de elementos caracterizada porque las operaciones de insercin y eliminacin se realizan solamente en un extremo de la estructura. El extremo donde se realizan estas operaciones se denomina habitualmente 'cima' (top en nomenclatura inglesa). Dada una pila P=(a,b,c,...k), se dice que a, que es el elemento ms inaccesible de la pila, est en el fondo de la pila (bottom) y que k, por el contrario, el ms accesible, est en la cima. Las restricciones definidas para la pila implican que si una serie de elementos A,B,C,D,E se aaden, en este orden a una pila, entonces el primer elemento que se borre de la estructura deber ser el E. Por tanto, resulta que el ltimo elemento que se inserta en una pila es el primero que se borra. Por esta razn, se dice que una pila es una lista LIFO (Last In First Out, es decir, el ltimo que entra es el primero que sale). Un ejemplo tpico de pila lo constituye un montn de platos, cuando se quiere introducir un nuevo plato, ste se pone en la posicin ms accesible, encima del ltimo plato. Cuando se coge un nuevo plato, ste se extrae, igualmente, del punto ms accesible, el ltimo que se ha introducido. Otro ejemplo natural de la aplicacin de la estructura pila aparece durante la ejecucin de un programa de ordenador, en la forma en que la mquina procesa las llamadas a los procedimientos. Cada llamada a un procedimiento (o funcin) hace que el sistema almacene toda la informacin asociada con ese procedimiento (parmetros, variables, constantes, direccin de retorno, etc..) de forma independiente a otros procedimientos y permitiendo que unos procedimientos puedan invocar a otros distintos (o a si mismos) y que toda esa informacin almacenada pueda ser recuperada convenientemente cuando corresponda. Como en un procesador slo se puede estar ejecutando un procedimiento, esto quiere decir que slo es necesario que sean accesibles los datos de un procedimiento (el ltimo activado que est en la cima). De ah que la estructura pila sea muy apropiada para este fin. Como en cualquier estructura de datos, asociadas con la estructura pila existen una serie de operaciones necesarias para su manipulacin, stas son: Crear la pila. Comprobar si la pila est vacia. Es necesaria para saber si es posible eliminar elementos. Acceder al elemento situado en la cima. Aadir elementos a la cima. Eliminar elementos de la cima.
Representacion de las pilas

Los lenguajes de programacin de alto nivel no suelen disponer de un tipo de datos pila. Aunque por el contrario, en lenguajes de bajo nivel (ensamblador) es posible manipular directamente alguna estructura pila propia del sistema. Por lo tanto, en general, es necesario representar la estructura pila a partir de otros tipos de datos existentes en el lenguaje.
La especificacin correcta de todas estas operaciones permitir definir adecuadamente una pila.
47
La forma ms simple, y habitual, de representar una pila es mediante un vector unidimensional. Este tipo de datos permite definir una secuencia de elementos (de cualquier tipo) y posee un eficiente mecanismo de acceso a la informacin contenida en l. El hecho de utilizar un vector para almacenar los elementos, puede conducir a la situacin en que la pila est llena, es decir, que no quepa ningn elemento ms. Esto se producir cuando el ndice que seala la cima de la pila sea igual al tamao del vector. Al definir un array hay que determinar el nmero de ndices vlidos y, por lo tanto, el nmero de componentes definidos. Entonces, la estructura pila representada por un array tendr limitado el nmero de posibles elementos. Se puede definir una pila como una variable, sin usar array: typedef struct nodo { int dato; struct nodo * sig; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo * Pila; Como todas las operaciones se realizan sobre la cima de la pila, es necesario tener correctamente localizada en todo instante esta posicin. Es necesaria una variable, cima, que apunte al ltimo elemento (ocupado) de la pila. Con estas consideraciones prcticas, se puede pasar a definir las operaciones que definen la pila.
Crear pila:
Es necesario definir la variable que permitir almacenar la informacin, indicando que la creacin implica que la pila est vaca, por lo que deber ser igual a NULL.
Comprobar si la pila est vaca:

Esta operacin permitir determinar si es posible eliminar elementos.
boolean Pila_vacia (Pila p) { boolean r=false; If ( (*pila)==Null) r=true; return r; }
Operacin de insercin
La operacin de insercin normalmente se conoce por su nombre ingls push. La operacin aplicada sobre una pila y un valor x, inserta x en la cima de la pila. Esta operacin est restringida por el tipo de representacin escogido. En el caso, la utilizacin de un array implica que se tiene un nmero mximo de posibles elementos en la pila, por lo tanto, es necesario comprobar, previamente a la insercin, que realmente hay espacio en la estructura para almacenar un nuevo elemento. Con esta consideracin el algoritmo de insercin sera:
48

Algoritmo Apilar
void InsertarPila(Pila *pila, int v) { pNodo nuevo; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->dato=v; nuevo->sig=*pila; *pila=nuevo; }
Operacin de eliminacin
La operacin de borrado elimina de la estructura el elemento situado en la cima. Normalmente recibe el nombre de pop en la bibliografa inglesa. El algoritmo de borrado sera:
Algoritmo Desapilar
int Pop(Pila *pila) { pNodo nodo=*pila; int v=0; if(!nodo) cout<< "Pila Vacias...\n"; else { *pila=nodo->sig; v=nodo->dato; free(nodo); } return v; }
(Recordemos que la funcin Pila_vacia nos devuelve un valor lgico (cierto o falso) que en este caso nos sirve como condicin para el si) En todos los algoritmos se podra suponer que las variables Pila y cima, lo mismo que n, son globales y, por lo tanto, no sera necesario declararlas como entradas o salidas.
Pilas Notacin Prefija, Infija y Postfija

Expresin aritmtica: Formada por operandos y operadores: A*B / (A+C) Operandos: variables que toman valores enteros o reales Operadores:
En caso de igualdad de prioridad Son evaluados de izquierda a derecha (se evala primero el que primero aparece) 5*4/2 = (5*4)/2 = 10
49
Cuando aparecen varios operadores de potenciacin juntos la expresin se evala de derecha a izquierda 2^3^2 = 2^(3^2) = 2^9 = 512
Notacin Infija
Es la notacin ya vista que sita el operador entre sus operandos. Ventaja: Es la forma natural de escribir expresiones aritmticas Inconveniente: Muchas veces necesita de parntesis para indicar el Orden de evaluacin: A*B/(A+C) A*B/A+C
Notacin Prefija o Polaca

En 1920 un matemtico de origen polaco, Jan Lukasiewicz, desarrollo un sistema para especificar expresiones matemticas sin parntesis. Esta notacin se conoce como notacin prefija o polaca (en honor a la nacionalidad de Lukasiewicz) y consiste en situar al operador ANTES que los operandos. Ejemplo: la expresin infija A*B / (A+C) se representara en notacin prefija como: /*AB+AC
Notacin Postfija o Polaca Inversa

La notacin postfija o polaca inversa es una variacin de la notacin prefija de forma que el operador de pone DESPUS de los operandos. Ejemplo: la expresin infija A*B / (A+C) se representara en notacin postfija como: AB*AC+/ Ventajas: La notacin postfija (como la prefija) no necesita parntesis. La notacin postfija es ms utilizada por los computadores ya que permite una forma muy sencilla y eficiente de evaluar expresiones aritmticas (con pilas).
Colas. Fundamentos
Las colas son secuencias de elementos caracterizadas porque las operaciones de insercin y borrado se realizan sobre extremos opuestos de la secuencia. La insercin se produce en el "final" de la secuencia, mientras que el borrado se realiza en el otro extremo, el "inicio" de la secuencia. Las restricciones definidas para una cola hacen que el primer elemento que se inserta en ella sea, igualmente, el primero en ser extraido de la estructura. Si una serie de elementos A, B, C, D, E se insertan en una cola en ese mismo orden, entonces los elementos irn saliendo de la cola en el orden en que entraron. Por esa razn, en ocasiones, las colas se conocen con el nombre de listas FIFO (First In First Out, el primero que entra es el primero que sale). ESTRUCTURA DE DATOS I -- FCI Teniendo en cuenta que las operaciones de lectura y escritura en una cola hacen siempre en extremos distintos, lo ms fcil ser insertar nodos por el final, a continuacin del nodo que no tiene nodo siguiente, y leer desde el principio, hay que recordar que leer un nodo implica elimarlo de la cola. Las colas, al igual que las pilas, resultan de aplicacin habitual en muchos problemas informticos. Quizs la aplicacin ms comn de las colas es la organizacin de tareas de un ordenador. En general, los trabajos enviados a un ordenador son "encolados" por ste, para ir procesando secuencialmente todos los trabajos en el mismo orden en que se reciben. Cuando el ordenador recibe el encargo de realizar una tarea, sta es almacenada al final de la cola de trabajos. En el momento que la tarea que estaba realizando el procesador acaba, ste selecciona la tarea situada al principio de la cola para ser ejecutada a continuacin. Todo esto suponiendo la ausencia de prioridades en los trabajos. En caso contrario, existir una cola para cada prioridad. Del mismo modo, es necesaria una cola, por ejemplo, a la hora de gestionar
50
eficientemente los trabajos que deben ser enviados a una impresora (o a casi cualquier dispositivo conectado a un ordenador). De esta manera, el ordenador controla el envio de trabajos al dispositivo, no enviando un trabajo hasta que la impresora no termine con el anterior. Anlogamente a las pilas, es necesario definir el conjunto de operaciones bsicas para especificar adecuadamente una estructura cola. Estas operaciones seran: Crear una cola vaca. Determinar si la cola est vaca, en cuyo caso no es posible eliminar elementos. Acceder al elemento inicial de la cola. Insertar elementos al final de la cola. Eliminar elementos al inicio de la cola.
Para determinar correctamente cada una de estas operaciones, es necesario especificar un tipo de representacin para las colas.
Representacion de las colas

Hay diferentes formas de implementar las operaciones relacionadas con colas, una de las ms eficientes es representar el array Cola[1..n] como si fuese circular, es decir, cuando se d la condicin de cola llena se podr continuar por el principio de la misma si esas posiciones no estan ocupadas. Con este esquema de representacin, se puede pasar a especificar el conjunto de operaciones necesarias para definir una cola circular. Para nuestro erstudio partiremos de la creacin sin arrays.
Crear cola:
Esta operacin consistir en definir la variable que permitir almacenar la informacin y las variables que apuntarn a los extremos de la estructura. Adems, hay que indicar explcitamente que la cola, trs la creacin, est vaca. typedef struct nodo { int dato; struct nodo * sig; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo * Cola;
Comprobar si la cola est vaca:

Con las condiciones establecidas, basta comprobar si inicio = fin:
Acceder al elemento inicial o al final de la cola:

Es importante poder acceder fcilmente al inicio o al final de la cola; para ello se puede usar un puntero llamado primero, y otro llamado ultimo.
Insertar un elemento en la cola:

Debido a la implementacin esttica de la estructura cola es necesario determinar si existen huecos libres donde poder insertar antes de hacerlo. Esto puede hacerse de varias formas:
boolean Cola_vacia Cola c) { boolean r=false; If ( (*cola)==Null) r=true; return r; }
51
Void Aadir (Cola * primero, Cola *Ultimo, int V) { pNuevo nuevo; nuevo=(pNodo)malloc(sizeof(tipoNodo)); /* crear un nuevo nodo*/ nuevo->dato=v; nuevo->siguiente=Null; /*este ser el ultimo nodo, no debetener siguiente*/ /*Si la cola no estaba vacia, aadimo el nuevo a continuacion de ultimo*/ If(Cola_vacia(ultimo)) (*ultimo)->siguiente=nuevo; *ultimo=nuevo; /*Ahora, el ultmioelemento de la cola es el nuevo nodo*/ /*Si primero es Null, la cola estaba vacia, ahora primero apuntara tambin al nuevo nodo */ }
O incrementando antes y luego comparando que 'Cola.inicio' sea igual a 'Cola.fin'.
Eliminar un elemento de la cola:

Sirve exclusivamente para extarer los elementos de una cola, se debe recordar que en cada movimiento de contenido de la cola los punteros primero y ltimo deben actualizarse debidamente.
Int Leer(Cola * primero, Cola *ultimo) { pNodo nodo;/* variable para manipular nodo*/ int v; /*variable auxiliar para retorno*/ nodo=*primero; /*Nodo apunta al primer elemento de la cola*/ if(Cola_vacia(nodo)) return 0; /* Si no hay nodos en la pila retornamos*/ *primero=nodo->siguiente; /*Asignmam,os a primero la direccin del segundo nodo*/ v=nodo->valor; /*Guardamos el valor de retorno*/ free(nodo); /*Borra el nodo*/ if(Cola_vacia(primero))*ultimo=NULL; /*Si la cola quedo vacia, ultimo debe ser NULL*/ return v; }
Conclusin
De todo esto puede sorprender que la condicin de cola llena sea la misma que la de cola vaca. Sin embargo, en el caso de la insercin de elementos cuando Cola.inicio = Cola.fin es cierto, no es verdad que la cola est llena, en realidad hay un espacio libre, ya que Cola.inicio apunta a una posicin libre, la anterior al primer elemento real de la cola. Pero si se decide insertar un elemento en esa posicin, no sera posible distinguir si Cola.inicio = Cola.fin indica que la cola est llena o vaca. Se podra definir alguna variable lgica que indicase cual de las dos situaciones se est dando en realidad. Esta modificacin implicara introducir alguna nueva operacin en los mtodos de insercin y borrado, lo que, en general, resultara peor solucin que no utilizar un elemento del array. Suele ser mejor solucin utilizar siempre 'n-1' elementos de la cola, y no 'n', que complicar dos operaciones que se tendrn que repetir mltiples veces durante la ejecucin de un programa.
Pilas y colas mltiples

ESTRUCTURA DE DATOS I -- FCI Hasta ahora se ha tratado solamente con la representacin en memoria y manipulacin de una nica pila o cola. Se han visto dos representaciones secuenciales eficientes para dichas estructuras. Sin embargo, en ocasiones, es preciso representar varias estructuras utilizando el mismo espacio de memoria. Supongamos que seguimos transformando las estructuras de datos en representaciones secuenciales, tipo array. Si slo hay que representar dos pilas sobre un mismo array A[1..n], la solucin puede resultar simple. Se puede hacer crecer las dos pilas partiendo desde los extremos opuestos del array, de forma que A[1] ser el elemento situado en el fondo de la primera pila y A[n] el correspondiente para la segunda pila. Entonces, la pila 1 crecer incrementando los ndices hacia A[n] y la pila 2 lo har decrementando los ndices hacia A[1]. De esta manera, es posible utilizar eficientemente todo el espacio disponible.
52
Si se plantea representar ms de dos pilas sobre ese mismo array A, no es posible seguir la misma estrategia, ya que un array unidimensional slo tiene dos puntos fijos, A[1] y A[n], y cada pila requiere un punto fijo para representar el elemento ms profundo. Cuando se requiere representar secuencialmente ms de dos pilas, por ejemplo m pilas, es necesario dividir en m segmentos la memoria disponible, A[1..n], y asignar a cada uno de los segmentos a una pila. La divisin inicial de A[1..n] en segmentos se puede hacer en base al tamao esperado de cada una de las estructuras. Si no es posible conocer esa informacin, el array A se puede dividir en segmentos de igual tamao. Para cada pila i, se utilizar un ndice f(i) para representar el fondo de la pila i y un ndice c(i) para indicar dnde est su cima. En general, se hace que f(i) est una posicin por debajo del fondo real de la pila, de forma que se cumpla la condicin f(i)=c(i) si y solamente si la pila i est vaca. La discusin realizada para el caso de pilas mltiples sirve de base para poder establecer estrategias de manipulacin de varias colas en un mismo array, incluso la combinacin de estructuras pilas y colas sobre la misma localizacin secuencial.
53
Listas Circulares
Una lista circular es una lista lineal en la que el ltimo elemento enlaza con el primero. Entonces es posible acceder a cualquier elemento de la lista desde cualquier punto dado. Las listas circulares evitan excepciones en las 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: struct nodo { int dato; struct nodo *siguiente; };
Donde p=^Nodolista (apunta al sgte. nodo de la lista) La definicin de tipo es equivalente a la anterior slo se debe modificar la direccin a la que apunta el enlace ubicado en el ltimo nodo. Las operaciones sobre una lista circular resultan ms sencillas. Cuando recorremos una lista circular, diremos que hemos llegado al final de la misma cuando nos encontremos de nuevo en el punto de partida; suponiendo que en este punto se deja un puntero fijo. Otra solucin al problema anterior sera ubicar en cada lista circular un elemento especial identificable, como lugar de parada. Este elemento especial recibe el nombre de cabeza de la lista. Esto presenta la ventaja de que la lista circular no estar nunca vaca.
Declaraciones de tipo para manejar listas:

Los tipos que definiremos normalmente para manejar listas cerradas son los mismos que para para manejar listas abiertas: typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Lista; ESTRUCTURA DE DATOS I -- FCI tipoNodo es el tipo para declarar nodos, evidentemente. pNodo es el tipo para declarar punteros a un nodo. Lista es el tipo para declarar 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
54
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: Aadir o insertar elementos. Buscar o localizar elementos. Borrar elementos. Moverse a travs de la lista, siguiente.
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 elemento en una lista circular vaca: Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a l, adems el puntero que define la lista, que valdr NULL:
El proceso es muy simple, bastar con que:

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:
El proceso sigue siendo muy sencillo:

1. Hacemos que nodo->siguiente apunte a lista->siguiente. 2. Despus que lista->siguiente apunte a nodo.
55
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. 4. Despus que lista->siguiente apunte a nodo.
Buscar o localizar un elemento de una lista circular: A la hora de 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 NULL.
Eliminar un nodo en una lista circular con ms de un elemento: Consideraremos los dos primeros casos como uno slo.
1. El primer paso es conseguir que lista apunte al nodo anterior al que queremos eliminar. Esto se consigue haciendo que lista valga lista->siguiente mientras lista->siguiente sea distinto de nodo. Manual de Estructura de Datos
56
2. Hacemos que lista->siguiente apunte a nodo->siguiente. 3. Eliminamos 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 NULL.
Otro algoritmo para borrar nodos: Existe un modo alternativo de eliminar un nodo en una lista circular con ms de un nodo. Supongamos que queremos eliminar un nodo apuntado por nodo:
1. 2. 3. 4.
Copiamos el contenido del nodo->siguiente sobre el contenido de nodo. Hhacemos que nodo->siguiente apunte a nodo->siguiente->siguiente. Eliminamos nodo->siguiente. Si lista es el nodo->siguiente, hacemos 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 NULL.
Ejemplo de lista circular en C: Construiremos una lista cerrada para almacenar nmeros enteros. Haremos pruebas insertando varios valores, buscndolos y eliminndolos alternativamente para comprobar el resultado.
57
Algoritmo de la funcin "Insertar":

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. void Insertar(Lista *lista, int v) { pNodo nodo; // Creamos un nodo para el nuvo valor a insertar nodo = (pNodo)malloc(sizeof(tipoNodo)); nodo->valor = v; // Si la lista est vaca, la lista ser el nuevo nodo // Si no lo est, insertamos el nuevo nodo a continuacin del apuntado // por lista if(*lista == NULL) *lista = nodo; else nodo->siguiente = (*lista)->siguiente; // En cualquier caso, cerramos la lista circular (*lista)->siguiente = nodo; }
Algoritmo de la funcin "Borrar":

1. Tiene la lista un nico nodo? 2. SI: 1. Borrar el nodo lista. 2. Hacer lista = NULL. 3. NO: 1. Hacemos lista->siguiente = nodo->siguiente. 2. Borramos nodo. void Borrar(Lista *lista, int v) { pNodo nodo; nodo = *lista; // Hacer que lista apunte al nodo anterior al de valor v do { if((*lista)->siguiente->valor != v) *lista = (*lista)->siguiente; } while((*lista)->siguiente->valor != v && *lista != nodo); // Si existe un nodo con el valor v: if((*lista)->siguiente->valor == v) { // Y si la lista slo tiene un nodo if(*lista == (*lista)->siguiente) { // Borrar toda la lista free(*lista); *lista = NULL; } else { // Si la lista tiene ms de un nodo, borrar el nodo de valor v nodo = (*lista)->siguiente; (*lista)->siguiente = nodo->siguiente; free(nodo); } Manual de Estructura de Datos
58

} }
Cdigo del ejemplo: Tan slo nos queda escribir una pequea prueba para verificar el funcionamiento:
#include <stdio.h> typedef struct _nodo { int valor; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Lista; // Funciones con listas: void Insertar(Lista *l, int v); void Borrar(Lista *l, int v); void BorrarLista(Lista *); void MostrarLista(Lista l); int main() { Lista lista = NULL; pNodo p; Insertar(&lista, 10); Insertar(&lista, 40); Insertar(&lista, 30); Insertar(&lista, 20); Insertar(&lista, 50); MostrarLista(lista); Borrar(&lista, 30); Borrar(&lista, 50); MostrarLista(lista); BorrarLista(&lista); getchar(); return 0; } void Insertar(Lista *lista, int v) { pNodo nodo; // Creamos un nodo para el nuvo valor a insertar nodo = (pNodo)malloc(sizeof(tipoNodo)); nodo->valor = v; // Si la lista est vaca, la lista ser el nuevo nodo // Si no lo est, insertamos el nuevo nodo a continuacin del apuntado // por lista if(*lista == NULL) *lista = nodo; else nodo->siguiente = (*lista)->siguiente; // En cualquier caso, cerramos la lista circular (*lista)->siguiente = nodo; }void Borrar(Lista *lista, int v) { pNodo nodo; nodo = *lista; // Hacer que lista apunte al nodo anterior al de valor v do { if((*lista)->siguiente->valor != v) *lista = (*lista)->siguiente; } while((*lista)->siguiente->valor != v && *lista != nodo);
59
// Si existe un nodo con el valor v: if((*lista)->siguiente->valor == v) { // Y si la lista slo tiene un nodo if(*lista == (*lista)->siguiente) { // Borrar toda la lista free(*lista); *lista = NULL; } else { // Si la lista tiene ms de un nodo, borrar el nodo de valor v nodo = (*lista)->siguiente; (*lista)->siguiente = nodo->siguiente; free(nodo); } } } void BorrarLista(Lista *lista) { pNodo nodo; // Mientras la lista tenga ms de un nodo while((*lista)->siguiente != *lista) { // Borrar el nodo siguiente al apuntado por lista nodo = (*lista)->siguiente; (*lista)->siguiente = nodo->siguiente; free(nodo); } // Y borrar el ltimo nodo free(*lista); *lista = NULL; }void MostrarLista(Lista lista) { pNodo nodo = lista; do { printf("%d -> ", nodo->valor); nodo = nodo->siguiente; } while(nodo != lista); printf("\n"); }
60
Listas doblemente enlazadas

Hasta ahora hemos estado trabajando exclusivamente con listas simplemente enlazadas. Dependiendo del problema, este tipo de estructura puede resultar ciertamente restrictiva. La dificultad de manejo de estas listas, como hemos visto, viene dada por el hecho de que dado un nodo especfico, solamente es posible moverse dentro de la lista en el sentido del nico enlace existente para ese nodo, es decir, es fcil pasar al sucesor pero no es igualmente fcil pasar al antecesor de ese mismo nodo. La nica manera de encontrar el predecesor de un nodo es volver a recorrer la lista desde el principio. Por lo tanto, cuando se tiene un problema donde es necesario moverse en ambos sentidos, es recomendable representar la lista con dos enlaces (doblemente enlazada). En este tipo de representacin, cada nodo tiene dos campos de enlace, uno que enlaza con el nodo predecesor y otro que enlaza con el nodo sucesor. Un nodo en una lista doblemente enlazada tiene, al menos tres campos, uno o ms de informacin y dos campos de enlace. En ocasiones, para facilitar an ms los movimientos dentro de la lista, es conveniente recurrir a una estructura circular de la misma, de forma que desde el ltimo elemento de la lista se pueda pasar al primero y viceversa. Entonces se habla de una lista circular doblemente enlazada. La estructura circular se puede utilizar igualmente aunque la lista sea simplemente enlazada. Para facilitar las operaciones de manipulacin de las estructuras circulares, sobre todo la insercin, y evitar en lo posible la consideracin de casos especiales (lista vacia) se suele aadir un nodo inicial (cabeza), que no contiene ninguna informacin til, y que existe aunque la lista est vaca. De modo que, incluso la lista vaca tiene una estructura circular.
Una lista doblemente enlazada es una lista lineal en la que cada elemento tiene dos enlaces, uno al elemento siguiente y otro al elemento anterior. Esto permite recorrer la lista en cualquier direccin.
Implementacion de Principales Doblemente enlazadas Insertar al inicio.

void insertar_final(pnododoble *lista,int n) { pnododoble nodo,aux; nodo=(pnododoble)malloc(sizeof(tiponododoble)); if (*lista==NULL) { *lista=nodo; nodo->sig=*lista; nodo->ant=nodo; } else { aux=(*lista)->ant; nodo-Sig=*lista, *lista=nodo; *lista->ant=aux; aux->sig=*lista; aux->ant=nodo; } }
operaciones
con
Listas
Circulares
Insertar al inicio.
void insertar_final(pnododoble *lista,int n) { pnododoble nodo; Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
61

nodo=(pnododoble)malloc(sizeof(tiponododoble)); if (*lista==NULL) *lista=nodo; else { (*lista)->ant->sig=nodo; nodo->ant=(*lista)->ant; } (*lista)->ant=nodo; Nodo->sig=*lista; f(*lista!=nodo) *lista=nodo; }
Insertar al final.
void insertar_final(pnododoble *lista,int n) { pnododoble ult,nodo; nodo=(pnododoble)malloc(sizeof(tiponododoble)); nodo->dato=n; if (*lista==NULL) { *lista=nodo; nodo->sig=*lista; nodo->ant=nodo; } else { ult=(*lista)->ant; ult->sig=nodo; nodo->ant=ult; (*lista)->ant=nodo; nodo->sig=*lista; }
Eliminar al inicio.
void insertar_inicio(pnododoble *lista,int n) { pnododoble ult,prt=*lista; if (*lista!=NULL) { if (prt->sig!=*lista) { ult=(*lista)->ant; lista=(lista)->sig; (*lista)->ant=ult; ult->sig=*lista; } else *lista=NULL free(prt); } }
Eliminar al final.
ESTRUCTURA DE DATOS I -- FCI void eliminar_final(pnododoble *lista) {pnododoble ult; if (*lista!=NULL) { ult=(*lista)->ant; if((*lista)->sig!=*lista) { ult->ant->sig=*lista; (*lista)->ant=nodo; } else *lista=NULL; free(ult); }
62

Insertar en cualquier parte.
void i_c_p(pnododoble *lista,int num,int n) { pnododoble nodo,aux,ult; nodo=(pnododoble)malloc(sizeof(tiponododble)); nodo->dato=num; if (*lista!=NULL) { aux=*lista; if(aux->dato!=n) {while(aux->sig!=*lista && aux->sig->dato!=n) { aux=aux->sig;} if(aux->sig!=*lista) {nodo->sig=aux->sig; aux->sig->ant=nodo; aux->sig=nodo; nodo->ant=aux;} else {aux->sig=nodo; nodo->ant=aux; (*lista)->ant=nodo; nodo-sig=*lista, } } else {ult=(*lista)->ant; (*lista)->ant=nodo; nodo->sig=*lista; *lista=nodo; (*lista)->ant=ult; ult->sig=*lista; } } else {*lista=nodo; nodo->sig=*lista; (*lista)->ant=nodo; } }
Imprimir la lista
void imprimir(pnodoble *lista) { pnododoble aux=*lista; if(*lista!=NULL) { do { cout<<aux->dato<< ; aux=aux->sig; } while(aux!=*lista); } }
63

Pilas y colas enlazadas
Se ha visto ya cmo representar pilas y colas de manera secuencial. Ese tipo de representacin prueba ser bastante eficiente, sobretodo cuando se tiene slo una pila o una cola. Cuando sobre el mismo array se tiene que representar ms de una estructura, entonces aparecen problemas para poder aprovechar de manera eficiente toda la memoria disponible. Vamos a presentar en esta seccin una nueva representacin de las pilas y las colas mediante la estructura de lista enlazada. En la representacin de estas estructuras vamos a hacer que los enlaces entre los elementos de la misma sea tal que faciliten las operaciones de insercin y borrado de elementos. Adems, hay que tener en cuenta que, como en cualquier otro tipo de representacin, es necesario mantener variables que indiquen dnde estn los extremos de las estructuras (dnde se realizan las operaciones), pero en este caso dichas variables ya no pueden ser ndices de un array sino referencias a localizaciones de elementos, es decir, punteros.
Pilas enlazadas
Comenzando por la estructura pila, enlazando los elementos con punteros las operaciones de insercin y borrado resultan muy simples. A continuacin definiremos la estructura pila con esta nueva representacin.
Crear pila:
Declaramos los tipos de datos necesarios para representar un nodo e inicializamos la pila como vacia. (1) Declaraciones: Nodo_pila: registro (informacion: T, enlace: puntero a Nodo_pila) cima: puntero a Nodo_pila (2)Asignacin de pila vaca cima <-- NULO
Comprobar si la pila est vaca:

La pila estar vaca si y solamente si el puntero cima no hace referencia a ninguna direccin de memoria. si cima = NULO entonces devolver(cierto) sino devolver(falso)
Acceder al elemento situado en la cima:

Al elemento "visible" de la pila se puede acceder fcilmente a travs del puntero que le referencia, cima, que siempre debe existir y ser adecuadamente actualizado.
Operacin de insercin:
Con la representacin enlazada de la pila, la estructura tiene una menor limitacin en cuanto al posible nmero de elementos que se pueden almacenar simultneamente. Hay que tener en cuenta que la representacin de la pila ya no requiere la especificacin de un tamao mximo, por lo que mientras exista memoria disponible se va a poder reservar espacio para nuevos elementos. Por esa razn, se va a suponer en el siguiente algoritmo que la condicin de pila llena no se va a dar y, por lo tanto, no ser necesaria su comprobacin.
Algoritmo Apilar
Entrada x: T (* elemento que se desea insertar *) Inicio p <-- crear_espacio p^.informacion <-- x p^.enlace <-- cima cima <-- p Fin Como se puede observar el algoritmo de insercin utilizando esta nueva representacin continua siendo muy simple, siendo el coste del mismo constante (cuatro pasos).
Operacin de eliminacin:
Lo nico que hay que tener en cuenta a la hora de disear un algoritmo para esta operacin es la utilizacin eficiente de la memoria, de forma que el espacio ocupado por el nodo borrado vuelva a estar disponible para el sistema.
64

Algoritmo Desapilar
Salida x: T Variable p: puntero a Nodo_pila Inicio si Pila_vacia entonces "Error: pila vacia" sino p <-- cima x <-- p^.informacion cima <-- p^.enlace liberar_espacio(p) fin_sino Fin
La solucin dada se puede extender a "m" pilas, de hecho como los enlaces entre elementos son establecidos por el programador, no por el mtodo de representacin, es como si las pilas siempre compartiesen espacios diferentes, no interfieren unas con otras. Se trata de una solucin conceptual y computacionalmente simple. No existe necesidad de desplazar unas pilas para proporcionar ms espacio a otras. El incremento de espacio de almacenamiento que implica la representacin enlazada se ve compensada por la capacidad de representacin de listas complejas de una forma simple y por la disminucin del tiempo de cmputo asociado a la manipulacin de listas, respecto a la representacin secuencial.
Colas enlazadas
Anlogamente al desarrollo hecho para las pilas se puede pasar a definir las operaciones requeridas para especificar una cola de forma enlazada.
Crear cola:
Declaramos los tipos de datos necesarios para representar un nodo e inicializamos la cola como vacia. (1) Declaraciones: Nodo_cola: registro (informacion: T, enlace: puntero a Nodo_cola) inicio, final: puntero a Nodo_cola (2)Asignacin de cola vaca inicio <-- NULO final <-- NULO
Comprobar si la cola est vaca:

De nuevo, la estructura estar vaca si y slo si el puntero inicio no hace referencia a ningn nodo de la cola. si inicio = NULO entonces devolver(cierto) sino devolver(falso)
Se puede acceder a este elemento de la cola mediante el puntero inicio que lo referencia.
Operacin de insercin: Algoritmo InsertarCola

Entrada x: T Variable
Acceso al primer elemento de la cola:
65
p: puntero a Nodo_cola Inicio p <-- crear_espacio p^.informacion <-- x p^.enlace <-- nulo si Cola_vacia entonces inicio <-- p sino final^.enlace <-- p final <-- p Fin
Operacin de borrado: Algoritmo BorrarCola

Salida x: T Variable p: puntero a Nodo_cola Inicio si Cola_vacia entonces "Error: cola vacia." sino p <-- inicio inicio <-- p^.enlace (* si tras borrar se vacia la cola, hay que poner final a nulo *) si Cola_vacia entonces final <-- NULO x <-- p^.informacion liberar_espacio(p) fin_sino Fin
Listas Mltiplemente Enlazadas

Este tipo de listas contiene ms de dos enlaces por nodo, los que tienen la posibilidad de apuntar a ms de dos listas enlazadas. Vista grfica de un nodo p p Dato p p
66
RECURSIVIDAD
El c onc e pt o d e r ec ur siv ida d va l iga do a l de r e pet ic i n. S on re curs i vos a q ue ll o s alg o ritm os q ue , esta nd o enc a psu lad os de nt ro de un a fu nci n, s on l la mados d esd e el la misma una y ot ra v ez, en c ont r ap os ici n a l os alg o ritm os it e rati v os, qu e h ac en uso d e bucl es wh il e, d o- wh il e, fo r, etc.
Caractersticas .
Un alg o ritm o r ecu rsi v o const a de un a pa rte r ecu rs iv a, otr a it e rati v a o n o r ec urs i va y una c ond ici n d e t e r min aci n. La pa rt e r e curs i va y l a c o ndic i n d e t e rmi nac i n siem p r e e xist e n. E n ca mbio la pa rt e n o r ec ur siv a p u ede c o inc idi r c o n la c on dic i n de ter mi nac i n. Al go mu y i mp o rta nte a te ne r en c u enta cu and o us em os l a r ec ur siv ida d es q ue e s nec esa r io as egu r ar n os q ue l le ga un m om en to en q ue n o h ace mo s ms l la mad as r ecu rsi v as. Si n o se cu mp le esta co nd ici n e l p ro gr ama n o pa ra r n u nca.
Ventajas e inconvenientes.
La p r inc i pal v ent aj a es la sim p lic ida d de com p r ensi n y s u g ra n p ot en cia, f a vo r eci e ndo la r es ol uci n d e p r obl emas d e man e ra n atu r al, se nci ll a y e l ega nt e ; y faci li dad pa ra com p rob a r y c on v enc e r se d e qu e la s ol uc i n d el p r obl em a es co r r ecta . El p rin ci pa l inc on v e ni e nte es l a i n efi ci enc ia t ant o en t i em po co mo en me mo r ia, dad o qu e p ar a p erm iti r s u uso es nec es ar io tr an sfo rma r el pr og ra ma r ecu rs iv o en ot r o ite rat i vo, qu e ut il iz a Bu cles y p il as pa ra a lmac en ar las va ri abl es. Vent ajas : efic i ent es y r p id os. Inco n v eni e ntes : P ar a cada el em ent o de la lista s e deb e res e r va r un es pac i o p ar a pu nt er os lo q u e sig ni fic a u n d esa p ro v ech ami e n to d e m em or ia e n e l "m an ej o d e l ista ". Zona de Overflow. Se r es e r va es pac io e n cie rt a z on a d e ext e rn a a la p r o pi a tab la, de a p ro x imad am ent e el 10% de su ta ma o, pa ra i nt rod uc ir l as co lis i on es. C ada si n ni mo s e alm ac en a en la p rim e ra ce lda dis p on ibl e d e l a zo na de o v er fl o w. Inco n v eni e nte : Des ap r ov ec ham ie nt o de m em or ia ( poc o ). Es p oc o e f ici ent e cu and o se han p r odu cid o c ol isi on es, ya qu e l a bs q u eda en la z on a d e o ve rf l ow es s ecu e nci al. Vent ajas : O cu pa m e no s mem or ia q ue el an ter i or . E l a lg or itm o d e bs q ue da y d e ins er ci n es m s s enc il lo. Almacenamiento interno Cua nd o e l esp aci o us a do pa ra a lm ace na r las col isi on es esta d ent r o de l os l mit es d e l a tabla . Dent r o de l a lmac en am i ent o int e rn o est n: E n cade na mi ent o di r ecto y e nca de nam i ent o vac o. Encadenamiento directo. ESTRUCTURADE DATOS I -- FCI
67
Se usa de nt ro d e la t abla un c am p o de t i p o p unt e r o p a ra qu a pu nt e al s ig ui ent e col isi on ad o, qu e esta r de nt ro de la t abl a. En es e c am po s e g ua r da l a di r ecc i n d el sigu ie nt e c olis i ona do. En e l e nca de nam i ent o dir ect o c on zo na d e ov e rf lo w p ode mos s o br edim e nsi on ar la tabla pa ra al mac en a r l as c ol isi on es, e n esta z on a l as c asi ll as esta r n enc ad en adas con un a v ar iab l e qu e a pu nt e al p rim e r esp aci o li br e d e l a z on a d e o v er fl ow . C ons iste en en la za r to dos los el em ent os cu y as cla v es gen e ra n i gua l n dic e pr ima ri o po r m ed i o de en lac es d e ntr o d e la tabl a a las nu e vas p os ici on es ocu p adas p o r e stos e l em ent os. Inco n v eni e ntes : Es pac i o res e r vad o en cad a el em ent o pa ra e l en lac e. Vent ajas : Ms r p ido qu e el e xt er n o co n zo na d e o ve rf l ow y a qu e e vit a l a bs q ue da secu e nci al. Oc up aci n de me mo ri a: D ep e nd e d el m t o do us ad o. El p ri me r caso ocu p a m en os mem or ia , y e l s eg und o es ms r pid o.
Forma de Interpretacin
Al go es r ecu rs iv o si se defi n e en t r mi nos d e s mism o (c ua nd o p ar a def in i rse h ac e men ci n a s mism o ). Pa r a q ue un a de fi nic i n r ecu rs i va se a v l ida , la r ef e r enc ia a s misma deb e s e r re lat i v ame nte ms s e nci ll a qu e el c aso co nsi de ra do . Ej em p lo: d efi nic i n d e n n atu ra l: -> El N 0 es natu r al -> El N n es nat ur al s i n-1 lo es. En u n a lg or itm o rec u rsi vo dist in gui mos com o mn imo 2 pa rt es: Cas o t ri vi al, bas e o d e fin de r ec urs i n: Es u n cas o d on de e l p r obl em a p u ede r es ol v er se si n te n er q ue hac e r uso d e u na nu e v a lla mad a a s m ismo . E vi ta la co nti nu aci n i nd e fin id a de l as pa rtes r ec urs i vas. b). P art e p ur am ent e re curs i va: Re lac io na el res ult ado del a lg or itm o co n r es ulta dos d e cas os ms simp l es. S e ha ce n nu e vas ll amad as a la f unc i n, p er o est n m s p r x imas al cas o bas e.
EJEMPLO ITERATIVO:
Int F act or ia l ( i nt n ) { int i , r es=l; fo r ( i = l; i<= n; i++ ) r es = r es* i; ret ur n ( res ) ; }
RECURSIVO:
int Fact o ri al ( int n ) { if (n = = 0 ) r etu rn (1 ); r etu rn ( n* Fact o ria l (n -1 ) ) ; }
68

TIPOS DE RECURSION
Recursividad simple: A qu e ll a e n cu y a d efi ni ci n s lo a pa r ec e un a lla mad a r ec u rsi va. S e pu ed e t ra nsf or ma r con fac il ida d e n alg o rit mos it e rat i vos. Recursividad mltiple: Se d a cua nd o ha y ms de una l lam ada a s misma d ent r o de l cue r po d e la f unc i n, r esult an do ms d if ci l d e h ace r de f orm a ite rat iv a.
int Fib ( i nt n ) /* e j : Fi bo nacc i */ { if (n< =l ) r etu rn ( 1 ) ; r etu r n (F ib (n- 1) + Fib ( n-2 ) ); } Rec u rsi vi dad an ida da: En a lgu n os d e los a rg. de la l lam ada r ec u rsi va ha y un a nu e va lla mad a a s m isma. int Ack ( int n, int m ) / * e j : Ack e rma n */ { if (n = = 0 ) r etu r n (m+1 ); els e if (m= = 0 ) ret ur n ( Ack ( n-1 , 1 ) ); r etu rn ( Ack ( n-1 , Ack ( n,m- l) ) ) ; } R ec urs i vid ad c r uz ada o ind i rect a: S on al go ritm os d o nde u na fu nci n p r o voc a u na lla mad a a s m isma de fo rma in di r ecta, a t ra v s de ot ras fu nci on es.
E j : P ar o Im pa r: int p a r ( i nt n um p ) { if (n um p= = 0) r et u rn ( l) ; r etu rn ( im pa r ( nu mp-1 ) ) ; int im pa r ( i nt num i ) { if (n umi= =0 ) ret ur n (0 ); r etu rn ( p ar ( nu mi- 1) ) ; } ESTRUCTURADE DATOS I -- FCI Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
69
LA PILA DE RECURSION
La m em or ia d el o rd en a do r s e d i vid e (d e ma ne ra l gi ca, n o f sic a ) en va r ios seg me ntos (4 ): Se gm ent o de c d igo : Pa rt e de la m emo r ia don de s e gu ar dan las instr ucc io n es de l p ro gr ama e n c od. M q u ina . Se gm ent o d e dat os: Pa rt e d e la m em or ia dest in ada a al mac e na r las v ar iab l es estt icas. Mo nt cu lo: P a rte de la mem or ia dest in ada a la s va r iab les di nm icas. Pi la d el p r og ram a: P art e d esti na da a las v ar ia bles l oca l es y p a rm et ros d e la fu nci n qu e est si end o ej ec ut ada. Llam ada a u na fu nci n: Se res e r va es pac i o e n la pi la pa ra los p ar met r os d e la f unc i n y sus va r iab les loc al es. S e gua rd a en la p il a la di r ecc i n d e la l n ea de cd ig o d esd e d o nde se ha ll ama do a la fu nc i n. S e alm ac ena n los p ar met r os d e la fu nci n y sus v al o res e n l a pi la. Al t e rmi na r l a fu n ci n, s e li be ra la m em or ia asig nad a en l a pi l a y s e vu el v e a la inst ruc . Actu al. Llam ada a u na fu nci n r ecu rsi v a: En e l cas o r ecu rs i vo, cada lla mad a ge n er a u n nu e vo ej em p la r d e l a fu nci n c on s us co rr es p ond ie nt es o bj et os l oca l es: La f unc i n s e e jec uta r n o rma lm ent e hast a la ll ama da a s m isma. En es e mom ent o s e c r ean e n l a p il a n u ev os p ar m etr os y va ri abl es lo cal es. El nu e vo e je mp la r de f un ci n c om ie n za a ej ecut a rse . Se c re an ms co p ias hast a ll ega r a l os cas os b ases , d ond e se res ue l ve dir ect am ent e el va l or, y s e va sa li e ndo li be r and o m emo r ia hasta ll ega r a l a pr im er a lla mad a ( ltim a e n c e r r ars e ) EJ E RC ICI O S a). To r r es de Ha no i: P rob l ema d e sol uc i n rec u rsi va, c ons iste e n mo ve r to dos l os discos ( de dif e r ent es tama os ) d e u na ag uj a a otr a, us an do un a agu ja au xi lia r, y sabi end o qu e u n di sco n o pu ed e esta r s ob r e otr o m en o r qu e st e. /* S ol uc i n: 1- M o v er n-1 disc os d e A a B 2- M o v er 1 d isco de A a C 3- M o v er n-1 disc os d e B a C
*/ vo id H an oi ( n, i ni cia l, a ux, fi na l ) { if ( n> 0 ) { Ha no i (n- 1, i nic ia l, f in al , au x ); p ri ntf (" M o ve r %d d e %c a %c ", n, in ici al, fi na l ) ; Ha no i (n -1, a u x, i ni cia l, fin al ); b). Ca lcu la r \ e le v ad o a n d e f o rma r ec urs i va: flo at x el e vn ( fl oat b as e, int e x p ) { if (e x p == O ) r etu rn (1 ); r etu rn ( b as e*x e le v n (b ase, e x p-1 )) ; c). M ult ip lic a r 2 ns c o n sum as suc es iv as r ec urs: int m ult i ( i nt a, i nt b ) { if (b == O ) r etu r n (0) ; re tur n ( a + mu lti (a , b-1 ) ); d). Qu h ac e este p r o gra ma ?: vo id c os a ( ch ar *ca d, i nt i ) if ( ca d[ i ] '= '\ O ' ) cosa (c ad,i +1 );
70

p ri ntf (" %c ", ca d[ i ] );
71
rboles Fundamentos y terminologa bsica

Hasta ahora hemos visto estructuras de datos lineales, es decir, los datos estaban estructurados en forma de secuencia. Sin embargo, las relaciones entre los objetos no siempre son tan simples como para ser representadas mediante secuencias (incluso, en muchas ocasiones, es conveniente que no sea as), sino que la complejidad de las relaciones entre los elementos puede requerir otro tipo de estructura. En esas situaciones se pasara a tener estructuras de datos no lineales. Este es el caso de la estructura de datos conocida como rbol. Un rbol es una estructura no lineal en la que cada nodo puede apuntar a uno o varios nodos. Tambin suele dar una definicin recursiva: un arbol es una estructura compuesta por un dato y varios arboles. Los rboles establecen una estructura jerrquica entre los objetos. Los rboles genealgicos y los organigramas son ejemplos comunes de rboles. Un rbol es una coleccin de elementos llamados nodos, uno de los cuales se distingue del resto como raz, junto con una relacin que impone una estructura jerrquica entre los nodos. Formalmente, un rbol se puede definir de manera recursiva como sigue: Definicin: una estructura de rbol con tipo base T es: (i) Bien la estructura vaca. (ii) Un conjunto finito de uno o ms nodos, tal que existe un nodo especial, llamado nodo raiz, y donde los restantes nodos estn separados en n >= 0 conjuntos disjuntos, cada uno de los cuales es a su vez un rbol (llamados subrboles del nodo raz).
La definicin implica que cada nodo del rbol es raz de algn subrbol contenido en el rbol principal. El ndice de un libro es un buen ejemplo de representacin en forma de rbol. Ejemplos de estructuras arborescentes:
Antes de continuar avanzando en las caractersticas y propiedades de los rboles, veamos algunos trminos importantes asociados con el concepto de rbol: ESTRUCTURA DE DATOS I -- FCI Grado de un nodo: es el nmero de subrboles que tienen como raz ese nodo (cuelgan del nodo). Nodo terminal u hoja: nodo con grado 0. No tiene subrboles. Grado de un rbol: grado mximo de los nodos de un rbol. Hijos de un nodo: nodos que dependen directamente de ese nodo, es decir, las races de sus subrboles. Padre de un nodo: antecesor directo de un nodo del cual depende directamente. Nodos hermanos: nodos hijos del mismo nodo padre. Camino: sucesin de nodos del rbol: n(1), n(2), .. n(k), tal que n(i) es el padre de n(i+1). Antecesores de un nodo: todos los nodos en el camino desde la raz del rbol hasta ese nodo. Nivel de un nodo: longitud del camino desde la raz hasta el nodo. El nodo raz tiene nivel 1. Altura o profundidad de un rbol: nivel mximo de un nodo en un rbol. Longitud de camino de un rbol: suma de las longitudes de los caminos a todos sus componentes. Bosque: conjunto de n >= 0 rboles disjuntos.
72
La representacin de un rbol general depender de su grado, es decir, del nmero de relaciones mximo que puede tener un nodo del rbol. Resulta ms simple la representacin y manipulacin de una estructura rbol cuando el grado de ste es fijo e invariable. Por esa razn, para introducir los aspectos ms concretos de la manipulacin de rboles nos vamos a centrar en un tipo particular de los mismos, los llamados rboles binarios o de grado dos.
rboles binarios Los rboles binarios constituyen un tipo particular de rboles de gran aplicacin. Estos rboles se caracterizan porque no existen nodos con grado mayor a dos, es decir, un nodo tendr como mximo dos subrboles. Definicin: un rbol binario es un conjunto finito de nodos que puede estar vaco o consistir en un nodo raz y dos rboles binarios disjuntos, llamados subrbol izquierdo y subrbol derecho. En general, en un rbol no se distingue entre los subrboles de un nodo, mientras que en un rbol binario se suele utilizar la nomenclatura subrbol izquierdo y derecho para identificar los dos posibles subrboles de un nodo determinado. De forma que, aunque dos rboles tengan el mismo nmero de nodos, puede que no sean iguales si la disposicin de esos nodos no es la misma:
Antes de pasar a la representacin de los rboles binarios, vamos a hacer algunas observaciones relevantes acerca del nmero y caractersticas de los nodos en este tipo de rboles. Lema 1: el nmero mximo de nodos en el nivel i de un rbol binario es 2^(i-1), con i >= 1, y el nmero mximo de nodos en un rbol binario de altura k es (2^k) - 1, con k >= 1. Lema 2: para cualquier rbol binario no vaco, si m es el nmero de nodos terminales y n es el nmero de nodos de grado dos, entonces se cumple que m = n + 1.
Igualmente, para poder entender alguna de las formas de representacin de los rboles binarios, vamos a introducir dos nuevos conceptos, lo que se entiende por rbol binario lleno y por rbol binario completo.
Definicin: se dice que un rbol binario est lleno si es un rbol binario de profundidad k que tiene
(2^k) - 1 nodos. Un rbol binario lleno es aquel que contiene el nmero mximo de posibles nodos. Como en estos casos no existen subrboles vacos excepto para los nodos terminales, es posible realizar una representacin secuencial eficiente de este tipo de rboles. Esta representacin suele implicar la numeracin de los nodos. La numeracin se realiza por niveles y de izquierda a derecha. Este proceso de numeracin (etiquetado) de los nodos permite una identificacin elegante de las relaciones de parentesco entre los nodos del rbol y se ver ms adelante.
Definicin(1): Los r bol es d e gr ad o 2 tie n e n un a es p eci al im p o rta nci a. S e l es co no ce

con el n omb r e de rb ol es bin a ri os. S e de fi ne un rb ol bi na ri o co mo un co nj unt o fi nit o de el em ent os (n od os ) q ue b i en est va ci o es t fo rm ad o po r u na r a z co n d os rb ol es bina r ios dis ju ntos, l lam ados s ub rb ol i z qu ie rd o y d e rec ho d e l a ra z.
73
Definicin (2): un rbol binario con n nodos y profundidad k se dice que es completo si y slo si sus
nodos se corresponden con los nodos numerados de 1 a n en el rbol binario lleno de profundidad k. Cuando un rbol no es lleno pero es completo, tambin es posible la representacin secuencial eficiente de la estructura de nodos que lo componen. En l os a p art ad os qu e sigu en se co nsid e ra r n nic am e nt e rb ol es bina r ios y , po r l o tanto , s e ut il iz ar l a p alab r a rb ol p ar a r ef er i rs e a r bo l bi na r io. Los rb o les de g rad o sup e ri o r a 2 re cib en e l nomb r e d e rb o les mu l ticam in o. rb ol b in ar io de bs q ued a.- L os rb o les b i na ri os s e ut ili z an f r e cue nt eme nt e pa ra r ep r es enta r co nj unt os de d atos cu y os e l em en tos se id ent if ica n po r u na c la v e nic a. Si el rbo l est o rga ni za d o d e ta l m an e ra q ue la cla v e d e c ada n odo es ma yo r q ue tod as las c la v es s u sub rbo l i z qu ie rd o, y me n or qu e todas las cl a ves d el s u brb o l d e rec ho se dic e qu e este rb ol es un rb o l bi na ri o d e b s qu ed a. Ej em p lo:
Representacin de los rboles binarios Como hemos visto, si el rbol binario que se desea representar cumpla las condiciones de rbol lleno o rbol completo, es posible encontrar una buena representacin secuencial del mismo. En esos casos, los nodos pueden ser almacenados en un array unidimensional, A, de manera que el nodo numerado como i se almacena en A[i]. Esto permite localizar fcilmente las posiciones de los nodos padre, hizo izquierdo e hijo derecho de cualquier nodo i en un rbol binario arbitrario que cumpla tales condiciones. ESTRUCTURA DE DATOS I -- FCI Lema 3: si un rbol binario completo con n nodos se representa secuencialmente, se cumple que para cualquier nodo con ndice i, entre 1 y n, se tiene que: (1) El padre del nodo i estar localizado en la posicin [i div 2] si i <> 1. Si i=1, se trata del nodo raz y no tiene padre. (2) El hijo izquierdo del nodo estar localizado en la posicin [2i] si 2i <= n. Si 2i>n, el nodo no tiene hijo izquierdo. (3) El hijo derecho del nodo estar localizado en la posicin [2i+1] si 2i+1 <= n. Si (2i+1) > n, el nodo no tiene hijo derecho.
Evidentemente, la representacin puramente secuencial de un rbol se podra extender inmediatamente a cualquier rbol binario, pero esto implicara, en la mayora de los casos, desaprovechar gran cantidad del espacio reservado en memoria para el array. As, aunque para rboles binarios completos la representacin es ideal y no se desaprovecha espacio, en el peor de los casos para un rbol lineal (una lista) de profundidad k, se necesitara espacio para representar (2^k) - 1 nodos, y slo k de esas posiciones estaran realmente ocupadas. Adems de los problemas de eficiencia desde el punto de vista del almacenamiento en memoria, hay que tener en cuenta los problemas generales de manipulacin de estructuras secuenciales. Las operaciones de insercin y borrado de elementos en cualquier posicin del array implican necesariamente el movimiento potencial de muchos nodos. Estos problemas se pueden solventar adecuadamente mediante la utilizacin de una representacin enlazada de los nodos.
74
Representacin enlazada Se podra simular una estructura de enlaces, como la utilizada para las listas, mediante un array. En ese caso, los campos de enlace de unos nodos con otros no seran ms que ndices dentro del rango vlido definido para el array. La estructura de esa representacin enlazada pero ubicada secuencialmente en la memoria correspondera al siguiente esquema para cada nodo:
donde el campo informacion guarda toda la informacin asociada con el nodo y los campos hijo izquierdo e hijo derecho guardan la posicin dentro del array donde se almacenan los respectivos hijos del nodo. Ejemplo:
Los problemas de esta representacin estn asociados con la manipulacin de la misma. En el caso de la insercin de nuevos nodos, el nico problema que puede aparecer es que se supere el espacio reservado para el array, en cuyo caso no se podrn insertar ms nodos. Sin embargo, la operacin de borrado implica mayores problemas de manipulacin. Al poder borrar cualquier nodo del rbol, se van a dejar "huecos" en la estructura secuencial del array, esto se podra solucionar, como siempre, mediante el desplazamiento de elementos dentro del vector. Sin embargo, si de por s esa operacin no resulta recomendable, en este caso mucho menos, ya que implica a su vez modificar los enlaces que hayan podido variar con el desplazamiento. Otra solucin, podra consistir en almacenar las posiciones del array que estn libres y que se pueden ocupar en la insercin de nodos. Esto podra resultar ms eficiente, pues no implica el desplazamiento de informacin, pero requiere de la utilizacin de otra estructura de datos auxiliar que maneje esa informacin. La mejor solucin, de nuevo, para evitar los problemas asociados con la manipulacin de arrays, es la representacin de los rboles binarios mediante estructuras dinmicas "puras", en el sentido de la
75
creacin en tiempo de ejecucin de los nodos que sean necesarios (no ms) y la utilizacin de punteros para enlazar estos nodos. La estructura de cada nodo en esta representacin coincide con la estructura de tres campos vista anteriormente. La nica diferencia reside en la naturaleza de los campos de enlace, en este caso se trata de punteros y no de ndices de un array. La implementacin, sera: #inc lu de <co ni o.h > #inc lu de <stdi o.h > #inc lu de <stdl ib.h > ty pe de f st ruct n odo { int d ato; struct n od o *i z q; struct n od o *d e r; }n od oa rb ol ; Se puede comprobar como la representacin en memoria de la estructura, en cuanto a definicin de tipos de datos, coincide exactamente con la de, por ejemplo, una lista doblemente ligada, sin que ello implique que se est hablando de la misma estructura de datos. De nuevo hay que dejar muy claro que es la interpretacin que hacemos de la representacin en memoria la que define una estructura de datos, no la representacin en s misma.
Nodo Dato *izq *der
La representacin enlazada tiene como principal desventaja que no resulta inmediato la determinacin del padre de un nodo. Es necesario buscar el camino de acceso al nodo dentro del rbol para poder obtener esa informacin. Sin embargo, en la mayora de las aplicaciones es la representacin ms adecuada. En el caso en que la determinacin del padre de un nodo sea una operacin importante y frecuente en una aplicacin concreta, se puede modificar ligeramente la estructura de cada nodo aadiendo un cuarto campo, tambin de tipo enlace, que guarde la posicin del padre de cada nodo. Al igual que en la representacin enlazada de las listas, es necesario mantener un puntero al primer elemento de la estructura, en este caso el nodo raz del rbol, que permita acceder a la misma.
Insertar Nodos
vo id ins e rta r (n od oa rb ol **r ai z, int ind ic e ) {// p ro ces o d e ins e rta r el e lem e nto e n el ar bo l if (* ra iz= =N ULL ){ *r ai z= (n od oa rb ol *) m all oc (si z eo f (n odo a rbo l ) ) ; (* ra iz )- >dat o= ind ic e; (* ra iz )- >i z q=N ULL; (* ra iz )- >d er =NU LL; } e lse Els e e lse {( p r intf ( "\n No s e pu ed e i ns ert a r i ndi ce du pl icad o \ n\ n" ) ); g etch ( ); } } // r ec o rr e a la i z qu ie rd a if (i ndi ce< (* r ai z) ->dat o )i nse rt ar ( & (* ra iz )-> iz q, in dic e ); // r ec o rr e a la d e r echa if ( ind ic e> (* r aiz )- >dat o )i nse rt ar ( & (* ra iz )-> de r, in dic e );
Funcin recursiva
76
Grafica un Arbol
vo id Gmu est ra A BJ ( nod o arb ol * p, i nt ni v el, int c ol, int p os, int i ) { s etli n est yl e (0,1, 0) ; if ( ! P ) ) { Gmu estr a AB J ( p->i z qu i e rda ,n iv e l+1,c ol - pos/ 2, p os/2,c ol ); s[0 ]= p->d ato ; setco l or (4 ); lin e (i ,( ni v el -1 )*45, co l,n iv e l*45 ) ; cir cl e (co l, ni v el*4 5,10 ); setco l or (1 0) ; outt ext x y (c ol-5 ,n iv e l*4 5-5,s ); Gmu estr a AB J ( p->d e re c ha,n i ve l+1 ,co l + p os/2, p os/2,c ol ); s etl in est yl e (0, 1,0 ) ; } }
Operaciones bsicas
Un a ta r ea mu y co mn a re al iz ar c on un rb ol es ej ec uta r un a d et er min ada o p er aci n con cad a un o d e los e l em ent os d el rb ol. Est a o p e rac i n s e c ons id e ra e nto nc es c om o un pa rm et r o de una t ar ms g e ne r al qu e e s la v isit a de t od os l os nod os o, c om o se den om in a us ua lme nt e, del r ec o r rid o d el rb ol. Si s e c onsi de r a la t ar e a com o u n pr oc eso s ec ue nci al, ent o nces los n odos in di vi dua l es se visit an e n u n o rd en es pec f ico , y p u ed en c ons id er a rse c om o o r ga ni zad os s eg n u na estr uct ur a l in ea l. D e h ech o, s e sim p li fic a co n side r abl em ent e la d esc ri pc i n d e mu ch os alg o ritm os si p u ed e ha bla rs e de l p r oces o d el sigu ie nt e el em ent o e n el rb ol, s eg n u n cie rt o or de n sub y ac ent e.
Recorrido de rboles binarios
Ha y d os f o rmas bs ic as d e r ec or r e r un rb ol: El r eco r ri do en am pl itud y el r eco r ri do e n p r of un dida d. Rec o r rid o e n am pl itud. - Es a qu el r eco r ri do q ue rec o r re rb ol p o r ni v el es, en e l lt imo e je mp l o se r a: 12 - 8, 17 - 5 ,9,15
el
P re o rd en: Ra i z, sub rb ol iz q ui e rd o y sub rbo l de re ch o. In O rde n: S uba rb ol iz q u ie rd o, ra iz , sub rbo l d e r ech o. P osto rd en : Suba rb o l i z qu i er do, sub arb o l d er e cho, r ai z.
Rec o r rid o e n p r of und id ad.- R ec or r e el rb ol p or s ub rb ol es. Ha y t res fo rmas: P r eo rd en , In o rd e n y post o rd en.
77
Ej em p lo: P re o rd en: 20 In O rd en: 2 P osto rd en : 2
- 12 - 5 - 2 - 7 - 13 - 5 - 7 - 12 - 13 - 15 - 7 - 5 - 15 - 13 - 12 -
15 20 35
40 30 30
30 35 47
35 40 40
47 47 20
Ej em p lo: P re o rd en: / + a b * c d O rd en I n O rd en: a + b / c * d P osto rd en : a b + c d * /
Si se desea manipular la informacin contenida en un rbol, lo primero que hay que saber es cmo se puede recorrer ese rbol, de manera que se acceda a todos los nodos del mismo solamente una vez. El recorrido completo de un rbol produce un orden lineal en la informacin del rbol. Este orden puede ser til en determinadas ocasiones. Cuando se recorre un rbol se desea tratar cada nodo y cada subrbol de la misma manera. Existen entonces seis posibles formas de recorrer un rbol binario. (1) nodo - subrbol izquierdo - subrbol derecho (2) subrbol izquierdo - nodo - subrbol derecho (3) subrbol izquierdo - subrbol derecho - nodo (4) nodo - subrbol derecho - subrbol izquierdo (5) subrbol derecho - nodo - subrbol izquierdo (6) subrbol derecho - subrbol izquierdo - nodo
Si se adopta el convenio de que, por razones de simetra, siempre se recorrera antes el subrbol izquierdo que el derecho, entonces tenemos solamente tres tipos de recorrido de un rbol, los tres primeros en la lista anterior. Estos recorridos, atendiendo a la posicin en que se procesa la informacin del nodo, reciben, respectivamente, el nombre de recorrido prefijo, infijo y posfijo y dan lugar a algoritmos eminentemente recursivos: Algoritmo Prefijo (Pre Orden) void preorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ printf("%d ", cabeza->dato); preorder(cabeza->izq); preorder(cabeza->der); } }
78

Algoritmo Infijo (in Orden) void inorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ inorder(cabeza->izq); printf("%d ",cabeza->dato); inorder(cabeza->der); } } Algoritmo Posfijo void postorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ postorder(cabeza->izq); postorder(cabeza->der); printf("%d ",cabeza->dato); } } Ejemplo de recorrido de un rbol:
79
Operaciones con rboles binarios La primera operacin a considerar sobre rboles binarios ser su generacin. En este caso, no vamos a entrar a considerar todos los casos que pueden aparecer al insertar un nuevo nodo en un rbol, la problemtica puede ser amplia y el proceso de generacin de un rbol depender de las reglas impuestas por una aplicacin particular. Vamos a ver, sin embargo, algn ejemplo concreto que permita ilustrar esta operacin. Al manipular la estructura rbol, la situacin ms habitual es que el problema imponga una serie de reglas para la construccin del rbol en funcin de los datos de entrada. Estos datos, en principio, sern desconocidos antes de la ejecucin del programa. El procedimiento de generacin del rbol deber, por tanto, reproducir de la manera ms eficiente posible esas reglas de generacin. Ejemplo 1: Supongamos que se desea generar en memoria una estructura de rbol binario con unos datos cuyas relaciones se conocen previamente. Es decir, el usuario va a trasladar al ordenador una estructura de rbol conocida. Para hacer esto, se establece una notacin secuencial que permita la interpretacin simple de las relaciones. sta notacin es similar a la representacin secuencial que se coment para rboles binarios completos, y que se extendi a cualquier rbol arbitrario. La notacin consiste en una secuencia de caracteres que indica la informacin de cada nodo en el rbol completo asociado, de manera que se indica tambin si algn subrbol est vaco y se supone que la informacin del subrbol izquierdo va siempre antes que la del subrbol derecho. En realidad se trata de una representacin secuencial del recorrido prefijo del rbol. Se considerar, para simplificar, que la informacin asociada con cada nodo es simplemente un carcter y que los subrboles vacos se representan con un '.'. Entonces la entrada al algoritmo de generacin puede ser simplemente una cadena de caracteres, donde cada uno de ellos se interpreta como un nodo del rbol. En este caso, las reglas de generacin del rbol binario a partir de su representacin secuencial seran: (1) Leer carcter a carcter la secuencia de entrada. (2) Si el carcter que se lee es '.' no hay que crear ningn nodo, el subrbol est vaco. (3) Si se lee un carcter distinto de '.' entonces se crea un nuevo nodo con la informacin leda y se pasa a generar los subrboles izquierdo y derecho de ese nodo, segn los mismos criterios y en ese mismo orden. Un algoritmo que implemente estas reglas de generacin podra ser: Algoritmo Generar_Arbol Entrada p: arbol (por referencia) Inicio leer(caracter) si (caracter <> '.') entonces p <-- crear_espacio p^.info <-- caracter Generar_Arbol(p^.Izq) Generar_Arbol(p^.Der) fin_si sino p <-- NULO Fin
Se puede observar como la recursividad permite definir de una manera simple y elegante el proceso de generacin.
80

Ejemplo 2:
Generar el rbol binario de representacin de una expresin aritmtica. Para ello se realizan las siguientes consideraciones: (1) La entrada del programa deber ser una expresin escrita en notacin infija. (2) En las expresiones slo se tendrn en cuenta los cuatro operadores binarios bsicos: +, -, *, / y no se considerarn parntesis. (3) Los operandos sern exclusivamente caracteres. La generacin del rbol se facilita considerablemente si se traduce la expresin a notacin posfija y se almacenan los elementos de la expresin en una pila, segn el algoritmo que vimos en el tema 3. Algoritmo Generar_Arbol Entrada p: arbol (por referencia) pila: TipoPila Inicio si (NO Pila_vacia(pila)) entonces p <-- crear_espacio p^.info <-- Desapilar(pila) si (p^.info ES operador) entonces Generar_Arbol(p^.Der) Generar_Arbol(p^.Izq) fin_si sino p^.der <-- NULO p^.izq <-- NULO fin_sino fin_si Fin Ejemplo 3: funcin que se encarga de copiar un rbol. Algoritmo Copiar Entrada arb: arbol Variable p: arbol Inicio si (arb <> NULO) entonces p <-- crear_espacio p^.info <-- arb^.Info p^.Izq <-- Copiar(arb^.Izq) p^.Der <-- Copiar(arb^.Der) devolver(p) fin_si sino p <-- NULO ESTRUCTURADE DATOS I -- FCI
81
devolver(p) fin_sino Fin Ejemplo 4: funcin que mire si dos rboles son equivalentes. Algoritmo Equivalentes Entradas arb1, arb2: arbol Salida eq: (cierto, falso) Inicio eq <-- FALSO si (arb1 <> NULO) Y (arb2 <> NULO) entonces si (arb1^.Info = arb2^.Info) entonces eq <-- Equivalentes(arb1^.Izq, arb2^.Izq) Y Equivalentes(arb1^.Der, arb2^.Der) fin_si sino si (arb1 = NULO) Y (arb2 = NULO) entonces eq <-- CIERTO Fin Ejemplo 5: eliminacin de nodos. El borrado de nodos es otra operacin habitual de manipulacin de rboles binarios. Hay que tener en cuenta que esta operacin debe mantener la estructura del rbol y, por tanto, depender del orden que se haya establecido dentro del rbol. Esto hace que la eliminacin de nodos se pueda convertir en una operacin ms compleja y que no se pueda hablar de un algoritmo general de borrado, ms bien se podr hablar de algoritmos para borrar nodos para un determinado orden dentro del rbol. Si por ejemplo, un rbol ha sido generado teniendo en cuenta que sus nodos estn correctamente ordenados si se recorre el rbol en orden infijo, se debe considerar un algoritmo de borrado que no altere ese orden. La secuencia de orden a que da lugar el recorrido infijo se debe mantener al borrar cualquier nodo del rbol. Existen dos casos a considerar cuando se borra un nodo del rbol. El primer caso, el ms simple, implica borrar un nodo que tenga al menos un subrbol vaco. El segundo caso, ms complejo, aparece cuando se desea borrar un nodo cuyos dos subrboles son no vacos. En este ltimo caso, hay que tener en cuenta que el nodo borrado debe ser sustituido por otro nodo, de manera que se mantenga la estructura inicial del rbol. Cuando el nodo a borrar posee dos subrboles no vacos, el proceso de reestructuracin de las relaciones dentro del rbol resulta ms complejo, ya que cuando el nodo es terminal, eliminar ese nodo es tan simple como eliminar el enlace que le mantiene unido al rbol desde su nodo padre, y si el nodo posee un nico subrbol no vaco, el nodo debe ser sustituido por su nodo hijo. Estas dos ltimas situaciones no implican una reestructuracin importante del rbol. Suponiendo que el rbol debe mantener el orden establecido entre los nodos por un recorrido particular del mismo, el problema es determinar qu nodo debe sustituir al nodo que se va a borrar. Si volvemos al ejemplo anterior, el orden establecido por el recorrido infijo del rbol sera:
82
(In Orden) Si se desea borrar el nodo C, que tiene dos nodos hijos, el nodo que debera sustituirle sera el nodo G, ya que es su sucesor en el orden establecido por el recorrido infijo. En general, sea cul sea el orden establecido entre los nodos, el sustituto de un nodo que se va a borrar deber ser su sucesor en dicho orden. De esta manera se mantiene la estructura global del rbol. Los diferentes criterios de ordenacin de los nodos van a dar lugar a distintos algoritmos para determinar el sucesor de un nodo, segn el orden establecido, y para modificar los enlaces entre nodos. Hace falta especificar los algoritmos que permitirn encontrar el padre y el sucesor infijo de un nodo del rbol.
Representacin de rboles generales como rboles bi narios Vamos a ver en este apartado que cualquier rbol se puede representar como un rbol binario. Esto es importante porque resulta ms complejo manipular nodos de grado variable (nmero variable de relaciones) que nodos de grado fijo. Una posibilidad evidente de fijar un lmite en el nmero de relaciones sera seleccionar un nmero k de hijos para cada nodo, donde k es el grado mximo para un nodo del rbol. Sin embargo, esta solucin desaprovecha mucho espacio de memoria. Lema 4:para un rbol k-ario (es decir, de grado k) con n nodos, cada uno de tamao fijo, el nmero de enlaces nulos en el rbol es (n * (k-1) + 1) de los (n*k) campos de tipo enlace existentes.
Esto implica que para un rbol de grado 3, ms de 2/3 de los enlaces sern nulos. Y la proporcin de enlaces nulos se aproxima a 1 a medida que el grado del rbol aumenta. La importancia de poder utilizar rboles binarios para representar rboles generales reside en el hecho de que slo la mitad de los enlaces son nulos, adems de facilitar su manipulacin. Para representar cualquier rbol por un rbol binario, vamos a hacer uso implcito de que el orden de los hijos de un nodo en un rbol general no es importante. La razn por la cual, para representar un rbol general, se necesitaran nodos con muchos enlaces es que, hemos pensado en una representacin basada en la relacin padre-hijo dentro del rbol, y un nodo puede tener un gran nmero de hijos. Sin embargo, se puede encontrar una forma de representacin donde cada nodo slo necesite tener dos relaciones, una que lo una con el hijo que tenga ms a la izquierda y otra que lo una con el siguiente nodo hermano por la derecha. Estrictamente hablando, como el orden de los hijos en un rbol no es importante, cualquiera de los hijos de un nodo podra ser el hijo que est ms a la izquierda, el nodo padre y cualquiera de los nodos hermanos podra ser el siguiente hermano por la derecha. Por lo tanto, la eleccin de estos nodos no dejar de ser, hasta cierto punto, arbitraria. Podemos basarnos para esta eleccin en la representacin grfica del rbol que se desea almacenar. Veamos el siguiente ejemplo, el rbol binario correspondiente al rbol de la figura se obtiene conectando juntos todos los hermanos de un nodo y eliminando los enlaces de un nodo con sus hijos, excepto el enlace con el hijo que tiene ms a la izquierda.
83
Este tipo de representacin se puede identificar con los rboles binarios que ya hemos visto, asociando el enlace izquierdo del rbol con el enlace al hijo de la izquierda y el enlace derecho con el enlace al nodo hermano. Se observa que de esta manera el nodo raz nunca tendr un subrbol derecho, ya que no tiene ningn hermano. Pero esto nos permite representar un bosque de rboles generales como un nico rbol binario, obteniendo primero la transformacin binaria de cada rbol y despus uniendo todos los rboles binarios considerando que todos los nodos raz son hermanos. Ver el ejemplo de la figura:
En todas estas representaciones de rbol general a rbol binario hay que tener en cuenta la interpretacin que se deben hacer de las relaciones, no es lo mismo que un nodo est a la izquierda o a la derecha de otro, ya que los enlaces izquierdos unen un nodo con su hijo mientras que los enlaces derechos unen dos nodos hermanos. De cualquier forma, teniendo en cuenta este aspecto, es posible aplicar los algoritmos de manipulacin de rboles binarios que se han visto hasta ahora. De hecho, en todos estos algoritmos se diferenciaba claramente entre el tratamiento del subrbol izquierdo y el del subrbol derecho
84
ANEXOS
85
MATRIZ
#include<stdio.h> #include<iostream.h> #include<conio.h> #define fil 15 #define col 15 void ingresar(int matriz1[fil][col], int f1 ,int c1) { int i, j; for (i=1;i<=f1;i++) for(j=1;j<=c1;j++) { cout<<"ingrese valor para la posicion "<<i<<j<<" "; cin>>matriz1[i][j]; } } void imprimir(int matriz1[fil][col], int f1 ,int c1) {int i,j; for(i=1;i<=f1;i++) { for(j=1;j<=c1;j++) { cout<<matriz1[i][j]<<'\t'; } cout<<endl; } } void limite(int &f,int &c) { do {cout<<"ingrese el limite de fila "; cin>>f; }while(f<0&&f>fil); do {cout<<"ingrese el limite columna "; cin>>c; }while(c<0&&c>col); } void restar(int matriz1[fil][col],int matriz2[fil][col],int mresta[fil][col],int f,int c) { int i,j; for(i=1;i<=f;i++) for(j=1;j<=c;j++) mresta[i][j]=matriz1[i][j]-matriz2[i][j]; } void sumar(int matriz1[fil][col],int matriz2[fil][col],int msuma[fil][col],int f,int c) { int i,j; for(i=1;i<=f;i++) for(j=1;j<=c;j++) msuma[i][j]=matriz1[i][j]+matriz2[i][j]; } void multiplicar(int matriz1[fil][col],int matriz2[fil][col],int mat_pro[fil][col],int f,int f1,int c1) { int i,aux,j,k,produc,suma; for(i=1;i<=f;i++) { for(j=1;j<=c1;j++) { aux=0;
86

for(k=1;k<=f1;k++) { produc=matriz1[i][k]*matriz2[k][j]; aux+=produc; } mat_pro[i][j]=aux; } } } void main () { clrscr(); int matriz1[fil][col],matriz2[fil][col]; int msuma[fil][col],mresta[fil][col]; int matmul[fil][col]; int f,c,f2,c2,opcion,llena=0; limite(f,c); limite(f2,c2); do { if(llena==1) { cout<<"MATRICES"; cout<<endl; imprimir(matriz1,f,c); cout<<endl; cout<<endl; imprimir(matriz2,f2,c2); getch(); } do { gotoxy(15,8);cout<<"1)INGRESE MATRICES "; gotoxy(15,9);cout<<"2)SUMA MATRICES "; gotoxy(15,10);cout<<"3)RESTA MATRICES"; gotoxy(15,11);cout<<"4)MULTIPLICA MATRICES"; gotoxy(15,12);cout<<"5)SALIR"; gotoxy(15,13);cout<<"Digite la opcion :"; gotoxy(30,14);cin>>opcion; }while(opcion<0||opcion>5); switch(opcion) { case 1: { clrscr(); limite(f,c); cout<<"Datos para la primera matriz"<<endl; ingresar(matriz1,f,c); limite(f2,c2); cout<<"Datos para la segunda matriz"<<endl; ingresar(matriz2,f2,c2); llena=1; getch(); clrscr(); break; } case 2: { clrscr(); if(f==f2&&c==c2) { Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
87

if(llena==1) {sumar(matriz1,matriz2,msuma,f,c); cout<<"Suma :"<<endl; imprimir(msuma,f,c); } else { cout<<"Datos para la primera matriz"<<endl; ingresar(matriz1,f,c); cout<<"Datos para la segunda matriz"<<endl; ingresar(matriz2,f2,c2); clrscr(); sumar(matriz1,matriz2,msuma,f,c); cout<<"Suma :"<<endl; imprimir(msuma,f,c); llena=1; } } else cout<<"No se pueden sumar"; getch(); clrscr(); break; } case 3: { clrscr(); if(f==f2&&c==c2) { if(llena==1) {restar(matriz1,matriz2,mresta,f,c); cout<<"Resta :"<<endl; imprimir(mresta,f,c); } else { cout<<"Datos para la primera matriz"<<endl; ingresar(matriz1,f,c); cout<<"Datos para la segunda matriz"<<endl; ingresar(matriz2,f2,c2); clrscr(); restar(matriz1,matriz2,mresta,f,c); cout<<"Resta:"<<endl; imprimir(mresta,f,c); llena=1; } } else cout<<"No se pueden restar"; getch(); clrscr(); break; } case 4: { clrscr(); if(c==f2) {if(llena==1) { multiplicar(matriz1,matriz2,matmul,f,f2,c2); cout<<"Multiplicacion:"<<endl;
88

imprimir(matmul,f,c2); } else { cout<<"Datos para la primera matriz"<<endl; ingresar(matriz1,f,c); cout<<"Datos para la segunda matriz"<<endl; ingresar(matriz2,f2,c2); clrscr(); multiplicar(matriz1,matriz2,matmul,f,f2,c2); cout<<"Multiplicacion:"<<endl; imprimir(matmul,f,c); llena=1; } } else cout<<"No se pueden multiplicar"; getch(); clrscr(); break; } case 5: break; } }while(opcion!=5); getch(); }
89
LISTA ABIERTA #include<conio.h> #include<stdio.h> #include<iostream.h> #include<stdlib.h> typedef struct nodo {int valor; struct nodo * siguiente; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo *Lista; // Funciones Prototipos int ListaVacia(Lista l); void Insertar(Lista *l,int v); void InsertarC(Lista *l,int v); void InsertarF(Lista *l,int v); void Borrar(Lista *l,int v); void BorrarLista(Lista *l); void MostrarLista(Lista l); void main() {clrscr(); Lista lista=NULL; pNodo p; InsertarF (&lista,20); InsertarF (&lista,10); InsertarF (&lista,40); InsertarF (&lista,30); MostrarLista(lista); getch();//sytem("PAUSE"); } int ListaVacia(Lista lista) {return(lista==NULL); } void Insertar(Lista *lista, int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->valor=v; if(ListaVacia(*lista)||(*lista)->valor>v){ nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente && anterior->valor <=v) anterior=anterior->siguiente; nuevo->siguiente=anterior->siguiente; anterior->siguiente=nuevo; } } void InsertarC(Lista *lista, int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->valor=v; nuevo->siguiente=*lista; *lista=nuevo; } void InsertarF(Lista *lista, int v)
90

{pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->valor=v; if(ListaVacia(*lista)){ nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente!=NULL) anterior=anterior->siguiente; anterior->siguiente=nuevo; nuevo->siguiente=NULL; } } void MostrarLista(Lista lista) {pNodo nodo=lista; if(ListaVacia(lista)) printf("Lista vacia \n"); else{ while(nodo) { printf("%d-> ",nodo->valor); nodo=nodo->siguiente; } } }
91

Insertar datos al Inicio de una lista, al final , y de forma ordenada en una lista abierta Borrar datos de una lista abierta uno o toda la lista. Mostrar una lista
Propuesta: Construir una funcin para poder insertar un nuevo elemento a la lista antes de un elemento determinado Construir una funcin para poder insertar un nuevo elemento a la lista despus de un elemento determinado
#include<conio.h> #include<stdio.h> #include<iostream.h> #include<stdlib.h> #include<string.h> #include<stdlib.h> typedef struct nodo {int codigo; char nombre[30]; float sueldo; struct nodo * siguiente; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo *Lista; // Funciones Prototipos int ListaVacia(Lista l); void Insertar(Lista *l,int v); // insertar al inicio o cabecera de la lsiat void InsertarC(Lista *l,int v); // insertar al inico de una lista void InsertarF(Lista *l,int v); // insertar al final de una lista void Borrar(Lista *l,int v); // borrar un elemento de la lista void BorrarLista(Lista *l); // borrar toda las lista void MostrarLista(Lista l); void main() {clrscr(); Lista lista=NULL; pNodo p; InsertarC (&lista,1); InsertarC (&lista,2); InsertarC (&lista,4); InsertarC (&lista,3); MostrarLista(lista); getch(); system("PAUSE"); } int ListaVacia(Lista lista) {return(lista==NULL); } void Insertar(Lista *lista,int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->codigo=v; printf("Ingrese Nombre del Empleado :"); scanf("%s",&nuevo->nombre); printf("Ingrese el sueldo :"); scanf("%f",&nuevo->sueldo); if(ListaVacia(*lista)||(*lista)->codigo>v){
92

nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente && anterior->codigo <=v) anterior=anterior->siguiente; nuevo->siguiente=anterior->siguiente; anterior->siguiente=nuevo; } } void InsertarC(Lista *lista,int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->codigo=v; printf("Ingrese Nombre del Empleado :"); cin>>nuevo->nombre; printf("Ingrese el sueldo :"); cin>>nuevo->sueldo; nuevo->siguiente=*lista; *lista=nuevo; } void InsertarF(Lista *lista,int v) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->codigo=v; printf("Ingrese Nombre del Empleado :"); scanf("%s",&nuevo->nombre); printf("Ingrese el sueldo :"); scanf("%f",&nuevo->sueldo); if(ListaVacia(*lista)){ nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente!=NULL) anterior=anterior->siguiente; anterior->siguiente=nuevo; nuevo->siguiente=NULL; } } void MostrarLista(Lista lista) {pNodo nodo=lista;
if(ListaVacia(lista)) printf("Lista vacia \n"); else{ printf("\nCODIGO EMPLEADO SUELDO\n"); while(nodo) { printf("%d \t %s \t %3.1f \n ",nodo->codigo,nodo->nombre,nodo->sueldo); nodo=nodo->siguiente; } } }
93
Implementaciones de Funciones para manipular: Listas Abiertas y Pilas Usando cadenas de caracteres
#include<stdlib.h> #include<iostream.h> #include<conio.h> #include<stdio.h> #include<string.h> typedef struct nodo {char nombre[40]; char apellido[30]; char fono[25]; int edad; struct nodo * sig; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo * Pila; typedef tipoNodo *Lista; char n[40], ap[40], fo[40]; void InsertarPila(Pila *pila, char n[],char ap[],char fo[], int v) {pNodo nuevo; nuevo=(pNodo)malloc(sizeof(tipoNodo)); strcpy(nuevo->nombre,n); strcpy(nuevo->apellido,ap); strcpy(nuevo->fono,fo); nuevo->edad=v; nuevo->sig=*pila; *pila=nuevo; } int Pop(Pila *pila, char n[],char ap[],char fo[]) {pNodo nodo=*pila; int v=0; if(!nodo) cout<< "Pila Vacias...\n"; else {*pila=nodo->sig; strcpy(n,nodo->nombre); strcpy(ap,nodo->apellido); strcpy(fo,nodo->fono); v=nodo->edad; free(nodo); } return v; } ESTRUCTURA DE DATOS I -- FCI void MostrarPila(Pila pila) {pNodo nodo=pila; int c; while(nodo) {c=Pop(&nodo,n,ap,fo); cout<<n<<"\t\t"<<ap<<"\t"<<fo<<"\t\t"<<c<<"\n"; } } void InsertarC(Lista *lista, char n[],char ap[],char fo[], int v) {pNodo nuevo;
94

nuevo=(pNodo)malloc(sizeof(tipoNodo)); strcpy(nuevo->nombre,n); strcpy(nuevo->apellido,ap); strcpy(nuevo->fono,fo); nuevo->edad=v; nuevo->sig=*lista; *lista=nuevo; }
void MostrarLista(Lista lista) { pNodo nodo=lista; if(!lista) printf("Lista vacia \n"); else while(nodo) { cout<<nodo->nombre<<"\t"<<nodo->apellido<<"\t"<<nodo->fono<<"\t"<<nodo->edad<<"\n"; nodo=nodo->sig; } } void introducirDespues(Lista *lista,char cl[],char no[],char ap[],char fo[],int dd) {pNodo nuevo, aux=*lista; while (aux && strcmp(aux->nombre,cl)!=0) aux=aux->sig; if (aux && strcmp(aux->nombre,cl)==0) { nuevo=(pNodo)malloc(sizeof(tipoNodo)); strcpy(nuevo->nombre,no); strcpy(nuevo->apellido,ap); strcpy(nuevo->fono,fo); nuevo->edad=dd; nuevo->sig=aux->sig; aux->sig=nuevo; } else cout <<"no se inserto... dato"<<cl<<" no encontrado\n"; } void introducirAntes(Lista *lista,char cl[],char no[],char ap[],char fo[],int dd) {pNodo nuevo, aux=*lista; nuevo=(pNodo)malloc(sizeof(tipoNodo)); strcpy(nuevo->nombre,no); strcpy(nuevo->apellido,ap); strcpy(nuevo->fono,fo); nuevo->edad=dd; if (strcmp(aux->nombre,cl)==0) {nuevo->sig=*lista; *lista=nuevo; } else { while (aux && strcmp(aux->sig->nombre,cl)!=0) aux=aux->sig; if (aux && strcmp(aux->sig->nombre,cl)==0) { nuevo->sig=aux->sig; aux->sig=nuevo; } else cout <<"no se inserto... dato"<<cl<<" no encontrado\n"; } } void eliminar(Lista *lista,char cl[]) {pNodo aux=*lista; Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
95
if (strcmp(aux->nombre,cl)==0) { *lista=(*lista)->sig; } else { while (aux && strcmp(aux->sig->nombre,cl)!=0) aux=aux->sig; if (aux && strcmp(aux->sig->nombre,cl)==0) aux->sig=aux->sig->sig; else cout <<"no se borro... dato"<<cl<<" no encontrado\n"; } } void main() {clrscr(); Lista lista=NULL; Pila pila=NULL; int op=2; if (op==1) {cout<<"\n***OPERACIONES CON LA LISTA ABIERTA***\n"; InsertarC (&lista,"Mariela","Martinez","236421",22); InsertarC (&lista,"Julio","Guillen","2012514",10); InsertarC (&lista,"Gladis","Alvarado","23025",40); InsertarC (&lista,"Ximena","Laz","223025",21); InsertarC (&lista,"Marcos","Kon","246920",30); MostrarLista(lista); getch(); cout<<"\nLISTA CON UN NUEVO DATO INCLUIDO ANTES DE XIMENA***\n"; introducirAntes(&lista,"Ximena","NEGRO","LAMPARK","12354",30); MostrarLista(lista); } else if (op==2) { cout<<"\n***operaciones con pila invertida***\n"; InsertarPila (&pila,"Mariela","Martinez","236421",22); InsertarPila (&pila,"Julio","Guillen","2012514",10); InsertarPila (&pila,"Gladis","Alvarado","223025",40); InsertarPila (&pila,"Ximena","Laz","223025",21); InsertarPila (&pila,"Marcos","Kon","246920",30); cout<<"\nPIla Original\n" ; MostrarPila(pila); getch(); InvertirPila(pila); }else { cout<<"\n***Error***\n"; getch(); } }
96
REGISTRO DE PACIENTES USANDO LISTAS ABIERTAS

#include<string.h> #include<conio.h> #include<stdio.h> #include<iostream.h> #include<stdlib.h> typedef struct nodo {int historia; char nombre[45]; double cedula; int edad; char direccion[40]; char sexo[15]; struct nodo * siguiente; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo *Lista; // Funciones Prototipos int ListaVacia(Lista l); void InsertarC(Lista *l,int hc,char n[],double c,int e,char d[],char s[]); void InsertarF(Lista *l,int hc,char n[],double c,int e,char d[],char s[]); void InsertarO(Lista *l,int hc,char n[],double c,int e,char d[],char s[]); void Crea_NLista(Lista l1,Lista *l2); void Borrar(Lista *l,int hc); void BorrarLista(Lista *l); void MostrarLista(Lista l); void main() {clrscr(); Lista lista=NULL, lista2=NULL; pNodo p; char n[45], d[40] ,s[15]; int i,h, e; double c; for(i=0;i<5;i++) { cout<<"\n Ingrese un numero de historia clinica :"; cin>> h; cout<<"\n Ingrese los nombres del paciente :"; gets(n); cout<<"\n Ingrese la cedula del paciente :"; cin>>c; cout<<"\n Ingrese la edad del paciente :"; cin>> e; cout<<"\n Ingrese la direccion del paciente :"; gets(d); cout<<"\n Ingrese el sexo del paciente :"; cin>>s; InsertarC (&lista,h,n,c,e,d,s); } clrscr(); cout<<" Lista Inicial \n"; MostrarLista(lista); getch(); //Generar la nueva lista Crea_NLista(lista,&lista2); cout<<"\n NUEVA LISTA \n"; MostrarLista(lista2); getch(); } int ListaVacia(Lista lista) {return(lista==NULL); } void InsertarC(Lista *lista, int hc, char n[],double c,int e,char d[],char s[]) {pNodo nuevo; Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres
97

nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->historia=hc; strcpy(nuevo->nombre,n); nuevo->cedula=c; nuevo->edad=e; strcpy(nuevo->direccion,d); strcpy(nuevo->sexo,s); nuevo->siguiente=*lista; *lista=nuevo; }
void InsertarF(Lista *lista, int hc, char n[],double c,int e,char d[],char s[]) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->historia=hc; strcpy(nuevo->nombre,n); nuevo->cedula=c; nuevo->edad=e; strcpy(nuevo->direccion,d); strcpy(nuevo->sexo,s); if(ListaVacia(*lista)){ nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente!=NULL) anterior=anterior->siguiente; anterior->siguiente=nuevo; nuevo->siguiente=NULL; } } void InsertarO(Lista *lista, int hc, char n[],double c,int e,char d[],char s[]) {pNodo nuevo, anterior; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->historia=hc; strcpy(nuevo->nombre,n); nuevo->cedula=c; nuevo->edad=e; strcpy(nuevo->direccion,d); strcpy(nuevo->sexo,s); if(ListaVacia(*lista)||(*lista)->historia>hc){ nuevo->siguiente=*lista; *lista=nuevo; } else {anterior=*lista; while(anterior->siguiente && anterior->historia <=hc) anterior=anterior->siguiente; nuevo->siguiente=anterior->siguiente; anterior->siguiente=nuevo; } } void Crea_NLista(Lista l1,Lista *l2) {pNodo nodo=l1; if(ListaVacia(l1)) printf("Lista vacia...No se genero la otra lista \n"); while(nodo) {if (nodo->edad <20 )
98
{ //Utilizamos cualquierra de las funciones para insertar el nodo en la nueva lista InsertarF(l2,nodo->historia,nodo->nombre,nodo->cedula,nodo->edad,nodo->direccion,nodo->sexo); } nodo=nodo->siguiente; } } void MostrarLista(Lista lista) {pNodo nodo=lista; if(ListaVacia(lista)) printf("Lista vacia \n"); else{ cout<<"\n Hist. Clinc Paciente Cedula Edad Direccion Sexo\n"; while(nodo) { cout<<" "<< nodo->historia<<" \t " << nodo->nombre<<" \t " <<nodo->cedula<<" \t " <<nodo>edad<<" \t " <<nodo->direccion<<" \t " <<nodo->sexo<<"\n"; nodo=nodo->siguiente; } } }
99
Manejo de Arboles
#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<math.h> #include<ctype.h> #include<string.h> #include<graphics.h> #include "interface.h" #include "arbol.h"
void main(void){ int gdriver = DETECT, gmode; int elemento, valor, opcion, i; char *dato; NODOARBOL *raiz=NULL; clrscr();
for(;;){ nuevo: valor=0; opcion=menu(); if((opcion>=8 && opcion<=16) && raiz==NULL){ window(52,8,80,12); textattr(YELLOW + BLINK); textbackground(BLACK); cprintf("\n\r n\r No hay nodos \n\r en el rbol "); window(1,1,80,25); ESTRUCTURA DE DATOS I -- FCI getch(); continue; }
switch(opcion){ case 6: clrscr(); printf("\nIngrese elemento a insertar [0 : 99]: "); gets(dato);
100

for(i=0;i<strlen(dato);i++)
if(!isdigit(dato[i])){ printf("\nDato inv lido"); getch(); goto nuevo;} elemento=atoi(dato); if(elemento<0 || elemento>99){ printf("\nDato desbordado"); getch(); break;} insertar(&raiz, elemento); break;
case 8: clrscr(); printf("\nIngrese elemento a eliminar [0 : 99]: "); gets(dato); for(i=0;i<strlen(dato);i++) if(!isdigit(dato[i])){ printf("\nDato inv lido"); getch(); goto nuevo;} elemento=atoi(dato); if(elemento<0 || elemento>99){ printf("\nDato desbordado"); getch(); break;} buscar(raiz, elemento, &valor); if(valor==1){ raiz=eliminar( raiz, elemento); printf("\nNodo eliminado\n"); getch(); } break;
case 10: clrscr(); printf("El rbol inorder es: "); inorder(raiz); getch(); break;
case 12: clrscr(); printf("El rbol preorder es: "); preorder(raiz); getch(); break; ESTRUCTURADE DATOS I -- FCI
case 14: clrscr(); printf("El rbol postorder es: "); postorder(raiz);
101

getch(); break;
case 16: clrscr(); initgraph(&gdriver, &gmode, "c:\\borlandc\\bgi"); dibujar(raiz, 15, 3, 7, 0); getch(); cleardevice(); closegraph(); break; case 18: exit(0); } } } /****************************************************************/ /* ARBOLES.H */
/****************************************************************/
typedef struct nodo{ int dato; struct nodo *izq; struct nodo *der; } NODOARBOL;
void insertar(NODOARBOL **cabeza, int elemento){
if(*cabeza==NULL){ ESTRUCTURA DE DATOS I -- FCI *cabeza= (NODOARBOL *) malloc(sizeof(NODOARBOL));
if(*cabeza==NULL){ printf("No hay memoria\n"); return; }
(*cabeza)->dato=elemento;
102

(*cabeza)->izq=NULL; (*cabeza)->der=NULL; }
else if(elemento< (*cabeza)->dato) insertar(& (*cabeza)->izq, elemento);
else if(elemento> (*cabeza)->dato) insertar(& (*cabeza)->der, elemento);
else{ printf("\nNo puede insertar: valor duplicado\n\n"); getch(); } }
void inorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ inorder(cabeza->izq); printf("%d ",cabeza->dato); inorder(cabeza->der); } }
void preorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ printf("%d ", cabeza->dato); preorder(cabeza->izq); preorder(cabeza->der); } } ESTRUCTURADE DATOS I -- FCI
void postorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ postorder(cabeza->izq); postorder(cabeza->der); printf("%d ",cabeza->dato); } }
103
void buscar(NODOARBOL *cabeza, int elemento, int *valor){ if(cabeza!=NULL){ if((cabeza)->dato==elemento) *valor=1;
else{ if(elemento<(cabeza)->dato) buscar((cabeza)->izq, elemento, valor);
else buscar((cabeza)->der, elemento, valor); } } else{ printf("\nDato no encontrado\n"); getch(); } }
NODOARBOL *eliminar(NODOARBOL *cabeza, int elemento){ NODOARBOL *p1, *p2; if(elemento==cabeza->dato){ if(cabeza->izq==cabeza->der){ free(cabeza); return(NULL); } else if(cabeza->izq==NULL){ p1=cabeza->der; free(cabeza); return(p1); } else if(cabeza->der==NULL){ ESTRUCTURA DE DATOS I -- FCI p1=cabeza->izq; free(cabeza); return(p1); } else{ p2=cabeza->der; p1=cabeza->der; while(p1->izq) p1=p1->izq;
104

p1->izq=cabeza->izq; free(cabeza); return(p2); } }
if(cabeza->dato<elemento) cabeza->der=eliminar(cabeza->der, elemento); else cabeza->izq=eliminar(cabeza->izq, elemento); return(cabeza); }
void dibujar(NODOARBOL *cabeza, int a, int b, int c, int d){ char value[3]; if(cabeza!=NULL){ itoa(cabeza->dato,value,10); circle(300+a,75+b,14); setcolor(YELLOW); outtextxy(295+a,75+b,value); setcolor(WHITE);
if(d==1) line(300+a+pow(2,c+1),b+14,300+a,61+b); else if(d==2) line(300+a-pow(2,c+1),b+14,300+a,61+b);
dibujar(cabeza->izq,a-pow(2,c)-pow(2,d-4),b+75,c-1,1); dibujar(cabeza->der,a+pow(2,c)+pow(2,d-4),b+75,c-1,2);} }
105
/****************************************************************/ /* INTERFACE.H */
/****************************************************************/ int menu(void); int acerca_de(void); void poner_recuadro(void); void barra(void); /****************************************************************/ /* MENU PRINCIPAL */
/****************************************************************/ int menu(){ int pos=6; char aux; poner_recuadro(); for( ; ; ){ switch(pos){ case 6 : gotoxy(28,pos); textcolor(YELLOW); textbackground(BLACK); cprintf(" Insertar aux=getch(); textcolor(15); textbackground(4); gotoxy(28,pos); cprintf(" Insertar break; case 8 : gotoxy(28,pos); textcolor(YELLOW); ESTRUCTURA DE DATOS I -- FCI textbackground(BLACK); cprintf(" Eliminar aux=getch(); textcolor(15); textbackground(4); gotoxy(28,pos); cprintf(" Eliminar break; "); "); "); ");
106

case 10 : gotoxy(28,pos); textcolor(YELLOW); textbackground(BLACK); cprintf(" Inorder aux=getch(); textcolor(15); textbackground(4); gotoxy(28,pos); cprintf(" Inorder break; case 12 : gotoxy(28,pos); textcolor(YELLOW); textbackground(BLACK); cprintf(" Preorder aux=getch(); textcolor(15); textbackground(4); gotoxy(28,pos); cprintf(" Preorder break; case 14 : gotoxy(28,pos); textcolor(YELLOW); textbackground(BLACK); cprintf(" Postorder aux=getch(); textcolor(15); textbackground(4); gotoxy(28,pos); cprintf(" Postorder break; case 16 : gotoxy(28,pos); textcolor(YELLOW); textbackground(BLACK); cprintf(" Graficar aux=getch(); textcolor(15); "); "); "); "); "); "); ");
107

textbackground(4); gotoxy(28,pos); cprintf(" Graficar break; case 18 : gotoxy(28,pos); textcolor(YELLOW); textbackground(BLACK); cprintf(" Salir aux=getch(); textcolor(15); textbackground(4); gotoxy(28,pos); cprintf(" Salir break; } switch(aux){ case 0x48 : pos=pos-2; if(pos==4) pos=18; break; case 0x50 : pos=pos+2; if(pos==17) pos=3; break; case 0x0d : return pos; case 0x44 : exit(0); case 0x3b : break; case 0x3c : acerca_de(); } } ESTRUCTURA DE DATOS I -- FCI } "); "); ");
/****************************************************************/ /* ACERCA DE ... */
/****************************************************************/
int acerca_de(void){ window(10,6,70,18); textcolor(BLACK);
108

textbackground(WHITE); clrscr(); cprintf("\n\r cprintf("\n\n\r cprintf(" cprintf(" cprintf(" cprintf(" ESCUELA POLIT CNICA NACIONAL");
CARRERA DE INGENIERA DE SISTEMAS\n\r\n\r"); PROGRAMACIN II\n\r\n\r"); Autor: Adri n Fernando Vaca C rdenas\n\r"); Curso: GR1\n\r\n\r"); Semestre: Octubre/2000 - Marzo/2001\n\r");
window(1,1,80,25); getch(); poner_recuadro(); return(0); } /****************************************************************/ /* PONER RECUADRO */
/****************************************************************/ void poner_recuadro(void){ int i; textbackground(6); clrscr(); clrscr(); textcolor(BLACK); textbackground(CYAN); gotoxy(23,4); cprintf("****** Men Principal ******"); for(i=0;i<16;i++){ gotoxy(23,i+5); textbackground(CYAN); cprintf("* } gotoxy(23,20); cprintf("******* Arboles 1.0 ********"); textcolor(WHITE); textbackground(RED); gotoxy(28,6); cprintf(" Insertar "); *"); ESTRUCTURADE DATOS I -- FCI
109

gotoxy(28,8); cprintf(" Eliminar gotoxy(28,10); cprintf(" Inorder gotoxy(28,12); cprintf(" Preorder gotoxy(28,14); cprintf(" Postorder gotoxy(28,16); cprintf(" Graficar gotoxy(28,18); cprintf(" Salir barra(); } "); "); "); "); "); ");
/****************************************************************/ /* BARRA INFERIOR */
/****************************************************************/ void barra(void){ gotoxy(1,25); textattr(WHITE); textbackground(BLUE); cprintf(" F2 -> ACERCA DE ... F10 -> SALIR ");
gotoxy(49,25); textcolor(WHITE); cprintf(" ARBOL 1.0 (C)opyright 2000");
gotoxy(1,1); textcolor(WHITE); textbackground(RED); ESTRUCTURA DE DATOS I -- FCI cprintf(" Utilize las flechas del cursor para desplazarse."); gotoxy(50,1); textcolor(WHITE); cprintf(" Enter para aceptar su opcin."); }
110
UNIVERSIDAD TECNICA DE MANABI

CIENCIAS INFORMATICAS APORTE DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero __ PARCIAL: Primero FECHA: PROFESOR: Ing. ______________ La empresa elctrica Emelmanabi desea mejorar su servicio a los usuarios, Se esta pensando usar una lista abierta, en la cual se pueda almacenar la siguiente informacin sobre los clientes: Ruta ( entero) Secuencia(entero) n_medidor(entero) propietario(cadena) direccin (cadena) Se solicita Implementar: 1. Una funcin para insertar los datos digitados en la lista abierta de forma ordenada con respecto al n_medidor. 2. Una funcin para Mostar la lista abierta. 3. Una funcin que permita Eliminar datos especficos de un X n_medidor de la lista abierta. 4. Crear la estructura del nodo, implemente el programa principal, y registre 20 clientes.

CIENCIAS INFORMATICAS APORTE DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero __ FECHA: PARCIAL: Primero PROFESOR: Ing. _______________
La empresa elctrica Emelmanabi desea mejorar su servicio a los usuarios, Se esta pensando usar una lista abierta, en la cual se pueda almacenar la siguiente informacin sobre los clientes: Ruta ( entero) Secuencia(entero) n_medidor(entero) propietario(cadena) direccin (cadena) Se solicita Implementar: 1. 2. 3. 4. Una funcin para insertar los datos digitados al final de la lista abierta. Una funcin para Mostar la lista abierta. Una funcin que permita ordenar los datos de la lista abierta. Crear la estructura del nodo, implemente el programa principal, y registre 20 clientes.

CIENCIAS INFORMATICAS APORTE DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero ________ PARCIAL: Primero FECHA: PROFESOR: Ing. __________ La empresa elctrica Emelmanabi desea mejorar su servicio a los usuarios, Se esta pensando usar una lista abierta, en la cual se pueda almacenar la siguiente informacin sobre los clientes: Ruta ( entero) Secuencia(entero) n_medidor(entero) propietario(cadena) direccin (cadena) Se solicita Implementar: 1. Una funcin para insertar los datos digitados al inicio de la lista abierta. 2. Una funcin para Mostar la lista abierta. 3. Una funcin que permita insertar a la lista abierta un nuevo cliente y poderlo ingresar justo antes del medidor numero 20. 4. Crear la estructura del nodo, implemente el programa principal, y registre 20 clientes.
111

CIENCIAS INFORMATICAS EXAMEN DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero C FECHA: jueves 9 de agosto del 2007 PARCIAL: Segundo PROFESOR: Ing. Christian Torres
1. Con el siguiente recorrido en In Orden llenar el siguiente rbol, y responder las siguientes incgnitas Recorrido en In Orden D-E-C-G-F-H-I-B-J-K-M-L-A-N-Q-R-P a) Grado : _________ b) Altura:_________ c) Nodos Ramas:____________________ d) Nodo Raz: ____________
2. Escriba una funcin recursiva que permita calcular el factorial de un nmero cualquiera.
3. Disee una estructura que permita almacenar los nombres y las notas de los estudiantes de un curso (N1 y N2), para poder ser almacenados en una lista doblemente enlazada, los estudiantes que sumado las 2 notas completaran 14 puntos o mas, debern ser almacenados en una pila, sus nombres y promedio (N1 + N2) y de la lista doblemente enlazados debern ser. Finalmente imprima la lista y luego la pila. Implemente las funciones necesarias Recuerde que los datos que pasan a la pila no deben quedarse en la lista. Manual de Estructura de Datos
112

CIENCIAS INFORMATICAS APORTE DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero __ FECHA: ____________________ PARCIAL: Segundo PROFESOR: Ing. _______________
1.- Dado el siguiente rbol encuentre: (2.5pts.)
a) Numero de Hojas_______________________ b) Nodos Hojas __________________________ c) Nodo Raz ____________________________ d) Nodos Ramas__________________________ e) Profundidad___________________________ f) Altura________________________________ D g) Grado________________________________ h) Recorrido en In Orden____________________ i) Recorrido en Post Orden __________________ j) Recorrido en Pre Orden ___________________ H E G I C F J B
K Q L M R
2) Escriba la estructura de una lista doblemente enlazada e implemente una funcin para Ingresar la informacin (usted elija la informacin que maneja la estructura) (2.0)
3) Asumir que a usted la entregan un rbol lleno de datos y una lista circular (lista cerrada) (5.5pts)
Y se desea hacer una comparacin de los datos que estn en el rbol con los que estn en la lista cerradas, para generar una pila que almacene los datos del rbol que no estn en la lista cerrada, y finalmente imprimir los datos de la lista y los de la pila generada. La informacin que maneja tanto el rbol como la lista cerrada es un nmero entero. Cree las funciones: generar la pila imprimir lista, y imprimir pila
113
Universidad Tcnica de Manab Facultad de Ciencias Informticas

Aporte 2 de Estructura de Datos I
Nombre:____________________________________________________________________ Semestre: 3ero __ Fecha: ________________ 1) Del siguiente rbol calcule: a. Grado______ b. Nodo hijo__________________________________ c. Nodos Hojas________________________________ d. Nodos Rama_________________________________ e. Nivel del nodo E_______ f. Orden_______ g. Altura del rbol___________
2) Escriba cual sera la forma de recorrer el siguiente rbol de acuerdo a su recorrido: a. In Orden_____________________________________________ b. Post Orden___________________________________________ c. Nivel del rbol:_______
3) Recorra el siguiente rbol en : a. Pre Orden____________________________________________ b. Post Orden___________________________________________ c. Nodos Ramas:_____________________________________ *

/ + G
+ 4) Con los siguientes Datos construya un rbol binario 83 - 69 13 2 - 8 56 - 21 - 34 A B C
114

CIENCIAS INFORMATICAS EXAMEN DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero __ FECHA: ___________________ PARCIAL: Primero PROFESOR: Ing. _____________________
Se desea implementar un sistema para la Clnica San Antonio, el cual utilice listas abiertas. El mismo deber almacenar la siguiente informacin sobre los pacientes: historia_clinica, nombres, cedula, edad, direccin, sexo Se solicita Implementar: 1. Defina el tipo de dato para cada campo y cree la estructura del nodo, para que pueda almacenar 100 pacientes. (1.0 pts) 2. Cree una funcin para insertar los datos digitados en la lista abierta de forma ordenada con respecto al historia_clinica. (1.0pts) 3. Cree una funcin que llene otra lista con los datos de los pacientes que tengan menos de 20 aos. Por ejemplo (1.5pts)
LISTA INGRESADA
001 CARLOS MATA 1305642153 28 CALDERON MASCULINO 002 MERCEDES SOTO 1314264303 18 PORTOVIEJO FEMENINO 003 AMARILIS ZAMORA 1312526241 15 PORTOVIEJO FEMENINO 004 XAVIER PLUA 1301114302 20 PORTOVIEJO MASCULINO 005 MERCEDES SOTO 1312023421 19 PORTOVIEJO FEMENINO
LISTA QUE SE GENERARIA

002 MERCEDES SOTO 1314264303 18 PORTOVIEJO FEMENINO 003 AMARILIS ZAMORA 1312526241 15 PORTOVIEJO FEMENINO
4. Una funcin para Mostar la lista abierta creada. (0.5pts) 5. Implemente el programa principal, pueda registrar pacientes, mostrarlos y eliminar. (1.0pts) Nota: Mostar la lista cuando sufra cambios y tambin la nueva lista generada con los menores a 20 aos.
005 MERCEDES SOTO 1312023421 19 PORTOVIEJO FEMENINO
115

CIENCIAS INFORMATICAS
PERIODO SEPTIEMBRE 2007 MARZO 2008
EXAMEN DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero _______ FECHA: ____________________ PARCIAL: Primero PROFESOR: Ing. ___________________________
Se tiene una lista abierta con los campos: int codigo: char nombre[35]; float sueldo; 1) Implemente una funcin para pasar los datos de la lista a una pila 2) Eliminar a los empleados que tienen sueldo menor a $ 125 3) Ingrese un nuevo nodo, pero justo antes del codigo=150. 2) Escriba la funcin que utilice una cola con elementos (solo dos campos: valor y siguiente) y que pueda pasar estos datos a una lista abierta de forma ordenada
3) En el siguiente procedimiento llamado examen UD deber identificar grficamente lo que realiza este procedimiento, cual seria el verdadero nombre de este procedimiento y para que servira este procedimiento void EXAMEN(Nuevo_dato *va, int v) {pNodo nodo; nodo=*va; do{ if ((*va)->siguiente->valor !=v) *va=(*va)->siguiente; }while (*va)-siguiente->valor!=v && *va!=nodo); If((*va)->siguiente->valor==v) If (*va==(*va)->siguiente{ free(*va); *va=NULL; } else {nodo=(*va)->siguiente; (*va)->siguiente=nodo->siguiente; } } }
116

CIENCIAS INFORMATICAS EXAMEN DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero __ FECHA: _______________________ PARCIAL: Segundo PROFESOR: Ing. ________________
4. Construya un rbol binario a partir del siguiente rbol 1.00pts
valor:
5. De su respuesta en la pregunta anterior: valor: 1.00pts a. Realizar el recorrido en Post Orden. b. Grado : _________ c. Altura:_________ 6. Disee una estructura que permita almacenar los nombres y las notas de los estudiantes de un curso (N1 y N2), para poder ser almacenados en una lista doblemente enlazada. Funciones a crear:
Ingreso de datos a la lista doble valor: 0.75pts Cree una funcin que escriba la observacin del estudiante junto a su nombre en una lista simple; es decir, los estudiantes que sumado las 2 notas completaran 14 puntos o mas Aprueba y los menores a 14 Reprueba. valor: 1.00pts Esto significara que debe usar dos estructuras valor: valor: 0.25pts
.Finalmente imprima la lista doble y luego la lista simple. 1.00pts Llamado a las funciones(Programa principal) Implemente las funciones necesarias
117

CIENCIAS INFORMATICAS EXAMEN DE RECUPERACIN DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero C PROFESOR: Ing. Christian Torres 2007 FECHA: jueves 16 de agosto del
typedef struct nodo {char nombre[40]; char apellido[30]; char fono[15]; int edad; struct nodo * sig; }tipoNodo;
typedef tipoNodo * pNodo; typedef tipoNodo *Lista;
1. Teniendo la presente estructura y definicin de tipos de datos, implemente una funcin para insertar nodos al inicio de una lista abierta. (1.5 pts)
2. Implemente una funcin para poder insertar un nuevo nodo antes del nodo con el campo nombre= Ximena. Para la estructura ya indicada. Asuma que los datos son pasado como argumentos de la funcin. ( 4.0pts)
3. Escriba una funcin para eliminar el primer nodo de una lista doblemente enlazada circular. Realice las modificaciones respectivas en la estructura y tipo de datos dados para que pueda trabajar en esta pregunta.( 1.5 pts)
4.
Construya una pila utilizado la estructura propuesta, e implemente una funcin que permita invertir una pila. ( 3.0pts)
118

CIENCIAS INFORMATICAS EXAMEN DE RECUPERACIN DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero __ PROFESOR: Ing. __________________ FECHA: __________________________
1. Una empresa de correos, desea implementar un programa que permita mejorar el manejo de la entrega de encomiendas, en la cual registre el nmero de envi, peso, destino, el remitente y el costo del envi. Por razones de no contar con el suficiente personal de entrega, la empresa enva a despachar los paquetes cuyo peso sea inferior a 500Kg, para ser entregado en el transcurso de la semana (de lunes a viernes), y los que sean superiores a 500 Kg sern despachados en el fin de semana (sbado y domingo). Se solicita que utilice una lista doblemente enlazada en la que registre todas las entregas y elabore con ello una lista simple, para almacenar las entregas de los paquetes para la semana (de lunes a viernes), y otra lista para los de fin de semana (sbado y domingo) (5pts)
2. Explique tericamente o grficamente, como poder entregar a las personas que tienen varios paquetes por recibir de diferente tamao (en la semana, y fin de semana), para entregarle en el mismo viaje todo a la vez en el primer viaje y as ahorrar combustible. (2 puntos)
3. Construya un rbol binario a partir del siguiente grafico. ( 3.0pts) Recorrer en In Orden. El rbol generado Nodos Hojas del rbol binario________________________________
119
UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS ESCUELA DE INGENIERA DE SISTEMAS INFORMTICOS REA DE MATEMTICAS
EL PORTAFOLIO ESTUDIANTIL El portafolio es una tcnica de enseanza, aprendizaje y avalo. Este consiste de una coleccin de los trabajos que realiza el estudiante para demostrar sus esfuerzos, logros y progreso en un rea especfica, en este caso el rea de matemticas Calculo Diferencial. El portafolio se ha incorporado en la educacin en la facultad de Ciencias Informticas no slo como una evidencia de los procesos de enseanza-aprendizaje, si no como un fortalecimientomejoramiento continuo en todo el quehacer educativo.
PROPOSITO Fortalecer las destrezas de bsqueda y localizacin de informacin Como funcin principal de servir como medio para que el estudiante pueda evidenciar su ejecucin acadmica en el curso. Permite desarrollar destrezas de anlisis y solucin de problemas en todo el quehacer educativo. Permite que el estudiante reflexione sobre su actividad y progreso en clase.
VENTAJAS Es un producto individual y personalizado que permite al estudiante explorar su creatividad. Sirve para que el estudiante comparta experiencias con otros compaeros del curso. Promueve la evaluacin sobre fortalezas y debilidades.
ORGANIZACIN DEL PORTAFOLIO El formato para el curso de Calculo Diferencial es el siguiente:
Portada diseada, incluye: nombre de la institucin, nombre del curso, nombre del estudiante, nombre del docente, fecha. Tabla de contenido. Carta de presentacin, presenta datos personales del estudiante, rea de inters, plan de trabajo, objetivos del curso, motivos y propsito para el desarrollo del portafolio. (incluya una foto en un lugar apropiado) Trabajos investigacin, tareas y asignaciones, una seleccin de trabajos representativos. Reflexiones, sobre la clase y trabajos realizados. Resumen de cierre, a manera de conclusin donde el estudiante destaque su satisfaccin con lo comprendido, reas que debe mejorar y limitaciones. rea para evaluacin del docente, seccin donde el docente presentar la evaluacin de la ejecucin del estudiante en el curso y en el portafolio.
PROCESO DE ELABORACIN FASE 1.- Recogida de Evidencias: esta fase va precedida por la revisin de objetivos o competencias delineados para el curso. Al definir stos se facilita la recoleccin de evidencias que pueden ser variadas como formato y soporte como lecturas, recortes de peridicos, tareas, informes, exmenes y presentaciones. FASE 2.- Seleccin de Evidencias: para evitar que el portafolio se convierta en un inventario de evidencias es necesario escoger los mejores trabajos. Estos trabajos deben representar el progreso en el curso. Este ejercicio permite al estudiante determinar las fortalezas y debilidades de acuerdo con las expectativas y objetivos del curso. FASE 3.- Reflexiones de las Evidencias: esta fase constituye el punto culminante del proceso de desarrollo del portafolio, Se espera que el estudiante reconozca los aciertos y desaciertos durante su paso por el curso. En este ejercicio de reflexin es determinante proponga las estrategias para mejorar los puntos dbiles. FASE 4.- Publicacin del Portafolio: en este punto el estudiante organizar las evidencias con sus respectivas reflexiones de acuerdo con las especificaciones indicadas por el docente o su tutor designado como gua por la facultad. Se espera que el estudiante utilice su creatividad para organizar y presentar el portafolio final.

Portafolio Jonathan

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Portafolio Jonathan

Caricato da

Copyright:

Formati disponibili

CARRERA DE INGENIERIA EN SISTEMAS INFORMATICOS

UNIVERSIDAD TECNICA DE MANABI FACULTAD DE CIENCIAS INFORMATICAS

PORTAFOLIO DE ESTRUCTURA DE DATOS

Docente: ING. CRISTIAN TORRES

FACULTAD DE CIENCIAS INFORMTICAS

UNIVERSIDAD TCNICA DE MANAB

FACULTAD DE CIENCIAS INFORMTICAS SYLLABUS

b.- OBJETIVO GENERAL DE LA ASIGNATURA: c.- DESCRIPCIN DE LA ASIGNATURA:

Niveles del resultado de aprendizaje

NIVEL ALTO: 86-100

NIVEL MEDIO 71-85

NIVEL ALTO: 86-100

NIVEL MEDIO 71-85

NIVEL ALTO: 86-100

Elaborar un programa con estructuras dinmicas no lineales bien detallado.

NIVEL ALTO: 86-100

Elaborar un programa con estructuras dinmicas no lineales con poca claridad.

NIVEL MEDIO 71-85

Elaborar un programa con estructuras dinmicas no lineales de forma confusa.

NIVEL ALTO: 86-100

NIVEL MEDIO 71-85

ESTRATEGIAS PARA EL TRABAJO AUTNOMO

UNIDAD II: ESTRUCTURAS SIMPLES

30 Experiencia: Aplicando lluvia a de ideas

30 Tareas extraclases. Investigacin del tema de la unidad Tareas en el lenguaje de

Definicin de listas abiertas Declaracin e implementacin de una lista

Conceptualizacin: Elaboracin de conclusiones conceptuales, cuadros de funcionamiento y alternativas

Listas circulares o cerradas Declaracin e implementacin de una lista circular

Aplicacin: Resolucin demostrativos de ejercicios y de

13 Experiencia: Aplicando la debates de

aplicar algoritmos generales de

13 Tareas extraclases. Investigacin del tema de la unidad Tareas en el

rboles Tipos de PreOrden InOrden PostOrden recorridos:

importancia en la agilidad y seguridad de los datos en el campo empresarial en general. Reflexin:

Operaciones con rboles Binarios de Bsqueda

trabajo, principales avance

propuestas resolucin. Aplicacin:

UNIDAD IV: TIPOS DE RBOLES

Reequilibrados en rboles AVL por borrado de un nodo.

V.- METODOLOGA Y RECURSOS

VI.- PLANEACIN DE LA EVALUACIN

VI.- BIBLIOGRAFA a.- Bibliografa Bsica:

Elda Quiroga Estudiantil-FCI-UTM. Ecuador

b.- Bibliografa Recomendada:

c.- Lecturas complementarias:

Abstraccin y Estructura de Datos en C++

VII.- COMPROMISO TICO

Lugar y fecha: Portoviejo, 6 de Mayo del 2013

Ing. Christian Ronald Torres Morn (f) Docente ANEXO. N 1

RESULTADOS DE APRENDIZAJE DE LA CARRERA ESPECFICOS A LOS QUE APUNTA LA MATERIA (ABET).

UNIVERSIDAD TCNICA DE MANAB MISIN:

FACULTAD DE CIENCIAS INFORMTICAS

PERIODO: TIEMPO: FECHA: DOCENTE GUIA:

Contenido: Generalidades y definiciones de estructuras de datos

PERIODO: TIEMPO: FECHA: DOCENTE GUIA:

Tema: Acceso a las estructura de Datos

PERIODO: TIEMPO: FECHA: DOCENTE GUIA:

Tema: Acceso a las estructura de Datos

printf("\n************************\nNombre: %s\nSueldo: %.2f\nValor de ventas: %.2f\n************************\n",A[x].nombre,A[x].sueldos,A[x].val_vent); getch(); }

Tema: Pasos de parmetros por referencia y por valor

PERIODO: TIEMPO: FECHA: DOCENTE GUIA:

Tema: Minga en la Universidad.

PERIODO: TIEMPO: FECHA: DOCENTE GUIA:

ver_fecha(datos); getch(); return 0; }

printf("\n\nNombre: %s\nSueldo: %.2f\nValor de ventas: %.2f\n\n",A[x].nombre,A[x].sueldos,A[x].val_vent); getch(); }