estructura portafolio

Docente: Ing. Cristian Ronald Torres

Semestre Mayo – Septiembre 2013

Formar académicos, científicos y profesionales responsables,

humanistas, éticos y solidarios, comprometidos con los objetivos del

desarrollo nacional, que contribuyan a la solución de los problemas

del país como universidad de docencia con investigación, capaces de

generar y aplicar nuevos conocimientos, fomentando la promoción y

difusión de los saberes y las culturas, previstos en la Constitución de

la República del Ecuador.

Ser institución universitaria, líder y referente de la educación

superior en el Ecuador, promoviendo la creación, desarrollo,

transmisión y difusión de la ciencia, la técnica y la cultura, con

reconocimiento social y proyección regional y mundial.

Ser una unidad con alto prestigio académico, con eficiencia,

transparencia y calidad en la educación, organizada en sus

actividades, protagonistas del progreso regional y nacional.

Formar profesionales eficientes e innovadores en el campo de las

ciencias informáticas, que con honestidad, equidad y solidaridad, den

respuestas a las necesidades de la sociedad elevando su nivel de vida

Ing. C. Torres: CHRISTIAN RONALD TORRES

Docente de la Facultad de Ciencias Informáticas de la Universidad Técnica de Manabí

País:

Ecuador

Ciudad:

PORTOVIEJO

Cursos:

Sociologia, Programacion, Programación II 2013-1, Estructura de Datos,

Estructura de Datos, Estructura de Datos, Contabilidad de Costos, Seguridad

Informática 2013-1, Procesamiento de Imagenes 2013-1, Diseño Grafico 2013-1,

Herramientas Web, Proteccion de la Informacion, Inteligencia Artificial, Gestion

Universitaria

Estructura de Datos

La materia introduce al estudiante a los conceptos y aplicación en la administración de memoria,

aplicando programación estructurada y orientada a objetos, permite conocer la estructura básica

operacional de la memoria RAM y de los grandes diseños de software, aplicando C++ el

estudiante desarrollará proyectos científicos tanto con interfaces en modo gráfico y en modo texto,

tomando como referencia aplicaciones en el campo general de otras carreras.

http://evirtual.utm.edu.ec/user/view.php?id=3408&course=1

















http://evirtual.utm.edu.ec/course/view.php?id=32

Syllabus

Carta de presentacion

Autorretrato

Diario metacognitivo

Artículos de revistas

Trabajo de ejecución

Materiales relacionados con la clase

Seccion abierta

Resumen de cierre

Investigacion

Vinculación

Gestion

Anexos

UNIVERSIDAD TÉCNICA DE MANABÍ

FACULTAD DE CIENCIAS INFORMÁTICAS

ESCUELA DE INGENIERÍA EN SISTEMAS

INFORMÁTICOS

Estructura de datos Segundo “B”

UNIVERSIDAD TÉCNICA DE MANABÍFACULTAD DE CIENCIAS INFORMÁTICAS

CARRERA DE INGENIERÍA EN SISTEMAS INFORMÁTICOS

SYLLABUS

I.- INFORMACIÓN GENERALFACULTAD/DEPARTAMENTO: FACULTAD DE CIENCIAS INFORMÁTICASCARRERA: INGENIERÍA EN SISTEMAS INFORMÁTICOSASIGNATURA/MÓDULO: ESTRUCTURA DE DATOS CÓDIGO: OF-0201Nivel / Semestre: 2 N° de Créditos:5 Modalidad : PresencialParalelo: 2do. “B” Período Académico: Sept. 25/2012 – Feb 14/2013 Área Académica: SOFTWAREPRERREQUISITO (S): CORREQUISITO (S):

CONTENIDOS DISCIPLINARES QUEDEBEN SER APROBADAS ANTES DE

CURSAR ESTE CONTENIDODISCIPLINAR

CÓDIGO

CONTENIDOS DISCIPLINARESQUE DEBEN SER CURSADOS AL

MISMO TIEMPO QUE ESTECONTENIDO DISCIPLINAR

CÓDIGO

PROGRAMACIÓN I OC-0100

DOCENTE: Ing. CHRISTIAN RONALD TORRES MORÁNTítulo: MAGITER EN GERENCIA EDUCATIVA E-mail: [email protected] personales: Profesor contratado a tiempo completo de la asignatura Estructura de Datos, y Herramientas WebDirector de Tesis de Ingeniería en Sistemas Informáticos, miembro de los equipos de Vinculación con la sociedad, DocenteTutor de pasantías pre profesionales, coautor del manual de Estructura de Datos junto a la Ing. Esthela San Andrés Láz,coautor del folleto de flujogramas para NBU.

II.- RUTA FORMATIVAa.- DEL PERFIL DE EGRESO: Competencia/Resultado de Aprendizaje:Competencia:

3. Construye soluciones informáticas de calidad que mejoren la eficiencia y eficacia de una organizaciónhaciendo uso correcto de la tecnología.

Resultado de Aprendizaje:a. Capacidad de planificar, diseñar, conducir e interpretar resultados de experimentos orientados a la

informática.

b.- OBJETIVO GENERAL DE LA ASIGNATURA:Capacitar al estudiante con los conocimientos significativos en administración de memoria dinámica y herramientas útiles enlos diseños, construcciones y usos principales de algoritmos en la estructuración de datos lineales y no linealesc.- DESCRIPCIÓN DE LA ASIGNATURA:La materia introduce al estudiante a los conceptos y aplicación en la administración de memoria, aplicando programaciónestructurada y orientada a objetos, permite conocer la estructura básica operacional de la memoria RAM y de los grandesdiseños de software, aplicando C++ el estudiante desarrollará proyectos científicos tanto con interfaces en modo gráfico y enmodo texto, tomando como referencia aplicaciones en el campo general de otras carreras.

III.- RESULTADOS DE APRENDIZAJE DE LA ASIGNATURA

Resultados del Aprendizaje(Objetivos Específicos)

Formas deEvidenciarlos

(Apreciación)

Niveles del resultado deaprendizaje Ponderación

1.- Identificar los tipos estructuradosde datos estáticos y dinámicosempleados en la creación deaplicaciones, considerando loslenguajes de programación. (NivelTaxonómico: Conocimiento)

1.- Pruebas escritas,orales (fotos), talleres,informes de ensayo,investigación yPrácticas en elLenguaje deprogramación C++.

Describirá la definición de la estructura de datos,los tipos de datos simples, básicos y compuestosen un ensayo técnico con: descripción general deltema clara; ideas que tienen relación, claridad yobjetividad con el tema; y una conclusión clara conaporte personal.

Describirá la definición de la estructura de datos,los tipos de datos simples, básicos y compuestosen un ensayo técnico con: descripción general deltema confusa; pocas ideas que tienen relación,claridad y objetividad con el tema; y unaconclusión confusa con aporte personal.

Describirá la definición de la estructura de datos,los tipos de datos simples, básicos y compuestosen un ensayo técnico con: descripción general deltema confusa; poca o ninguna idea que tienenrelación, claridad y objetividad con el tema; y unaconclusión confusa sin aporte personal.

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

2.- Elaborar aplicaciones dinámicasde estructura lineal, almacenamientoy recuperación de los mismos enunidades de almacenamiento,aplicarán soluciones deadministración de memoriamediante el desarrollo deaplicaciones científicas ycomerciales. (Nivel Taxonómico:Aplicación)


Comparará con la utilización de un cuadrocomparativo tres semejanzas y tres diferenciasentre los tipos de datos que permiten almacenarmás de un dato; reflejando las relaciones de lascomparaciones con ideas claras.

Comparará con la utilización de un cuadrocomparativo tres semejanzas y tres diferenciasentre los tipos de datos que permiten almacenarmás de un dato; reflejando las relaciones de lascomparaciones con ideas pocos claras.

Comparará con la utilización de un cuadrocomparativo dos semejanzas y dos diferenciasentre los tipos de datos que permiten almacenarmás de un dato; reflejando las relaciones de lascomparaciones con ideas confusas.

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

3.- Implementar aplicacionesdinámicas de estructura Lineal,almacenamiento y recuperaciónde los mismos en unidades dealmacenamiento, aplicaránsoluciones de administración dememoria mediante el desarrollode aplicaciones científicas ycomerciales (Nivel Taxonómico:Aplicación)


Implementará aplicaciones dinámicas deestructura Lineal, almacenamiento y recuperaciónde los mismos en unidades de almacenamiento,aplicarán soluciones de administración dememoria mediante el desarrollo de aplicacionescientíficas y comerciales.

Implementará aplicaciones dinámicas deestructura Lineal, almacenamiento y recuperaciónde los mismos en unidades de almacenamiento,aplicarán soluciones de administración dememoria mediante el desarrollo de aplicacionescomerciales.

Implementará aplicaciones dinámicas deestructura No Lineal, almacenamiento yrecuperación de los mismos en unidades dealmacenamiento.

NIVEL ALTO:

86-100

NIVELMEDIO

71-85

NIVEL BÁSICO

70

4.- Implementar aplicacionesdinámicas de estructura no Lineal,almacenamiento y recuperación delos mismos en unidades dealmacenamiento, aplicaránsoluciones de administración dememoria mediante el desarrollo deaplicaciones científicas y comerciales(Nivel Taxonómico: Aplicación)


Elaborará un programa con estructuras dinámicasno lineales bien detallado.

Elaborará un programa con estructuras dinámicasno lineales con poca claridad.

Elaborará un programa con estructuras dinámicasno lineales de forma confusa.

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

5.- Organizar la información enalgoritmos y estructuras AVL y surelación con los gestores de Base deDatos (Nivel Taxonómico: Aplicación)


Elaborará un programa que emplee estructurasarborescentes de forma AVL uso de forma clara.

Elaborará un programa que emplee estructurasarborescentes de forma AVL de forma poco clara.

Elaborará un programa que emplee estructurasarborescentes de forma AVL de forma confusa.

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

IV.- PROGRAMACIÓN

N°PROGRAMA DEL CONTENIDO

DISCIPLINAR (ASIGNATURA, UNIDAD,CURSO, TALLER, OTRO) POR TEMAS

N°TOTAL

HORASP-A

HORAS PRESENCIALES HORASAUTÓNOMAS

ESTRATEGIAS PARA ELTRABAJO AUTÓNOMO

1. UNIDAD I: GENERALIDADES YDEFINICIONES DE ESTRUCTURA DEDATOS

Definición

Variables, Tipos de datos.

Representación Gráfica de las

estructura de datos

Acceso a las estructura de

Datos (Estáticas)

Tipos de Estructuras de Datos

Diferencia entre gestión

Estática y Dinámica

Operaciones con varios

punteros

Asignación dinámica de

memoria

Liberación dinámica de

memoria

La constante NULL

Ventajas y desventajas de

punteros

46 23

Experiencia:

Aplicando lluvia de ideas

concretar conocimientos

relativo a la memoria y sus

diferentes importancias en el

funcionamiento del

computador

Reflexión:

En equipos de trabajo, analizar

el funcionamiento general del

computador y de los

programas, considerando las

siguientes aplicaciones:

Procesadores de texto, Hojas

de cálculo, Reproductores,

Tareas del sistema operativo

como Impresión, etc.

Conceptualización:

Elaboración de mapas

conceptuales, cuadros de

funcionamiento y estructurales

de la memoria.

Aplicación:

Resolución de ejercicios

demostrativos y de

planteamiento de problemas.

23Tareas extra-clases.Investigación deltema de la unidadTareas en ellenguaje deprogramaciónC++.CD. interactivolibros PDF. Apoyopara elestudiante,Espacio virtual dela UniversidadTécnica deManabí, Internet.Guardar laevidencia en elPortafolio Digital.

-Formarán equipos de 2estudiantes-Del taller o tarea respectivasse escogerán ejerciciosrepresentativos de acuerdo alresultado de aprendizaje-Se aplicará la técnica deprocesos.-Al final de la tarea seinterrogarán, así:¿Qué cosas fueron difíciles?¿Qué cosas fueron fáciles?¿Qué aprendí hoy día?¿Qué aporte a mi equipo?-Aplicarán un ASAT. (AporteSignificativo de Aprendizaje dela Tarea o Taller).-Para el ensayo del temarespetivo se Tomarán lolineamientos más importantesde la introducción llamativa,fundamentación y conclusióncrítica.

2. UNIDAD II: ESTRUCTURAS SIMPLESY COMPUESTAS

Listas Abiertas

60 30

Experiencia:

Aplicando lluvia de ideas

concretar conocimientos

relativo a problemas

30Tareas extra-clases.Investigación deltema de la unidadTareas en ellenguaje de

-Formarán equipos de 2estudiantes-Del taller o tarea respectivasse escogerán ejerciciosrepresentativos de acuerdo alresultado de aprendizaje-Se aplicará la técnica deprocesos.-Al final de la tarea se

Definición de listas abiertas

Declaración e implementaciónde una lista

Operaciones con Listas

Inserción de un nodo

Búsqueda de un nodo

Recorridos de una lista

Eliminación de un nodo

Listas y Archivos

Variaciones de listas

Pilas y Colas

Listas circulares o cerradas

Declaración e implementaciónde una lista circular






Listas doblemente enlazadas abiertasy cerradas

Declaración e implementaciónde una lista doblementeenlazada






informáticos planteados

Reflexión:

En grupos de trabajo, analizar

el funcionamiento general de

los diferentes algoritmos

considerando las diferentes

aplicaciones.

Conceptualización:

Elaboración de conclusiones

conceptuales, cuadros de

funcionamiento y alternativas

estructurales de solución.

Aplicación:


demostrativos y de


programaciónC++.CD. interactivolibros PDF. Apoyopara elestudiante,Espacio virtual dela UniversidadTécnica deManabí, Internet.Guardar laevidencia en elPortafolio Digital.

interrogarán, así:¿Qué cosas fueron difíciles?¿Qué cosas fueron fáciles?¿Qué aprendí hoy día?¿Qué aporte a mi equipo?-Aplicarán un ASAT. (AporteSignificativo de Aprendizaje dela Tarea o Taller).-Para el ensayo del temarespetivo se Tomarán lolineamientos más importantesde la introducción llamativa,fundamentación y conclusióncrítica.

3. UNIDAD III: ESTRUCTURASARBORESCENTES

Definición, implementación

26 13

Experiencia:

• Aplicando debates

definir la importancia de

aplicar algoritmos generales de

13Tareas extra-clases.Investigación deltema de la unidadTareas en el

-Formarán equipos de 2estudiantes-Del taller o tarea respectivasse escogerán ejerciciosrepresentativos de acuerdo alresultado de aprendizaje-Se aplicará la técnica deprocesos.

Tipos de recorridos:PreOrdenInOrdenPostOrden

Operaciones con Árboles Binarios deBúsqueda

Búsqueda de elementos.Inserción de elementos.Borrado de elementos.

* Nodo hoja.

*Nodo rama.

Movimiento a través del árbol.Comprobación de árbolesvacíos.

Comprobación del nodo hoja.Cálculo de:

Número de nodos.

Altura del árbol.

Altura de un nodo.

Árboles degenerados.

árboles binarios y su

importancia en la agilidad y

seguridad de los datos en el

campo empresarial en general.

Reflexión:

• En grupos de

trabajo, analizar el

funcionamiento general de los

principales sistemas

informáticos, considerando el

avance tecnológico del

software en la base de datos

Conceptualización:

• Elaboración de

propuestas algorítmicas,

prácticas y de alternativas de

resolución.

Aplicación:

• Resolución de

ejercicios demostrativos y de


lenguaje deprogramaciónC++.CD. interactivolibros PDF. Apoyopara elestudiante,Espacio virtual dela UniversidadTécnica deManabí, Internet.Guardar laevidencia en elPortafolio Digital.

-Al final de la tarea seinterrogarán, así:¿Qué cosas fueron difíciles?¿Qué cosas fueron fáciles?¿Qué aprendí hoy día?¿Qué aporte a mi equipo?-Aplicarán un ASAT. (AporteSignificativo de Aprendizaje dela Tarea o Taller).-Para el ensayo del temarespetivo se Tomarán lolineamientos más importantesde la introducción llamativa,fundamentación y conclusióncrítica.

4. UNIDAD IV: TIPOS DE ÁRBOLESESPECIALES

Árboles equilibrados.

Definición.

Operaciones en AVL.

Factor de equilibrio.

Rotación simple de nodos.

Rotación simple a la derecha.

Rotación simple a la izquierda.

Rotación doble de nodos a laderecha.

Rotación doble de nodos s laizquierda.

Reequilibrados de árbolesAVL.

Reequilibrados en árbolesAVL por inserción de un nodo.

28 14

Experiencia:

Aplicando el planteamiento de

problemas, identificar

dificultades y generar la

necesidad de encontrar

soluciones algorítmicas.

Reflexión:

En grupos de trabajo, analizar

el funcionamiento de los

diferentes algoritmos

propuestos.

Conceptualización:

Elaboración de propuestas de

funcionamiento y alternativas

estructurales de solución.

Aplicación:

14Tareas extra-clases.Investigación deltema de la unidadTareas en ellenguaje deprogramaciónC++.CD. interactivolibros PDF. Apoyopara elestudiante,Espacio virtual dela UniversidadTécnica deManabí, Internet.Guardar laevidencia en elPortafolio Digital.

-Formarán equipos de 2estudiantes-Del taller o tarea respectivasse escogerán ejerciciosrepresentativos de acuerdo alresultado de aprendizaje-Se aplicará la técnica deprocesos.-Al final de la tarea seinterrogarán, así:¿Qué cosas fueron difíciles?¿Qué cosas fueron fáciles?¿Qué aprendí hoy día?¿Qué aporte a mi equipo?-Aplicarán un ASAT. (AporteSignificativo de Aprendizaje dela Tarea o Taller).-Para el ensayo del temarespetivo se Tomarán lolineamientos más importantesde la introducción llamativa,fundamentación y conclusióncrítica.

Reequilibrados en árbolesAVL por borrado de un nodo.


demostrativos y de


V.- METODOLOGÍA Y RECURSOS Se aplicará un PEA, Dinámica de integración y socialización, documentación, presentación de los temas de clase y objetivos, lectura de motivación

y video del tema, técnica 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)

Revisión de la clase programada antes del día señalado para la sesión correspondiente (blog-docente)

Consultas, tareas y talleres se entregarán en archivo escrito al docente y en archivo lógico al área de contacto del curso.

Los recursos disponibles para el curso serán: pizarra tiza líquida(4), proyector, internet inalámbrico, 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 generación,

computadores(2) del aula,1 portátiles por equipo del estudiante, libros-CD-interactivo- pdf., blog. del estudiante y del docente para interactividad

y fortalecimiento continúo.

VI.- PLANEACIÓN DE LA EVALUACIÓNLas evaluaciones estarán orientadas a los procesos, lo que conlleva a que ninguna evaluación tenga una ponderacióndeterminante para la acreditación.Durante el periodo académico, el estudiante de la Universidad Técnica de Manabí, se someterá obligatoriamente a lossiguientes parámetros de evaluación de los aprendizajes: evaluación de medio ciclo, evaluación de final de ciclo, evaluación deactividades varias y evaluaciones de investigaciones.

ACREDITACIÓNMEDIO CICLO FINAL DE CICLO EXAMEN DE

RECUPERACIÓN ASISTENCIA

EXÁMENES (30%) 15 15ACT. EN EL AULA (40%)

Tareas 5 5Ejercicios de aplicación 2.5 2.5Lecciones orales 2.5 2.5Pruebas escritas 5 5

Participación 2.5 2.5Exposiciones 2.5 2.5

ACTIVIDADES DE INVESTIGACIÓNPORTAFOLIOPROYECTOINFORME FINAL(30%)

510

5

10

TOTAL 50% 50% 100%

VI.- BIBLIOGRAFÍAa.- Bibliografía Básica:

AUTOR TÍTULO DE LIBRO EDICIÓN AÑO PUBLICACIÓN EDITORIALMARTÍNEZ, Román Estructura de Datos, Referencia

practica con objetos orientadosa objetos

7° 2008 Elda Quiroga

TORRES, Christian Manuales de estructura deDatos en C++

1° 2010 Estudiantil-FCI-UTM.Ecuador

b.- Bibliografía Recomendada:AUTOR TÍTULO DE LIBRO EDICIÓN AÑO PUBLICACIÓN EDITORIAL

Garrido Antonio Abstracción y Estructurade Datos en C++

1° 2006 Delta Publicaciones S. L.

c.- Lecturas complementarias: 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 democráticamente el criterio de los demás. 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 manipulación y utilización de los equipos informáticos. 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 ocasión se aceptará el retraso de 10 minutos. El estudiante por ningún concepto utilizará celulares en el aula, igual comportamiento tendrá el docente. El intento de copia de cualquier estudiante será sancionado con la calificación de cero y no habrá oportunidad de

recuperación, independiente de las sanciones establecidas por la universidad. Los trabajos se entregarán 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

párrafo o un texto se calificará con cero.

Lugar y fecha: Portoviejo, 6 de Mayo del 2013

Ing. Christian Ronald Torres Morán(f) Docente (f) Coordinador

ANEXO. N° 1

RESULTADOS DE APRENDIZAJE DE LA CARRERA ESPECÍFICOS A LOS QUE APUNTA LAMATERIA (ABET).

a. Capacidad de realizar análisis, síntesis y aplicación de las matemáticas y ciencias básicas en lasolución de problemas de ingeniería en sistemas informáticos.

b. Capacidad de planificar, diseñar, conducir e interpretar resultados de experimentos orientadosa la informática.

c. La capacidad de diseñar sistemas, procesos, modelos y componentes informáticos que cumplanlos estándares nacionales o internacionales, tomando en cuenta las limitaciones económicas,ambientales, sociales, políticas, de salud y seguridad del entorno, y cumpliendosatisfactoriamente con las especificaciones y restricciones existentes o indicadas por losinteresados o por los criterios de sostenibilidad.

d. Capacidad para funcionar como parte de un equipo de profesionales de distintas áreas delconocimiento, demostrando una efectiva cooperación, comunicación, con habilidades pararesolver conflictos y contribuyendo proactivamente en la propuesta de líneas estratégicasdesde el punto de vista informático, para la solución de problemas.

e. Capacidad para identificar, formular, evaluar y resolver técnicamente problemas de ingenieríaplanteados de acuerdo a las necesidades del medio.

f. Capacidad para comprender, reconocer y aplicar valores y códigos de ética profesional, que lepermitan desenvolverse sin perjudicar a sus clientes y contribuyendo al desarrollo de lasociedad.

g. Habilidad para presentar efectivamente, ideas, proyectos, informes de investigaciones,documentos de trabajo de manera escrita, oral y digital, utilizando las herramientas de lasnuevas tecnologías de la información.

h. Habilidad y capacidad para comprender el impacto de las soluciones informáticas a la realidadlocal, nacional e internacional en un contexto económico global, ambiental y social.

i. Habilidad y aptitud para ser un profesional con el compromiso del aprendizaje continuo, concapacidad para reconocer las oportunidades para mejorar en su campo profesional.

j. 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.

k. Capacidad y destreza para utilizar técnicas, habilidades y herramientas en el desarrollo desoftware y hardware para implementar soluciones a problemas de su profesión.

Contribución de la materia a los resultados de aprendizaje de la carrera:

A: Alta M: Medio B: Baja

a b c d e f g h i j k

A M B




INFORMÁTICOS


Este portafolio es muestra de mi trayectoria en el curso de Estructura de Datos, este curso

me sirvió de mucho tanto para desarrollarme académicamente como personalmente ya que

el docente no solo se enfocó en formar estudiantes sino también entes humanos con

principios y valores ya que esto es la base en todo profesional.

Aquí evidencio una a una mis destrezas y debilidades en esta materia con el desarrollo del

diario metacognitivo.

Las técnicas presentadas por el docente me ayudaron a mejorar como futuro profesional

de la Informática ya que las clases basadas en la práctica abundante me ayudo a

comprender con más facilidad los temas planteados.




INFORMÁTICOS


Mi nombre es Kenia Mabel Navarrete García, tengo 19 años de edad, soy una persona

sencilla, amigable, responsable, con muchas ganas de aprender y captar las enseñanzas de

cada clase, me gusta compartir y trabajar en equipo desempeñándome siempre de la

mejor manera posible para lograr un trabajo exitoso.

Soy estudiante de la asignatura de ESTRUCTURA DE DATOS, actualmente curso

SEGUNDO “B” en la Facultad de Ciencias Informáticas de la Universidad Técnica de

Manabí.

Mis metas son convertirme en profesional y no solo ser Ingeniera en Sistemas Informáticos

sino ser la mejor Ingeniera en Sistemas Informáticos y para ello estoy estudiando en una

Institución académica de calidad.

NOMBRES KENIA MABEL

APELLIDOS NAVARRETE GARCIA

IDENTIFICACION 131571764-3

LUGAR DE NACIMIENTO PORTOVIEJO

FECHA DE NACIMIENTO 1 DE DICIEMBRE DE 1993

ESTADO CIVIL SOLTERA

LUGAR DE RESIDENCIA PORTOVIEJO

DIRECCION JUAN MONTALVO ENTRE PEDRO GUAL Y 10 DE AGOSTO

TELEFONO 052 638-647 / 0959882950

CORREO ELECTRONICO [email protected]

Soy una persona responsable, aplicada en mis estudios, me gusta el trabajo en equipo,

tengo facilidad de aprendizaje y muchas ganas de superarme.

ESCUELA UNIDAD EDUCATIVA PARTICULAR “TNTE HUGO ORTIZ”

COLEGIO COLEGIO MUNICIPAL VESPERTINO “MANUEL RIVADENEIRA”

TITULO OBTENIDO BACHILLER EN ADMINISTRACION Y COMERCIO ESPECIALIDAD INFORMATICA

mailto:[email protected]

Primer lugar en el concurso intercolegial de programación organizado por el ITSUP

GS TECNOLOGIA

CARGO: Servicio técnico

FUNCIONES: Formateo de computadoras, mantenimiento técnico, instalación de

programas

JEFE INMEDIATO: Fernando Rivadeneira

OIM SEGUROS

CARGO: Secretaria

FUNCIONES: Contestar llamadas, funciones de una secretaria

JEFE INMEDIATO: Mauricio Morales

Conferencia de Avances tecnologicos, desarroolados de software, redes inalambricas y

roboticas; en la segunda feria de ciencias y tecnologia organizada por el segundo nivel de

electronica de la carrera de Ingenieria en Sistema Informaticos desde el 24 al 25 de enero

del 2013, con una dración de 22 horas.

__________________________

KENIA MABEL NAVARRETE GARCIA 131571764-3




INFORMÁTICOS


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();

}

Clase # 1

•Del 06 de mayo del 2013 - 14 Septiembre 2013 Periodo

•3 horas Tiempo

•Lunes 06 de mayo del 2013 Fecha

• Ing. Cristhian Ronald Torres Docente

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();

}

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:

# include”string.h”

struct tnotas{

char nomb_est[30];

float calif;

}

Las estructuras van antes del void main(), mai().

Clase # 2


•2 horas Tiempo

•Miércoles 08 de mayo del 2013 Fecha


Para acceder a los miembros de la estructura se debe hacer uso del punto y un nombre del

campo.

Ejemplo:

# include”string.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

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 asignación, 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

Diseñe una estructura que permita almacenar cedula, nombres, apellidos, cuidad y

departamento del empleado de una empresa pública 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()

{

Clase # 3


•3 horas Tiempo

•Lunes 13 mayo del 2013 Fecha


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();

}

Crear un programa que nos permita almacenar nombre, sueldos, junto con el valor de

ventas.

#include<conio.h>

#include<stdio.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];


{

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 # 4


•2 horas Tiempo



#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;

}

}

Clase # 5


•3 horas Tiempo



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 # 6


•3 horas Tiempo




#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();

Clase # 7


•3 horas Tiempo



return 0;

}


#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;

}

Crear una estructura que permita manejar números 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];


ingreso(datos[x]);


calcular(datos[x]);


mostrar(datos[x]);

getch();

}

void ingreso(struct empleado &f)

Clase # 8


•2 horas Tiempo



{

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;

}

#include"stdio.h"

#include"conio.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";

Clase # 9


•3 horas Tiempo

•Lunes 03 de junio del 2013 Fecha


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 # 10


•2 horas Tiempo

•Miércoles 05 de junio del 2013 Fecha


#include"stdio.h"

#include"conio.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];

Clase # 11


•3 horas Tiempo



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(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)

{//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();

}

#include"stdio.h"

#include"conio.h"


#include"string.h"

#include"stdlib.h"


char nom[30];


}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;

Clase # 12


•2 horas Tiempo



}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)


else

almacenar_fin(&l1,nombre);

}

else if(op==3)

{clrscr();

ver_lista(l1);

}

} while(op!=4);

}

void almacenar(lista *l,char c[])

{pnodo nodo;


if(nodo==NULL)


return; }



{ //procedo hacer los enlaces

nodo->sig=*l;

*l=nodo;

} }

void almacenar_fin(lista *l,char c[])

{pnodo nodo;


if(nodo==NULL)


return; }



//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;

}

}


{pnodo n=l;

while(n)


n=n->sig;}

getch();

}

#include<conio.h>

#include<stdio.h>


#include<stdlib.h>

#include<string.h>


char nom[25];


}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));

Clase # 13


•3 horas Tiempo



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);

}}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


//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;


if (nodo==NULL)


return;

}




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;


if (nodo==NULL)


return;

}




//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)


n=n->sig;

}

getch();

}

#include<conio.h>

#include<stdio.h>


#include<stdlib.h>

#include<string.h>


char nom[25];


}tipoAlumno;


typedef tipoAlumno *lista;


void almacenar(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();


Clase # 14


•2 horas Tiempo




printf("\n3. Registrar ordenadamente");


printf("\n5. Eliminar un elemento");

printf("\n6. Eliminar lista");

printf("\n7. Filtrar nombres repetidos");


do{ cout<<"Opcion: ";cin>>op;

}while ((op>8) ||(op<1));

if (op<=3)

{ //char nombre[25];

clrscr();



fflush(stdin);

gets(nombre);

if(op==1)


else if(op==2)


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();

eliminar(&l1);

printf ("\nLista eliminada completamente");

getch();

}

else if(op==7)

{ clrscr();

filtro_nombre(&l1);

printf ("\nNombres filtrados correctamente");

getch();

}

}

while(op!=8);

}

void almacenar(lista *l, char c[])

{pnodo nodo;


if (nodo==NULL)


return;

}





nodo->sig=*l;

*l=nodo;

}

void almacenar_fin(lista *l, char c[])

{pnodo nodo;


if (nodo==NULL)


return;

}




if(!*l)

{nodo->sig=*l;

*l=nodo;

}

else

{pnodo aux=*l;


aux=aux->sig;


aux->sig=nodo;

nodo->sig=NULL;

}

}

void almacenar_ord(lista *l, char c[])

{pnodo nodo,aux=*l;


if (nodo==NULL)


return;

}





if(!*l) //1A

{

nodo->sig=*l;

*l=nodo;

}

else if(strcmp(aux->nom,c)>0) //2A

{

nodo->sig=*l;

*l=nodo;

}

else //2B

{


aux=aux->sig;

nodo->sig=aux->sig;

aux->sig=nodo;

}

getch();

}


{pnodo n=l;

while (n)


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;

}

}

El Ministerio de Interior ha elaborado para el segundo semestre del año 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 número de años de sentencia.

Se necesita que el listado este en función de los más 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 más buscados, para

capturar y en dicho proceso debe ser retirado de la lista de más buscados y llevarlo a la lista de

capturados, mostrar la lista de más buscados, mostrar la lista de capturados, monto que invierte el

estado en la captura de los más 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

Clase # 15


•3 horas Tiempo



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)

{







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);

}


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-


}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)


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;

aux->sig=nodo->sig;

free(nodo);

}

}

}

}

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);

}

}

Clase # 16


•2 horas Tiempo



Clase # 17


•3 horas en una jornada Tiempo

•Lunes 01 de julio del 2013 Fecha





INFORMÁTICOS


Universidad Complutense de Madrid. Editorial Complutense

ISBN: 9788499380964

Serie: Extensión

Nº Edición: 1

Año de Edición: 2011

Tamaño: 210 x 290

Formato: Libro electrónico

M. Rodríguez Artalejo; P. A. González Calero; M. A. Gómez Martín

Este libro es el resultado de la experiencia adquirida por los autores impartiendo la

asignatura Estructuras de datos y de la información, en la Facultad de Informática de la

UCM, desde el curso 1995-96 hasta la actualidad. Como fruto de ese trabajo, además del

libro, se han generado transparencias de apoyo a las clases e implementaciones en C++

de todos los algoritmos descritos. Ese material adicional, disponible en la página

http://gaia.fdi.ucm.es/people/pedro/edem/, junto con el texto aquí presentado, da sentido al

moderno enfoque que ha servido de orientación a este trabajo. Hay libros de estructuras de

datos con un enfoque formal, alejado de los lenguajes de programación concretos, y

también hay libros menos formales y más preocupados por proporcionar detalles de

implementación, con un lenguaje concreto. Los autores de esta obra plantean la

aproximación de ambos enfoques. Es decir, proponen un planteamiento formal en la

presentación de los conceptos, acompañado de implementaciones ejecutables para el

material adicional.

MateriasCiencia y tecnología de los ordenadores. Informática.




INFORMÁTICOS


r.llj §j4¡¡1 Aa

i i r i ; i i i i ¡ i i rct'.ojrtietrr¡§lQ}ü r j ; ¡ i i ¡ i:'-, ,- r , l

r:i!

Crear una matriz de 10 x 10 y elabore una sopa de letra a fin de que contenga 5

palabras para que sean buscadas dentro de la matriz.

#include"stdio.h"

#include"conio.h"

void main()

{

clrscr();

char

matriz[10][10]={"XVCDLXBGQY","AIRGELAAHO","RRITANOTLD","AAMORPLIAP","CMRE

LADTCU","OIGISAAOVO","PRTERNURAK","FELICIDADL","WQDYTAUTQJ","CARISMAAZH

"};

printf("Encuentre en la sopa de letras las siguientes palabras:\n AMOR \n FELICIDAD \n

TERNURA \n CARISMA \n ALEGRIA \n");

printf("\n");


{

for(int y=0;y<10;y++)

printf(" %c",matriz[x][y]);

printf("\n");

}

getch();

}

En la siguiente pantalla se puede evidenciar lo que la línea de codificación citada

anteriormente realiza:

Las cinco palabras a buscar son amor, felicidad, ternura, carisma y alegria

En este tipo de leguaje como lo es el lenguaje c no se puede pasar una array completo

como argumento pero si podemos pasar a una función un puntero al primer elemento

del array previamente especificando el nombre del array sin índice. Es decir que la

declaración del parámetro de la función debe tener un tipo puntero compatible al

puntero del array.

Tomaremos como ejemplo este pequeño esqueleto de programa:

void main()

{

int peso[60];

convertir (peso)

/*…*/

}

Podemos declarar el parámetro de la función en tres formar para que una función

reciba un array unidimensional:

Como un array indeterminado

Como un puntero

Como un array delimitado

Como se puede notar en el ejemplo anterior el array peso debe ser recibido en la

función convertir ().

Array indeterminado: Especifica que se va a recibir en la función la dirección del array

de un tipo dado de cierta longitud.

void convertir (int primo[])

{

/*…*/

}

/*primo[] es un puntero a array*/

Podemos notar que el array peso tiene 60 elementos, pero primo es un puntero al

primer elemento del array peso.

Cabe destacar que la declaración del parámetro int primo[] no crea un array sino un

puntero ya que en la función convertir (peso) el argumento peso es un puntero al

primer elemento de los 60 elementos del array, debido a esto la llamada de la función

pasa un puntero a la función convertir().

Puntero: La función al ser llamada pasa una dirección que va a ser recibida en el

puntero.

void convertir (int *primo)

{

/*…*/

}

Aquí podemos ver que la función convertir () se puede utilizar en el array en forma

indexada o con “aritmética de punteros”.

Por o tanto tenemos dos formas para declarar los siguientes parámetros ya que ambas

son sinónimos debido a que ambas definen primo como un puntero a un entero la

diferencia es que primo[] apunta aun array y *primo apunta a una variable puntero.

int primo[]

int *primo

Array delimitado: Este consiste en la declaración estándar del array como parámetro

de la función.

void convertir (int primo[50])

{

/*…*/

}

Podemos concluir diciendo que el uso de cualquiera de los tres métodos de

declaración de los parámetros es idéntico ya que cada uno le indica al compilador que

se va a recibir un puntero a entero.

Se pueden realizar cambios en el array original del programa cuando empleemos el

nombre del array como argumento de una función ya que esta utiliza el puntero real

del array que llamo a la función.

Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de

datos de diferente tipo. Al contrario que los arrays, las estructuras tienen la ventaja que

nos permiten agrupar varios datos, que mantengan algún tipo de relación, aunque sean

de distinto tipo, permitiendo manipularlos todos juntos, usando un mismo identificador,

o cada uno por separado dependiendo de las necesidades del programador.

También está permitido anidar estructuras, con lo cual se pueden conseguir

superestructuras muy elaboradas, se las llama anidadas porque forman parte de otra

estructura es decir una estructura que contiene a otra estructura, de ahí nacen dos tipos

de estructuras anidadas: internas y externas.

Estructuras anidada interna:

Son aquellas que se las definen dentro de otras estructuras. Estas no pueden ser

creadas dentro de otras estructura solo se las puede llamar y cuando se las llama solo

sirven para esa estructura.

Este tipo de estructura es llamada así porque como su nombre mismo lo dice la

estructura anidada va internamente es decir dentro de la estructura que la va a

contener, como lo podemos ver en el ejemplo:

struct Profesor {

struct Estudiante {

char nombre[50];

char identidad[11];

};

int numest;

}a;

Estructura anidada externa:

Este tipo de estructura se la conoce así porque la anidación de las estructuras no va

completamente dentro de la estructura principal sino que hace el llamado de los

campos correspondientes a través de otra estructura que la contenga como lo veremos

en el ejemplo. Se ve claramente que podemos crear una estructura y en su interior otras

dos:

struct persona

{

char nombre [50];

int edad;

};

struct empresa

{

char nombre [50];

char empresa_tipo [50];

};

struct trabajador

{

struct persona currela;

struct empresa mi_empresa;

};

Nota: Dentro de una estructura la estructura anidad ya no puede tener variables

estructuradas.

Bibliografía:

Curso de C++/ google: http://c.conclase.net/curso/?cap=011

Estructuras / google: http://www.freewebs.com/jojaqui/Estructuras.pdf

http://arco.esi.uclm.es/~david.villa/pensar_en_C++/vol1/ch04s08.html

http://c.conclase.net/curso/?cap=011

http://www.freewebs.com/jojaqui/Estructuras.pdf

Con el último ejercicio realizado en la clase del día 20 de mayo del

2013 y apoyándose en la investigación de la Tarea 3.

Elija un tipo de estructura anidadas para aplicar y completar el

ejercicio

#include<stdio.h>

#include<conio.h>


void mostrar(struct sistema A);

void ingreso(sistema &A);

struct notas{ float lecciones;

float tareas;

float consultas;

float tgrupal;

float evaluacion; } ;

struct sistema{ char nombre[30];

char nivel[20];

struct notas NMC_MAT,NMC_PRO,NMC_ESD; };

void main()

{clrscr();

struct sistema A;

ingreso(A);

mostrar(A);

}

void ingreso(struct sistema &A){

cout<<"\nNombre: "; fflush(stdin); cin>>A.nombre;

cout<<"\nNivel:"; fflush(stdin); cin>>A.nivel;

cout<<"\nNOTAS DE MATEMATICAS\n";

cout<<"\nLecciones:"; fflush(stdin); do{

cin>>A.NMC_MAT.lecciones;}while(A.NMC_MAT.lecciones<1||A.NMC_MAT.lecciones>10);

cout<<"Tareas:"; fflush(stdin); do{

cin>>A.NMC_MAT.tareas;}while(A.NMC_MAT.tareas<1||A.NMC_MAT.tareas>10);

cout<<"Consultas:"; fflush(stdin); do{

cin>>A.NMC_MAT.consultas;}while(A.NMC_MAT.consultas<1||A.NMC_MAT.consultas>10);

cout<<"Trabajos Grupales:"; fflush(stdin); do{

cin>>A.NMC_MAT.tgrupal;}while(A.NMC_MAT.tgrupal<1||A.NMC_MAT.tgrupal>10);

cout<<"Evaluaciones:"; fflush(stdin);

do{cin>>A.NMC_MAT.evaluacion;}while(A.NMC_MAT.evaluacion<1||A.NMC_MAT.evaluaci

on>10);

clrscr();//Nuevo Materia a Ingrsar notas

cout<<"\nNOTAS DE PROGRAMACION\n";


cin>>A.NMC_PRO.lecciones;}while(A.NMC_PRO.lecciones<1||A.NMC_PRO.lecciones>10);


cin>>A.NMC_PRO.tareas;}while(A.NMC_PRO.tareas<1||A.NMC_PRO.tareas>10);


cin>>A.NMC_PRO.consultas;}while(A.NMC_PRO.consultas<1||A.NMC_PRO.consultas>10);


cin>>A.NMC_PRO.tgrupal;}while(A.NMC_PRO.tgrupal<1||A.NMC_PRO.tgrupal>10);


do{cin>>A.NMC_PRO.evaluacion;}while(A.NMC_PRO.evaluacion<1||A.NMC_PRO.evaluaci

on>10);

clrscr();//Nueva Materia a Ingresar notas

cout<<"\nNOTAS DE ESTRUCTURA DE DATOSs\n";


cin>>A.NMC_ESD.lecciones;}while(A.NMC_ESD.lecciones<1||A.NMC_ESD.lecciones>10);


cin>>A.NMC_ESD.tareas;}while(A.NMC_ESD.tareas<1||A.NMC_ESD.tareas>10);


cin>>A.NMC_ESD.consultas;}while(A.NMC_ESD.consultas<1||A.NMC_ESD.consultas>10);


cin>>A.NMC_ESD.tgrupal;}while(A.NMC_ESD.tgrupal<1||A.NMC_ESD.tgrupal>10);


do{cin>>A.NMC_ESD.evaluacion;}while(A.NMC_ESD.evaluacion<1||A.NMC_ESD.evaluacio

n>10);

}

void mostrar (struct sistema A)

{

clrscr();

cout<<"Nombre del estudiante:"<<A.nombre<<endl;cout<<"Nivel del

estudiante:"<<A.nivel<<endl;

cout<<"MATERIA DE MATEMATICAS: \n"<<"Lecciones\tTareas\tConsultas\tTrabajos

Grupales\tEvaluaciones"<<endl;

cout<<A.NMC_MAT.lecciones<<"\t\t "<<A.NMC_MAT.tareas<<"\t

"<<A.NMC_MAT.consultas<<"\t \t "<<A.NMC_MAT.tgrupal<<"\t

\t\t"<<A.NMC_MAT.evaluacion<<endl;

cout<<"MATERIA DE PROGRAMACION: \n"<<"Lecciones\t Tareas\t Consultas\t Trabajos

Grupales\t Evaluaciones"<<endl;

cout<<A.NMC_PRO.lecciones<<"\t\t "<<A.NMC_PRO.tareas<<"\t

"<<A.NMC_PRO.consultas<<"\t \t "<<A.NMC_PRO.tgrupal<<"\t

\t\t"<<A.NMC_PRO.evaluacion<<endl;

cout<<"MATERIA DE ESTRUCTURA DE DATOS: \n"<<"Lecciones\t Tareas\t Consultas\t

Trabajos Grupales\t Evaluaciones"<<endl;

cout<<A.NMC_ESD.lecciones<<"\t\t "<<A.NMC_ESD.tareas<<"\t

"<<A.NMC_ESD.consultas<<"\t \t "<<A.NMC_ESD.tgrupal<<"\t

\t\t"<<A.NMC_ESD.evaluacion<<endl;

getch();

}

Con la implementación de la función suma, sustituya su ejercicio para que emplee

punteros para agregar a los miembros de la estructura de datos fecha y poder obtener

la nueva fecha.

#include<conio.h>

#include<stdio.h>

#include<iomanip.h>

struct fecha{int dia;

int mes;

int anio;

};

void Pidefecha(struct fecha &f);

void Verfecha(struct fecha f);

void Verfecha(struct fecha f)

{ cout << setfill('0') << setw(2) << f.dia << '/'

<< setw(2) << f.mes << '/' << setw(4) << f.anio;

}

void Pidefecha(struct fecha &f)

{ char ch;

cout << "Escriba la Fecha de la forma dd/mm/aa:";

cin >> f.dia >> ch >> f.mes >> ch >> f.anio;

}

//crear el main

void main()

{clrscr();

struct fecha f1;

Pidefecha(f1);

cout << "\nFecha ingresada: ";

Verfecha(f1);

cout << " \nHe terminado..";

getch();

}

//Programa para sumar una cantidad cualquiera a la fecha

#include"stdio.h"

#include"conio.h"

#include "iomanip.h" //para utilizar los espacios setfill y setw


struct fecha{int dia, mes, anio;};

void pidefecha(struct fecha &f);

void verfecha(struct fecha f);

void suma(struct fecha &f);

void verfecha(struct fecha f)

{cout << setfill('O') << setw(2) << f.dia << '/' << setw(2) << f.mes << '/' << setw(4) <<

f.anio;}

void pidefecha(struct fecha &f)

{ char ch;

cout << "Escriba la fecha de la forma dd/mm/aa: ";

cin>> f.dia >> ch >> f.mes >> ch >> f.anio; }

void suma(struct fecha &f)

{ int a,*punt;punt=&a; cout<<"\nIngrese la cantidad a sumar: "; cin>>a;

f.dia=f.dia+*punt;

if (f.dia>30) {f.dia=f.dia-30;f.mes=f.mes+1;}

if (f.mes>12) {f.mes=1;f.anio=f.anio+1;}

cout <<"La fecha modificada es: "<< setfill('O') << setw(2) << f.dia << '/' << setw(2) <<

f.mes << '/' << setw(4) << f.anio << "\n";}

void main()

{textbackground(13); clrscr();

struct fecha f;

pidefecha(f);

cout<<"Fecha ingresada \t";

verfecha(f);

suma(f);

textcolor(9);cprintf("Precione enter para finalizar la ejecucion :P");

_setcursortype(_NOCURSOR);

getch();}

#include<conio.h>

#include<stdio.h>


#include<stdlib.h>

#include<string.h>


char nom[25];


}tipoAlumno;


typedef tipoAlumno *Lista;


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("\n3. Registrar Nombre ordenadamente");



do{ cin>>op;

}while ((op>5) ||(op<1));

if (op<=3)

{ char nombre[25];

clrscr();



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);

}}while(op!=5);

}

void almacenar(Lista *l, char c[])

{pnodo nodo;


if (nodo==NULL)


return;

}





nodo->sig=*l;

*l=nodo;

}

void almacenar_fin(Lista *l, char c[])

{pnodo nodo;


if (nodo==NULL)


return;

}




if(!*l)

{nodo->sig=*l;

*l=nodo;

}

else

{pnodo aux=*l;


aux=aux->sig;


aux->sig=nodo;

nodo->sig=NULL;

}

}

void almacenar_ord(Lista *l, char c[])

{pnodo nodo,aux=*l;


if (nodo==NULL)


return;

}





if(!*l) //1A

{

nodo->sig=*l;

*l=nodo;

}

else

{if(strcmp(aux->nom,c)>0) //2A

{

nodo->sig=*l;

*l=nodo;

}

else //2B

{


aux=aux->sig;

nodo->sig=aux->sig;

aux->sig=nodo;

}}

}

void ver_lista(Lista l)

{pnodo n=l;

while (n)


n=n->sig;

}

getch();

}

Crear una función que permita eliminar un nodo de las lista de nombres, realizado en

clase.

Además debe implementar una función que elimine toda la lista.

Incorpore en el menú las dos opciones y ejecute el programa.

#include<conio.h>

#include<stdio.h>


#include<stdlib.h>

#include<string.h>


char nom[25];


}tipoAlumno;


typedef tipoAlumno *lista;


void almacenar(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 main()

{

lista l1=NULL;

int op;

char nombre[25];

do{

clrscr();



printf("\n3. Registrar ordenadamente");


printf("\n5. Eliminar un elemento");

printf("\n6. Eliminar lista");


do{ cout<<"Opcion: ";cin>>op;

}while ((op>7) ||(op<1));

if (op<=3)

{ //char nombre[25];

clrscr();



fflush(stdin);

gets(nombre);

if(op==1)


else if(op==2)


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();

eliminar(&l1);

printf ("\nLista eliminada completamente");

getch();

}

}

while(op!=7);

}

void almacenar(lista *l, char c[])

{pnodo nodo;


if (nodo==NULL)


return;

}





nodo->sig=*l;

*l=nodo;

}

void almacenar_fin(lista *l, char c[])

{pnodo nodo;


if (nodo==NULL)


return;

}




if(!*l)

{nodo->sig=*l;

*l=nodo;

}

else

{pnodo aux=*l;


aux=aux->sig;


aux->sig=nodo;

nodo->sig=NULL;

}

}

void almacenar_ord(lista *l, char c[])

{pnodo nodo,aux=*l;


if (nodo==NULL)


return;

}





if(!*l) //1A

{

nodo->sig=*l;

*l=nodo;

}

else if(strcmp(aux->nom,c)>0) //2A

{

nodo->sig=*l;

*l=nodo;

}

else //2B

{


aux=aux->sig;

nodo->sig=aux->sig;

aux->sig=nodo;

}

getch();

}


{pnodo n=l;

while (n)


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);

}

}

El Ministerio de Interior ha elaborado para el segundo semestre del año 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 número de años de sentencia.

Se necesita que el listado este en función de los más 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 mas buscados, para

capturar y en dicho proceso debe ser retirado de la lista de más buscados y llevarlo a la lista de

capturados, mostrar la lista de mas buscados, mostrar la lista de capturados, monto que invierte el

estado en la captura de los más buscados, salir del programa.

#include "stdio.h"

#include "conio.h"

#include "stdlib.h"

#include "string.h"



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


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 ******";







registrar(&lmb, apellido, nombre, lugar, delito, valor, anio);

}

if (op==2)

{







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);

}


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)


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-


eliminar(&lmb,p->apellido, p->nombre, p->lugar_proceso, p->delito, p-


}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)


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;

aux->sig=nodo->sig;

free(nodo);

}

}

}

}

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);

}

}

.

Ejercicio # 1 del aporte.

#include"conio.h"

#include"string.h"


#include"stdio.h"

struct fdm{

char nombre[50];

char peso[10];

char talla[8];

float tiempo;

};

void main() {

clrscr();

struct fdm a[50];

//Ingreso de aspirantes

for(int i=0;i<4;i++) {

cout<<"\nNombre: ";gets(a[i].nombre);

cout<<"\nPeso: ";cin>>a[i].peso;

cout<<"\nTalla: ";cin>>a[i].talla;

cout<<"\nTiempo: ";cin>>a[i].tiempo; }

//mostrar aspirantes

clrscr();

cout<<"\nNombre\tPeso\tTalla\tTiempo";

for(int i=0;i<4;i++){

cout<<"\n"<<a[i].nombre;

.

.

cout<<"\t"<<a[i].peso;

cout<<"\t"<<a[i].talla;

cout<<"\t"<<a[i].tiempo<<"\n";}

getch();

}

.

FACULTAD DE CIENCIAS INFORMATICASTECCION DE ESTRUCTURA DE DATOS

ESTUDIANTE:

NIVEL: SEGUNDO "B"1. Responda SÍ ó NOy porque

:A5ltunl}AL3 Docente: lng. Christian Torres

ftÑayson porciones de memoria donde se aloja la información c¡ue se procesa en algún programa.

\US"{. lrr" grof,e'r¡ otr.g¡s¡o¡, c}rrccc\ooeb de rng§ñoc?ü rt)".",pc.sooóoi.

2. Pinte e, recuadro gue indica una correcta declaración de un puntero.

tA n Puntero &p; .--tr- struct ejemplo *q;

\ rV ,¡ úy'nt*P; n punterop;l' y'seteccione las afirmaciones correctas, si existen.

'-/ Asignar un puntero a una dirección de memoria:

tr Se lo realiza al momento de declarar una variable con la ayuda de operador de dirección (*) y la asignación(=).

^ Y Se lo realiza al momento de declarar una variable con la ayuda de operador de dirección {&}y la asignación(=).

U A Se_ lo realiza en cualquier momento de declarar una variable con la ayuda de operador de dirección {*iy la

qi/ " i,t"-lT"Tl=J asignar a puntero si tos tipos de datos no concuerdan.v/

V 4. Seleccionar la opción según sea lo correcto:

Puntero en estructuras:

,*-/,"8e pueden pasar estructuras nrediante punteros o se puede pasar simplemente un miembro (ocampo) de la estructura.El acceso a los campos de una estructura se realiza a través de operador punto {.)El acceso a los campos de una estructui'a se realiza a través de operador flecha (->)

Podemos por medio de punteros pasar o manipular parte de las esti'ucturas ;

:r

Seleccione la afirrnación incorrecta:

Asignar un puntero a estructuras para aeceder a un arrqy de estructura solo es posible indicandc¡ la posición clel

arra!; p=§¿ygctor_estrcutu rado[índice]Asignar un puntero a estructuras para acceder a la primera posición de un array de estructura es pnsible asignado alpuntero el array sin especificar los indices: p=vector_estrcuturado.Todas las anteriores.Ninguna de las anteriores

Marcar Ia opción correcta:

Para poder cambiar de dirección a un puntero a estructuras que recorre un array de estructuras:

E Se debe incrementar la dirección con el operador de incremento, previamente que este díreccionado en la

r1U

* I 0 / . i:ffiifi:'.Tir,r* a ta dirección del puntero de forma temporat, sin necesídad de mover ei puntero de ta

V primera posición delarray.t- [ No es posible realizar estas operaciones en array de estructuras.

7. Ejercicio de aplicación: Crear un programa gue utilice una estructura para alrnacenar rutas de busesidentificando placa, disco, chofer hora;salida, paradas, En donde paradas debe ser un array estructuradoque indique la hora en que realízo una parada. Empleando punteros a estructuras, que accedan a un

array de estructuras, para permitir el ingreso de 10 recorrido de buses, con sus respect¡vas paradas. No

utilice la variable de array de estructuras de ámbito local .

Firma:

#c.r

T.INIVER§IDAD TECNICA DE M,qNABI"/Vt

0 tr--f5.

os. ñ

il




INFORMÁTICOS


UNIVERSIDAD TECNICA DE MANABÍ

FACULTAD DE CIENCIAS INFORMATICAS

FACULTAD DE CIENCIAS INFORMATICAS

FCI - 2008

Autores:

Ing. Esthela San Andres

Ing. Christian Torres

ESTRUCTURA DE DATOS I

PROGRAMACIÓN EN C++

“Lo importante en un individuo, no es lo

que piensa, sino lo que hace”

J. Watson

Universidad Tecnica de Manabí Facultad de Ciencias Informaticas

Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres 1

ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

ESTRUCTURA DE DATOS I

PROGRAMACIÓN EN C++

Sistema de Información

Introducción.- Un sistema de información es un conjunto de elementos que interactúan 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 información pueda operar.

El recurso humano que interactúa con el Sistema de Información, el cual está formado por las personas que utilizan el sistema.

Un sistema de información realiza cuatro actividades básicas: entrada, almacenamiento, procesamiento y salida de información.

Entrada de Información: Es el proceso mediante el cual el Sistema de Información toma los datos que requiere para procesar la información. Las entradas pueden ser manuales o automáticas. Las manuales son aquellas que se proporcionan en forma directa por el usuario, mientras que las automáticas son datos o información que provienen o son tomados de otros sistemas o módulos. Esto último se denomina interfases automáticas.

Las unidades típicas de entrada de datos a las computadoras son las terminales, las cintas magnéticas, las unidades de diskette, los códigos de barras, los escáners, la voz, los monitores sensibles al tacto, el teclado y el mouse, entre otras.

Almacenamiento de información: El almacenamiento es una de las actividades o capacidades más importantes que tiene una computadora, ya que a través de esta propiedad el sistema puede recordar la información guardada en la sección o proceso anterior. Esta información suele ser almacenada en estructuras de información denominadas archivos. La unidad típica de almacenamiento son los discos magnéticos o discos duros, los discos flexibles o diskettes y los discos compactos (CD-ROM).

Procesamiento de Información: Es la capacidad del Sistema de Información para efectuar cálculos de acuerdo con una secuencia de operaciones preestablecida. Estos cálculos pueden efectuarse con datos introducidos recientemente en el sistema o bien con datos que están almacenados. Esta característica de los sistemas permite la transformación de datos fuente en información que puede ser utilizada para la toma de decisiones, lo que hace posible, entre otras cosas, que un tomador de decisiones genere una proyección financiera a partir de los datos que contiene un estado de resultados o un balance general de un año base.

Salida de Información: La salida es la capacidad de un Sistema de Información para sacar la información procesada o bien datos de entrada al exterior. Las unidades típicas de salida son las impresoras, terminales, diskettes, cintas magnéticas, la voz, los graficadores y los plotters, entre otros. Es importante aclarar que la salida de un Sistema de Información puede constituir la entrada a otro Sistema de Información o módulo. En este caso, también existe una interfase automática de salida. Por ejemplo, el Sistema de Control de Clientes tiene una interfase automática de salida con el Sistema de Contabilidad, ya que genera las pólizas contables de los movimientos procesales de los clientes.


Manual de Estructura de Datos 2

ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

A continuación se muestran las diferentes actividades que puede realizar un Sistema de Información de Control de Clientes:

Actividades que realiza un Sistema de Información:

Entradas:

• Datos generales del cliente: nombre, dirección, tipo de cliente, etc. • Políticas de créditos: límite de crédito, plazo de pago, etc. • Facturas (interfase automático). • Pagos, depuraciones, etc.

Proceso:

• Cálculo de antigüedad de saldos. • Cálculo de intereses moratorios. • Cálculo del saldo de un cliente.

Almacenamiento:

• Movimientos del mes (pagos, depuraciones). • Catálogo de clientes. • Facturas.

Salidas:

• Reporte de pagos. • Estados de cuenta. • Pólizas contables (interfase automática) • Consultas de saldos en pantalla de una terminal.

Las diferentes actividades que realiza un Sistema de Información se pueden observar en el diseño conceptual ilustrado en la en la figura 1.1.

Actividades que realiza un Sistema de Información, figura 1.1



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Tipos y Usos de los Sistemas de Información

Durante los próximos años, los Sistemas de Información cumplirán tres objetivos básicos dentro de las organizaciones:

1. Automatización de procesos operativos. 2. Proporcionar información que sirva de apoyo al proceso de toma de decisiones. 3. Lograr ventajas competitivas a través de su implantación y uso.

Los Sistemas de Información que logran la automatización de procesos operativos dentro de una organización, son llamados frecuentemente Sistemas Transaccionales, ya que su función primordial consiste en procesar transacciones tales como pagos, cobros, pólizas, entradas, salidas, etc. Por otra parte, los Sistemas de Información que apoyan el proceso de toma de decisiones son los Sistemas de Soporte a la Toma de Decisiones, Sistemas para la Toma de Decisión de Grupo, Sistemas Expertos de Soporte a la Toma de Decisiones y Sistema de Información para Ejecutivos. El tercer tipo de sistema, de acuerdo con su uso u objetivos que cumplen, es el de los Sistemas Estratégicos, los cuales se desarrollan en las organizaciones con el fin de lograr ventajas competitivas, a través del uso de la tecnología de información.

Los tipos y usos de los Sistemas de Información se muestran en la figura 1.2.

A continuación se mencionan las principales características de estos tipos de Sistemas de Información.

Sistemas Transaccionales. Sus principales características son:

• A través de éstos suelen lograrse ahorros significativos de mano de obra, debido a que automatizan tareas operativas de la organización.

• Con frecuencia son el primer tipo de Sistemas de Información que se implanta en las organizaciones. Se empieza apoyando las tareas a nivel operativo de la organización.

• Son intensivos en entrada y salid de información; sus cálculos y procesos suelen ser simples y poco sofisticados.

• Tienen la propiedad de ser recolectores de información, es decir, a través de estos sistemas se cargan las grandes bases de información para su explotación posterior.

• Son fáciles de justificar ante la dirección general, ya que sus beneficios son visibles y palpables.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Sistemas de Apoyo de las Decisiones. Las principales características de estos son:

• Suelen introducirse después de haber implantado los Sistemas Transaccionales más relevantes de la empresa, ya que estos últimos constituyen su plataforma de información.

• La información que generan sirve de apoyo a los mandos intermedios y a la alta administración en el proceso de toma de decisiones.

• Suelen ser intensivos en cálculos y escasos en entradas y salidas de información. Así, por ejemplo, un modelo de planeación financiera requiere poca información de entrada, genera poca información como resultado, pero puede realizar muchos cálculos durante su proceso.

• No suelen ahorrar mano de obra. Debido a ello, la justificación económica para el desarrollo de estos sistemas es difícil, ya que no se conocen los ingresos del proyecto de inversión.

• Suelen ser Sistemas de Información interactivos y amigables, con altos estándares de diseño gráfico y visual, ya que están 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 cuándo debe hacerse un pedido al proveedor o un Sistema de Simulación de Negocios que apoye la decisión de introducir un nuevo producto al mercado.

• Estos sistemas pueden ser desarrollados directamente por el usuario final sin la participación operativa de los analistas y programadores del área de informática.

• Este tipo de sistemas puede incluir la programación de la producción, compra de materiales, flujo de fondos, proyecciones financieras, modelos de simulación de negocios, modelos de inventar ios, etc .

Sistemas Estratégicos. Sus principales características son:

• Su función primordial no es apoyar la automatización de procesos operativos ni proporcionar información para apoyar la toma de decisiones.

• Suelen desarrollarse in house, es decir, dentro de la organización, por lo tanto no pueden adaptarse fácilmente a paquetes disponibles en el mercado.

• Típicamente su forma de desarrollo es a base de incrementos y a través de su evolución dentro de la organización. Se inicia con un proceso o función en particular y a partir de ahí se van agregando nuevas funciones o procesos.

• Su función 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 Estratégicos son creadores de barreras de entrada al negocio. Por ejemplo, el uso de cajeros automáticos en los bancos en un Sistema Estratégico, ya que brinda ventaja sobre un banco que no posee tal servicio. Si un banco nuevo decide abrir sus puertas al público, tendrá que dar este servicio para tener un nivel similar al de sus competidores.

• Apoyan el proceso de innovación 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Tipos de datos

� Bit . Unidad de in formación más senci l la en el s istema binar io.

� Byte. Unidad de información que consta de 8 bits equiva lente a un único carácter , como una let ra, número o s igno de puntuación.

� Carácter. Es un elemento tomado de un conjunto de s ímbolos . E jemplo : a,b,c,0 ,1,%=…

� Palabra. Conjunto de bi ts que pueden ser manipulados por una computadora.

La longitud de una pa labra en una computadora puede ser: 8, 16, 31, etc. Depende de l Microprocesador

Manipulación de bits

� Digital ización de la in formación. Se conv ierte texto, sonido o imágenes en formato que puede ser entendido por la PC.

� Los microprocesadores ent ienden e l formato de 0,1´s.

� Los microprocesadores detectan cuando un b it se carga y su va lor es igual a 1

� Se pueden representar una gran diversidad de va lores: verdad y fa lso, femenino y mascul ino, etc.

� La ef ic ienc ia de las pc´s no se basa en la complej idad de su lóg ica

� La ef ic ienc ia de las pc´s se basa en la ve loc idad de t rabajo.

� Ejemplo de combinac iones posib les: 2 bits , 8 bits

� Si se ut i l i zan 8 bits para representar un carácter, se pueden representar hasta 256 caracteres d i ferentes, puesto que ex isten 256 patrones o combinaciones diferentes de 8 b its.

� Los computadores d i f ieren con respecto a l número de bits ut i l i zados para representar un carácter

Clasificación de los t ipos de datos

� En func ión de quien los def ine:

o Tipos de datos estándar.

o Tipos de datos def inidos por e l usuar io

� En func ión de la representación interna:

o Tipos de datos escalares o s imples

o Tipos de datos est ructurados.

� Los t ipos de datos simples son los s iguientes :

◦ Numér icos ( Integer, Real ) ·

◦ Lógicos (Boolean) ·

◦ Carácter (Char, St r ing) ·



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Representación de datos simples

� Dato. Representación forma de hechos, conceptos o inst rucciones

� Tipo de dato. Un conjunto de va lores, aquel los que puede tomar cualquier dato de d icho t ipo.

� Las var iab les y constantes que forman parte de un programa pertenecen a un t ipo de datos determinado. De esta forma, los va lores asociados a dichas var iab les (o constantes) pueden operar con ot ros de acuerdo a su naturaleza (p . e. dos números enteros pueden ser mult ip l icados pero no t iene sent ido hacer esa operación con cadenas de caracteres) .

� NUMEROS ENTEROS

� Si ut i l i zamos 32 bits para representar número enteros, disponemos de 2^32 combinac iones d i ferentes de 0 y 1`s:

4294967296 va lores.

Como tenemos que representar número negat ivos y e l cero:

-2 147 483 648 a l +2 147 483 647

� NUMEROS REALES.

(+|-) mantisa x 2e xp on e nte

En la notación del punto f lotante un número real está representado por una hi lera de 32 bits formada por una mantisa de 24 bits seguida de un exponente de 8 bits.

La base se f i ja como 10. Tanto la mant isa como el exponente son enteros binar ios de complemento doble.

T ipos de datos abstractos

� Un t ipo de datos abstracto – TDA def ine una nueva c lase de ob jeto o concepto que puede manejarse con independencia de la est ructura de datos para representar lo .

Para e l lo es necesar io espec if icar:

� Las operac iones que se puede rea l i zar con los objetos .

� El e fecto que se produce a l actuar con las operac iones sobre los mismos.

� . Un TDA encapsula la def inic ión de l t ipo y todas las operaciones con este t ipo.

� Los lenguajes de programación entregan al programador c iertos t ipos de datos básicos o pr imit ivos, especif icando e l conjunto de va lores que una var iab le de uno de esos t ipos puede tomar y el conjunto de operac iones rea l i zables sobre los mismos.

� Por e jemplo, s i se dec lara en C/C++

� unsigned int x , y ;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

� La instrucc ión n = 9+10 de un programa donde = es el operador de asignac ión, el contenido de la loca l idad de almacenamiento dado por n será e l va lor 19.

Cada t ipo de datos : es reconoc ido por los e lementos de datos que puede tomar y por las operaciones asoc iadas a é l . (su domin io) E jemplo : en pascal

� Dominio entero D={0,1,2….max}

� Operaciones

Los TDAs son general i zac iones de los t ipos de datos bás icos y de las operac iones pr imit ivas . Un TDA encapsula t ipos de datos en el sent ido que es pos ible poner la def in ic ión de l t ipo y todas las operaciones con ese t ipo en una secc ión de un programa.

Por ejemplo, se puede def in ir un t ipo de datos abstracto CONJUNTO [Aho1988] con e l cual se pueden def in i r las s iguientes operaciones:

� ANULA(A)

� Hace vacío a l conjunto A

� UNION(A, B, C)

� Construye el conjunto C a part i r de la un ión de los conjuntos A y B.

� TAMAÑO(A)

� Entrega la cant idad de elementos de l conjunto A.

E l componente bás ico de una est ructura de datos es la celda.

� La celda a lmacena un valor tomado de a lgún t ipo de dato s imple o compuesto

� El mecanismo de agregación de celdas l lamado ar reglo es una co lección de elementos de t ipo homogéneo.

Ar reglo b idimensional en C/C++

int w[5][3]

� w[ i ] [ j ] = b[ i * n + j ]

� n es la cant idad de columnas del ar reglo

� w[2] [0] = b[6]



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Estructuras de datos Son datos elementales aquel los que se consideran indivisibles en unidades más simples.

Una est ructura de datos es una c lase de datos que se puede caracter izar por su organizac ión y operaciones def in idas sobre e l la . A lgunas veces a estas est ructuras se les l lama t ipos de datos.

Los t ipos de datos más frecuentes ut i l i zados en los d i ferentes lenguajes de programación son:

Lógicas de datos.- En un programa, cada var iable pertenece a alguna est ructura de datos exp l íc i ta o impl íc i tamente def in ida, la cual determina el conjunto de operac iones va l idas para e l la.

Primit ivas y simples.- Aquel las que no están compuestas por ot ras est ructuras de datos por ejemplo, enteros, booleanos y caracteres.

Lineales: pi las , colas y l istas l igadas l ineales.

No lineales incluyen grafos y árboles.

Organización de archivos.-Las técnicas de estructuración de datos apl icadas a conjuntos de datos que los s istemas operat ivos manejan como ca jas negras comúnmente se l laman Organizac ión de Arch ivos.

CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS Se clasifican en:

a) Por su almacenamiento b) Por su organización 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 organización.- Se clasifican en:

Estáticas Dinámicas

Estáticas.- son aquellas cuya agrupación de memoria no se disminuye o aumenta estas son: cadenas, conjuntos, escalares, entre otros. Dinámicas.- Son aquellas cuya agrupación de memoria pueden aumentar o disminuir durante la ejecución del programa, estas son: pila, colas, listas. d) Por su comportamiento.- Se clasifican en:

Simples Compuesto o Estructurados

Simples.-Son aquellas que almacenan un valor y son:

Enteros Real Lógicos Caracteres

Escalares



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Enteros Reales Simples Caracteres Cadena Booleano Arreglo

Estático Conjunto Registro

Listas Estructurados Lineales Pilas Colas Dinámicos No Lineales Árboles Grafos

Compuesto.- Son aquellos que almacenan múltiples valores en su estructura y son los siguientes:

Cadenas Arreglos Conjuntos Registros Listas Pilas Colas Árboles Archivos Base de datos

Los t ipos de datos simples pueden ser organizados en di ferentes est ructuras de datos : estát icas y dinámicas.

Las estructuras de datos estáticas: Son aquel las en las que el tamaño ocupado en memoria se def ine antes de que e l programa se ejecute y no puede modif icarse dicho tamaño durante la e jecuc ión de l programa.

Estas est ructuras están implementadas en casi todos los lenguajes.

Su pr inc ipa l caracter ís t ica es que ocupan so lo una casi l la de memor ia, por lo tanto una var iable s imple hace referenc ia a un único valor a la vez , dentro de este grupo

Cla

sif

ica

ció

n d

e l

as

es

tru

ctu

ra

s d

e D

ato

s



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

de datos se encuentra : enteros , reales, caracteres, bo léanos, enumerados y subrangos ( los últ imos no ex isten en algunos lenguajes de programación)

Las estructuras de datos dinámicas: No t ienen las l imitac iones o rest r icciones en el tamaño de memor ia ocupada que son prop ias de las est ructuras estát icas .

Mediante el uso de un t ipo de datos especif ico, denominado puntero, es posib le construi r est ructuras de datos dinámicas que no son soportadas por la mayoría de los lenguajes, pero que en aquel los que s i t ienen estas caracter íst icas of recen so luciones ef icaces y efect ivas en la solución de problemas complejos.

Se caracter iza por el hecho de que con un nombre se hace referencia a un grupo de casi l las de memor ia. Es dec i r un dato est ructurado t iene var ios componentes.

VARIABLES ESTRUCTURADAS O ARREGLOS

CONJUNTO DE DATOS DEL MISMO DEL MISMO TIPO AGRUPADOS BAJO UN SOLO NOMBRE Para refer i rnos a uno de el los se hace referenc ia a la posic ión que ocupa el dato respecto a los ot ros. Pueden ser unidemsionales (vectores) mult id imensionales ( matr ices )

E j :

voca l={a,e, i ,o,u }

La l ista de c lase con notas

VECTORES Arreglos unidimensinales:

Ejemplo:

• Lista de Clase

• Cola para comprar t ickest

• Vocales del abecedario .

OPERACIONES CON VECTORES Podemos hacer con un vector:

• Llenar

• Mostrar

• Ordenar

• Buscar:

• Secuencia l

• Binaria



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Estructuras

Supongamos que queremos hacer una agenda con los números de teléfono de nuestros amigos. Necesitaríamos un array de Cadenas para almacenar sus nombres, otro para sus apellidos y otro para sus números de teléfono. Esto puede hacer que el programa quede desordenado y difícil 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 extraños.

Para nuestro ejemplo podemos crear una estructura en la que almacenaremos los datos de cada persona. Vamos a crear una declaración 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, teléfono) se le llama campo o miembro. (NOTA: He declarado edad como char porque no conozco a nadie con más de 127 años.

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 aplicación de esta estructura. (NOTA: En el siguiente ejemplo los datos no se guardan en disco así que cuanda acaba la ejecución 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 número de teléfono del amigo: " ); fflush( stdout ); scanf( "%s", &amigo.telefono ); printf( "El amigo %s %s tiene el número: %s.\n", amigo.nombre, amigo.apellido, amigo.telefono ); }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Este ejemplo estaría mejor usando gets que scanf, ya que puede haber nombres compuestos que scanf no cogería por los espacios.

Se podría 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 información de varios amigos. Con una variable de estructura sólo podemos guardar los datos de uno. Para manejar los datos de más gente (al conjunto de todos los datos de cada persona se les llama REGISTRO) necesitamos declarar arrays de estructuras.

¿Cómo se hace esto? Siguiendo nuestro ejemplo vamos a crear un array de ELEMENTOS elementos:

struct estructura_amigo amigo[ELEMENTOS];

Ahora necesitamos saber cómo 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 número %i:\n", num_amigo+1 ); printf( "Nombre: " ); fflush( stdout ); gets(amigo[num_amigo].nombre); printf( "Apellido: " ); fflush( stdout ); gets(amigo[num_amigo].apellido); printf( "Teléfono: " ); 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 );



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

printf( "%i años ", amigo[num_amigo].edad ); printf( "y su teléfono es el %s.\n" , amigo[num_amigo].telefono ); } } IMPORTANTE: Quizás alguien se pregunte qué pinta la línea esa de while(getchar()!='\n');. Esta línea se usa para vaciar el buffer de entrada. Para más información consulta Qué son los buffer y cómo funcionan.

Inicializar una estructura

A las estructuras se les pueden dar valores iniciales de manera análoga a como hacíamos 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 sería 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 definición 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 más de 29 letras (recordemos que hay que reservar un espacio para el símbolo '\0'), el apellido ("Lopez") una cadena de menos de 39, el teléfono una de 9 y la edad debe ser de tipo char.

Vamos a ver la inicialización de estructuras en acción:

#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 años ", amigo.edad ); printf( "y su teléfono es el %s.\n" , amigo.telefono );



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

}

También 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 línea es un registro. Como sucedía en los arrays si damos valores iniciales al array de estructuras no hace falta indicar cuántos 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 función igual que hacíamos con las variables. Por supuesto en la definición de la función debemos indicar el tipo de argumento que usamos:

int nombre_función ( struct nombre_de_la_estructura nombre_de_la variable_estructura )

En el ejemplo siguiente se usa una función llamada suma que calcula cual será la edad 20 años más tarde (simplemente suma 20 a la edad). Esta función 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 función 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; }; struct estructura_amigo amigo = { "Juanjo", "Lopez", "592-0483", 30 }; int suma( struct estructura_amigo arg_amigo ) { return arg_amigo.edad+20; } int main()



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

{ printf( "%s tiene ", amigo.apellido ); printf( "%i años ", amigo.edad ); printf( "y dentro de 20 años tendrá %i.\n", suma(amigo) ); }

Si dentro de la función suma hubiésemos cambiado algún 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.

También 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 código 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 años ", amigo.edad ); printf( "y dentro de 20 años tendrá %i.\n", suma(&amigo) ); } Lo primero será indicar a la función suma que lo que va a recibir es un puntero, para eso ponemos el * (asterisco). Segundo, como dentro de la función 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 dirección 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, según cómo se mire) de poder cambiar los datos de la estructura de la variable amigo de main.

Pasar sólo miembros de la estructura

Otra posibilidad es no pasar toda la estructura a la función sino tan sólo los miembros que sean necesarios. Los ejemplos anteriores serían más correctos usando esta tercera opción, ya que sólo usamos el miembro 'edad':

int suma( char edad ) { return edad+20; } int main() { printf( "%s tiene ", amigo.apellido ); printf( "%i años ", amigo.edad ); printf( "y dentro de 20 años tendrá %i.\n", suma(amigo.edad) ); } Por supuesto a la función suma hay que indicarle que va a recibir una variable tipo char (amigo->edad es de tipo char).



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 más ordenada. Imaginemos la siguiente situación: una tienda de música quiere hacer un programa para el inventario de los discos, cintas y cd's que tienen. Para cada título quiere conocer las existencias en cada soporte (cinta, disco, cd), y los datos del proveedor (el que le vende ese disco). Podría 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 podría hacer de esta otra forma más 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 número de cd de cierto título usaríamos lo siguiente:

inventario.existencias.cd

y para acceder al nombre del proveedor:

inventario.proveedor.nombre



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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. Además 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 hipotético programa que dibuja una gráfica:

unsigned char x0, y0; /* Coordenadas del punto origen */

unsigned char x1, y1; /* Coordenadas del punto final */

unsigned char x, y; /* Coordenadas de un punto genérico */

int F; /* valor de la función en el punto (x,y) */

int i; /* Esta la usamos como contador para los bucles */

La definición del tipo unsigned char aparte de ser larga no nos da información de para qué se usa la variable, sólo 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 podríamos hacer:

typedef unsigned char COORD;

typedef int CONTADOR;

typedef int VALOR;

y ahora quedaría:

COORD x0, y0; /* punto origen */

COORD x1, y1; /* punto final */

COORD x, y; /* punto genérico */

VALOR F; /* valor de la función en el punto (x,y) */

CONTADOR i;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Ahora, nuestros nuevos tipos de datos, aparte de definir el tipo de variable nos dan información 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 más cómodo para trabajar y con sentido para nosotros.

Punteros

También 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

También podemos declarar tipos array. Esto puede resultar más cómodo 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

También 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;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Asignación de Memoria Dinámica

Métodos de Asignación de Memoria

¿Cuáles son los métodos de asignación 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 métodos de asignación de memoria utilizados para su almacenamiento. Por un lado, se tiene la asignación estática de memoria en donde se reserva la cantidad necesaria para almacenar los datos de cada estructura en tiempo de compilación. Esto ocurre cuando el compilador convierte el código fuente (escrito en algún lenguaje de alto nivel) a código objeto y solicita al S.O. la cantidad de memoria necesaria para manejar las estructuras que el programador utilizó, quien según ciertos algoritmos de asignación de memoria, busca un bloque que satisfaga los requerimientos de su cliente. Por otro lado se tiene la asignación dinámica en donde la reserva de memoria se produce durante la ejecución del programa (tiempo de ejecución). Para ello, el lenguaje Pascal cuenta con dos procedimientos: NEW() y DISPOSE() quienes realizan llamadas al S.O. solicitándole un servicio en tiempos de ejecución. El procedimiento NEW ,por su parte, solicita reserva de un espacio de memoria y DISPOSE la liberación de la memoria reservada a través de una variable especial que direccionará el bloque asignado o liberado según sea el caso.

Ejemplo : Cuando se compilan las sgtes. Líneas de código se produce una asignación estática 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)

interes : integer;

(*Se solicita memoria para 1 entero --> 2 bytes)

¿Cuántos bytes se reservarían para:?

datos: array [1..25] of double;

Para explicar con mayor detalle el concepto de memoria dinámica es necesario conocer el concepto ¡PUNTEROS!



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Punteros

Son tipos de datos simples capaces de almacenar la posición 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 explicación.- Un puntero es un objeto que apunta a otro ob jeto. Es deci r , una var iable cuyo va lor es la d i rección de memoria de ot ra var iable.

No hay que confundi r una di recc ión de memor ia con el contenido de esa d i rección de memor ia .

int x = 25;

D i rección 1502 1504 1506 1508

La di recc ión de la var iable x (&x) es 1502

El contenido de la var iable x es 25

Las di recciones de memoria dependen de la arquitectura de l ordenador y de la gest ión que e l s istema operat ivo haga de e l la.

En lenguaje ensamblador se debe ind icar numéricamente la pos ic ión f ís ica de memor ia en que queremos a lmacenar un dato. De ahí que este lenguaje dependa tanto de la máquina en la que se apl ique.

En C no debemos, n i podemos, ind icar numér icamente la di recc ión de memoria, s i no que ut i l izamos una et iqueta que conocemos como var iab le (en su día def inimos las var iab les como di recciones de memoria) . Lo que nos interesa es almacenar un dato, y no la loca l i zac ión exacta de ese dato en memoria.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Una var iab le puntero se dec lara como todas las var iab les. Debe ser del mismo t ipo que la var iab le apuntada. Su ident i f icador va precedido de un aster isco (*) :

int *punt;

Es una var iab le puntero que apunta a var iab le que cont iene un dato de t ipo entero l lamada punt.

char *car:

Es un puntero a var iable de t ipo carácter .

long f loat *num;

f loat *mat[5] ; // . . .

Es deci r : hay tantos t ipos de punteros como t ipos de datos, aunque también pueden declararse punteros a estructuras más comple jas ( func iones, st ruct , f icheros . . . ) e incluso punteros vac íos (void ) y punteros nulos (NULL).

Dec larac ión de var iab les puntero: Sea un f ragmento de programa en C:

char dato; //var iab le que almacenará un carácter.

char *punt; //dec laración de puntero a carácter .

punt = &dato; //en la var iab le punt guardamos la d i rección // de memoria de la var iab le dato; punt apunta // a dato . Ambas son del mismo t ipo, char.

int *punt = NULL, var = 14;

punt = &var;

pr intf (“%#X, %#X”, punt, &var ) // la misma sal ida: di rección

pr intf (“\n%d, %d”, *punt, var ) ; //sa l ida: 14, 14

Hay que tener cuidado con las di recciones apuntadas:

pr intf (“%d, %d”, *(punt+1), var+1);

*(punt + 1) repesenta el valor contenida en la d i rección de memoria aumentada en una posic ión ( int=2bytes) , que será un valor no deseado. Sin embargo var+1 representa e l va lor 15.

punt + 1 representa lo mismo que &var + 1 (avance en la d irecc ión de memoria de var ) .

A l t rabajar con punteros se emplean dos operadores espec íf icos :

� Operador de d i rección: & Representa la di recc ión de memoria de la var iab le que le s igue:

&fnum representa la di recc ión de fnum.

� Operador de contenido o ind irecc ión: *

El operador * apl icado al nombre de un puntero ind ica el va lor de la var iab le apuntada:

f loat a l tura = 26.92, *apunta;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

apunta = &altura; // in ic ia l i zac ión del puntero

f loat a l tura = 26.92, *apunta;

apunta = &altura; // in ic ia l i zac ión del puntero

.pr intf ( “\n%f”, a l tura) ; //sa l ida 26.92

.pr intf ( “\n%f”, *apunta) ;

No se debe confundi r e l operador * en la declaración de l puntero:

int *p;

Con el operador * en las inst rucciones:

*p = 27;

p r intf ( “\nContenido = %d”, *p);

Veamos con un e jemplo en C la di ferenc ia entre todos estos conceptos

Veamos el arch ivo

- punt0.cpp

- punt1.cpp

Es dec i r : int x = 25, *p int ;

p int = &x;

La var iable p int cont iene la d irecc ión de memor ia de la var iab le x . La expresión: *pint representa el va lor de la var iab le (x) apuntada, es dec i r 25. La var iable p int también t iene su prop ia di rección: &pint

Veamos con ot ro ejemplo en C la di ferenc ia entre todos estos conceptos

vo id main(vo id) {

int a, b, c , *p1, *p2;

vo id *p;

p1 = &a; // Paso 1. La di rección de a es asignada a p1

*p1 = 1; // Paso 2. p1 (a ) es igual a 1. Equiva le a a = 1;

p2 = &b; // Paso 3. La d i rección de b es asignada a p2

*p2 = 2; // Paso 4. p2 (b) es igual a 2. Equiva le a b = 2;

p1 = p2; // Paso 5. El va lor de l p1 = p2

*p1 = 0; // Paso 6. b = 0

p2 = &c; // Paso 7. La d i rección de c es asignada a p2

*p2 = 3; // Paso 8. c = 3

pr intf ( "%d %d %d\n", a, b, c ) ; // Paso 9. ¿Qué se imprime?

p = p1; // Paso 10. p cont iene la di rección de p1

p = p2; // Paso 11. p1= p2;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

*p1 = 1; // Paso 12. c = 1

pr intf ( "%d %d %d\n", a, b, c ) ; // Paso 13. ¿Qué se impr ime?

}

Vamos a hacer un seguimiento de las di recc iones de memoria y de los valores de las var iab les en cada paso. Suponemos que la var iab le a es co locada en la di recc ión 0000, b en la s iguiente, es deci r 0002, con un offset de 2 bytes, por ser valores integer .

Se t rata de un sistema de pos ic iones re lat ivas de memoria. Se verá en ar i tmética de punteros.

Se obt iene e l s igu iente cuadro. En él ref le jamos las di recciones re lat ivas de memor ia y los cambios en cada uno de los pasos marcados:

In ic ia l i zac ión de punteros( I ) :

S i <Almacenamiento> es extern o stat ic , <Expres ion> deberá ser una expres ión constante del t ipo <Tipo> expresado.

Si <Almacenamiento> es auto, entonces <Expres ion> puede ser cualquier expres ión del <Tipo> espec if icado.

Ejemplos:

1) La constante entera 0, NULL (cero) proporc iona un puntero nulo a cualquier t ipo de dato:

int *p;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

p = NULL; //actual ización

2) El nombre de un ar ray de a lmacenamiento stat ic o extern se t ransforma según la expresión:

a ) f loat mat [12];

f loat *punt = mat;

b) f loat mat [12];

f loat *punt = &mat[0] ;

3) Un “cast” puntero a puntero:

int *punt = ( int *) 123.456;

Inic ia l i za e l puntero con e l entero .

4) Un puntero a carácter puede inic ia l i zarse en la forma:

char *cadena = Esto es una cadena”;

5) Se pueden sumar o restar valores enteros a las direcc iones de memoria en la forma: (ar i tmét ica de punteros)

stat ic int x ;

int *punt = &x+2, *p = &x-1;

6) Equiva lencia: Dos t ipos def inidos como punteros a objeto P y puntero a objeto Q son equivalentes só lo s i P y Q son de l mismo t ipo. Apl icado a matr ices:

nombre_puntero = nombre_matr iz ;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

PUNTEROS Y ARRAYS Sea el array de una dimensión:

int mat [ ] = {2, 16, -4, 29, 234, 12, 0, 3} ;

en e l que cada e lemento, por ser t ipo int , ocupa dos bytes de memoria.

Suponemos que la di rección de memoria del pr imer elemento, es 1500:

&mat[0] es 1500

&mat[1] será 1502

&mat[7] será 1514

int mat [ ] = {2 , 16, -4 , 29, 234, 12, 0, 3} ;

En total los 8 elementos ocupan 16 bytes.

Podemos representar las di recciones de memor ia que ocupan los elementos de l ar ray , los datos que cont iene y las posic iones del array en la forma:

Di rección 1500 1502 1504 1506 1508 1510 1512 1514 E lemento mat [0] mat [1] mat [2] mat [3] mat [4] mat [5] mat [6] mat[7] E l acceso podemos hacerlo mediante el índice:

x = mat[3]+mat[5] ; // x = 29 + 12

para sumar los elementos de la cuarta y sexta pos ic iones.

Como hemos d icho que podemos acceder por pos ic ión y por di rección: ¿Es lo mismo &mat[0] y mat?

Y &mat[1] = mat++ ?

Veamos el código de un ejemplo:

#inc lude <stdio.h>

#inc lude <conio.h>

int mat[5]={2, 16, -4, 29, 234, 12, 0 , 3} , i ; //declaradas como globales

vo id main() {

p r intf ( "\n%d", &mat[0] ) ; //resultado: 1500 (di rección de mem)

p r intf ( "\n%p", mat ) ; //resultado: 1500 ( " " " " " )

i++; // i=1

p r intf ( "\n%p", mat+i) ; //resultado: 1502 ( " " " " " )

p r intf ( "\n%d", *(mat+i) ) ; //resultado: 16 (va lor de mat[1] o valor

getch( ) ; }

E jemplo



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Parece deduci rse que accedemos a los e lementos del array de dos formas:

- mediante e l subíndice.

- mediante su d irecc ión de memor ia.

E lemento mat[0] mat [1] mat [2] mat[3] mat [4] mat [5] mat [6] mat[7]

Analizando las direcciones de memoria del array:

De lo anter ior se obt ienen var ias conclusiones:

- Es lo mismo &mat[0] que mat, &mat[2] que mat + 2

- Para pasar de un e lemento a l s igu iente , es lo mismo:

Que el código:

A esta forma de desplazarse en memoria se le l lama



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Aritmética de punteros

- A una var iable puntero se le puede asignar la dirección de cualquier objeto .

- A una var iab le puntero se le puede asignar la dirección de otra var iable puntero (s iempre que las dos señalen e l mismo objeto)

- A un puntero se le puede in ic ial izar con el valor NULL

- Una var iab le puntero puede ser restada o comparada con ot ra s i ambas apuntan a elementos de un mismo array.

- Se puede sumar o restar va lores enteros : p++, pv+3, teniendo en cuenta que el desplazamiento (offset ) depende de l t ipo de dato apuntado:

p++; //p apunta a la s igu iente di recc ión

pv+=3 // pv apunta 3*nº bytes de l dato apuntado (of fset )

S i tenemos:

f loat *dec imal; //suponemos que apunta a 0000

dec imal++; //apunta a 0004

- Observar las s iguientes inst rucciones:

int *p;

double *q;

void *r ; //puntero genér ico

p = &34; // las constantes no t ienen dirección

p = &( i+1); // las expresiones no t ienen di rección

&i = p; // las d irecc iones no se pueden cambiar

p = q ; // i legal

p = ( int *)q; // lega l



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Uti l i zando la aritmética de punteros nos desplazamos de unas posic iones de memor ia a ot ras. Pero. ¿cómo acceder a los contenidos de esas pos ic iones ut i l izando notac ión de punteros?

Empleamos el operador * , indirección que nos da e l contenido de la di rección de memor ia apuntada.

Y. . . ¿cómo se apl ica la ar i tmét ica de punteros para desplazarnos en un ar ray bidimensional?:

f loat mat[2] [4] ; //declarac ión de l ar ray

Ut i l i zando punteros, la dec larac ión será:

f loat (*mat) [4] ; //array b idimensional

En donde mat es un puntero a un grupo cont iguo de ar rays monodimensionales (vectores) de 4 elementos cada uno.

Ex iste, por tanto una equiva lencia:

Recordemos que *mat representa un puntero a la pr imera fi la. A la segunda f i la nos refer imos mediante *(mat+1)+j para las direcciones y con *(*(mat+1)+j ) para los contenidos. El segundo subíndice actua sobre la co lumna.

Si en x [10][20] qu iero acceder al e lemento de la f i la 3 y la columna 6, lo hago escr ib iendo x [2][5] . Con notac ión de punteros , es equiva lente a

* ( * ( x + 2 ) +5)



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

ya que x + 2 es un puntero a la f i la 3. Por tanto. E l contenido de dicho puntero, *(x+2), es la f i la 3. Si me desplazo 5 pos ic iones en esa f i la l lego a la posic ión *(x+2)+5, cuyo contenido es *(*(x+2)+5). Ver dibu jo:

S i en x [10][20] qu iero acceder al e lemento de la f i la 3 y la columna 6, lo hago escr ib iendo x [2] [5] . Con notac ión de punteros, lo que hacemos es considerar que es un ar ray formado por 10 ar rays unidimensionales (vectores) de 20 elementos cada uno, de modo que accedo a x [2] [5] mediante la expres ión:

* ( * ( x + 2 ) +5)

ya que x + 2 es un puntero a la f i la 3. Por tanto. E l contenido de dicho puntero, *(x+2), es la f i la 3. Si me desplazo 5 pos ic iones en esa f i la l lego a la posic ión *(x+2)+5, cuyo contenido es *(*(x+2)+5). Las sigu ientes expres iones con punteros son vá l idas:

**x x [0] [0] ; *(*(x+1) ) x [1] [0]

*(*x+1) x [0] [1] ; **(x+1) x [1] [0]

Si en

int array[ f i las ] [columnas] ;

Quiero acceder a l e lemento ar ray [y ] [z ] para asignarle un va lor , lo que e l compi lador hace es :

*(*array +columnas x y + z)) = 129; //asignac ión

Si fuera int ar ray [2] [5] y quis iera as ignar 129 al e lemento de la f i la 1 y co lumna 2, pondría:

* (ar ray + 5x1 + 1)) = 129;

es deci r , desde e l or igen del ar ray avanza 6 posiciones de memoria:



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

PUNTEROS A ARRAYS MATRICES Un array mult idimensional es, en real idad, una co lección de vectores. Según esto, podemos def in ir un ar ray b idimensional como un puntero a un grupo cont iguo de ar rays un id imensionales. Las dec larac iones siguientes son equiva lentes:

int dat [f i l ] [co l ] int (*dat) [col ]

En genera l :

t ipo_dato nombre[d im1][dim2] . . . . . [d imp]; equiva le a:

t ipo_dato (*nombre) [dim2][d im3]. . . . . [d imp];

E l ar ray: int va lor [x ] [y ] [z ] ;

Puede ser representado en la forma:

int (*va lor ) [y ] [z] ;

O como un ARRAY DE PUNTEROS:

int *valor [x ] [y ] ;

s in paréntesis

En su nueva dec laración desaparece la ú lt ima de sus dimensiones.

Veamos más declarac iones de arrays de punteros :

int x [10] [20]; int *x[10];

f loat p [10] [20] [30]; int *p[10][20];



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Punteros a CADENAS DE CARACTERES

Una cadena de caracteres es un ar ray de caracteres . La forma de def in i r un puntero a una cadena de caracteres:

char *cadena;

El ident i f icador del ar ray es la di recc ión de comienzo del array. Para saber dónde termina la cadena, el compi lador añade el carácter ‘\0’ (ASCI I 0, NULL):

char *nombre = “PEPE PEREZ”;

ARRAYS DE PUNTEROS A CADENAS DE CARACTERES En un ar ray de punteros a cadenas de caracteres cada elemento apunta a un carácter. La declarac ión será:

char *cad[10]; //por e jemplo

Gráf icamente podría ser:

- si las dimensiones no son conoc idas, sabremos dónde comienzan las cadenas, pero no dónde terminan. Para el lo se efectúa la l lamada reserva dinámica de memoria ( funciones mal loc, cal loc( ) , rea l loc( ) y f ree() de stdl ib.h ó al loc.h) :

char cad[10][80];

Equiva le a char **cad reservando 800 bytes



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

La declarac ión:

char cad[10] [80];

Reserva memoria para 10 cadenas de caracteres de80 caracteres cada una. Pero en la declarac ión como array de punteros :

char *cad[10];

El compi lador desconoce el tamaño de las cadenas: ¿cuánta memoria reserva?

- si e l ar ray es stat ic y se inic ia l i zan las cadenas en e l propio código, e l compi lador calcula la d imensión no exp l ic i tada (ar rays s in dimensión exp l íc i ta ) .

OTRAS CLASES DE PUNTEROS: �Punteros genér icos: Son t ipo void:

void *generico;

Los punteros t ipo void pueden apuntar a ot ro t ipo de datos. Es una operac ión del icada que depende del t ipo de compi lador. Es conveniente emplear e l “cast ing” para la conversión. Aún as í , no todas las conversiones están permit idas.

�Puntero nulo: En C un puntero que apunte a un objeto vá l ido nunca tendrá un va lor cero. E l va lor cero se ut i l iza para indicar que ha ocurr ido a lgún er ror (es dec ir , que a lguna operación no se ha podido real i zar )

int *p = NULL; // int *p=0;

�Punteros constantes : Una dec laración de puntero precedida de const hace que e l ob jeto apuntado sea una constante (aunque no el puntero) :

const char *p = “Val ladol id”;

p [0] = ‘ f ’ //er ror . La cadena apuntada por + es cte .

p = “Pucela” //Ok. p apunta a ot ra cadena.

Si lo que queremos es dec larar un puntero constante;

char *const p = “Medina”;

p [0] = ‘s ’ ; //error : e l ob jeto “Medina”, es cte.

p = “Peñaf ie l ” ; //error : e l puntero p es constante.

�Punteros a punteros:

Ver e jemp4.cpp, e jemp11.cpp y ejemp12.cpp

int **puntero; //puntero a puntero a un objeto int .

E l t ipo de ob jeto apuntado después de una doble ind i rección puede ser de cualquier c lase.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Permite manejar ar rays de múlt ip les d imensiones con notac iones del t ipo ***mat, de múlt ip le ind i rección que pueden generar problemas s i e l t ratamiento no es e l adecuado. O jo a los “punteros locos”.

�Punteros a datos comple jos: Se pueden declara punteros a datos def inidos por e l usuario ( typedef( ) ) , a datos st ruct , a funciones, como argumentos de func iones. . .

� Declarac iones complejas:

Una dec larac ión compleja es un ident i f icador con más de de un operador. Para interpretar estas declarac iones hace fa lta saber que los corchetes y paréntesis (operadores a la derecha de l ident i f icador t ienen pr ior idad sobre los aster iscos (operadores a la izquierda del ident i f icador. Los paréntes is y corchetes t ienen la misma pr ior idad y se eva lúan de i zquierda a derecha. A la izquierda de l todo el t ipo de dato.Empleando paréntes is se puede cambiar el orden de pr ior idades. Las expresiones entre paréntesis se evalúan pr imero, de más internas a más externas.

Para interpretar declaraciones complejas podemos seguir e l orden:

1) Empezar con e l ident i f icador y ver s i hacia la derecha hay corchetes o paréntesis .

2) Interpretar esos corchetes o paréntes is y ver s i hacia la i zquierda hay aster iscos.

3 ) Dentro de cada nivel de paréntesis , de más internos a más externos, ap l icar puntos 1 y 2.

Veamos un ejemplo:

char *(*(*var ) ( ) ) [10]

La interpretac ión es:

1. La var iab le var es declarada como

2. un puntero a

3. una función que devuelve

4. un puntero a

5. un ar ray de 10 elementos, los cuales son

6. punteros a

7. ob jetos de t ipo char.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Punteros a estructuras

Cómo no, también 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 hacíamos 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 dirección válida donde apuntar. No podemos por ejemplo crear un puntero a estructura y meter los datos directamente mediante ese puntero, no sabemos dónde apunta el puntero y los datos se almacenarían en un lugar cualquiera.

Y para comprender cómo funcionan, nada mejor que un ejemplo. Este programa utiliza un puntero para acceder a la información 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 años ", p_amigo->edad ); printf( "y su teléfono es el %s.\n" , p_amigo->telefono ); }

Has la definición 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 dónde 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 dirección donde está almacenado...'.

Ahora queremos acceder a cada campo de la estructura. Antes lo hacíamos 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 sólo nos queda saber cómo 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];



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 años.\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 &.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Punteros a Arrays de estructuras

Por supuesto también 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 años ", p_amigo->edad ); printf( "y su teléfono es el %s.\n" , p_amigo->telefono ); /* y ahora saltamos al siguiente elemento */ p_amigo++; } }

En vez de p_amigo = amigo; se podía 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 más usada pero la segunda quizás indica más claramente al lector principiante lo que se pretende.

Ahora veamos el ejemplo anterior de cómo introducir datos en un array de estructuras mediante punteros:

#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()



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

{ 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 años.\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).



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Introducción:

Una de las aplicaciones más interesantes y potentes de la memoria dinámica y los punteros son las estructuras dinámicas de datos. Las estructuras básicas disponibles en C y C++ tienen una importante limitación: no pueden cambiar de tamaño durante la ejecución. Los arreglos están compuestos por un determinado número de elementos, número que se decide en la fase de diseño, antes de que el programa ejecutable sea creado.

En muchas ocasiones se necesitan estructuras que puedan cambiar de tamaño durante la ejecución del programa. Por supuesto, podemos hacer 'arrays' dinámicos, pero una vez creados, tu tamaño también será fijo, y para hacer que crezcan o diminuyan de tamaño, deberemos reconstruirlas desde el principio.

Las estructuras dinámicas nos permiten crear estructuras de datos que se adapten a las necesidades reales a las que suelen enfrentarse nuestros programas. Pero no sólo eso, como veremos, también 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 están compuestas de otras pequeñas estructuras a las que llamaremos nodos o elementos, que agrupan los datos con los que trabajará nuestro programa y además uno o más punteros autoreferenciales, es decir, punteros a objetos del mismo tipo nodo.

Una estructura básica 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 sólo necesitaremos un puntero a un nodo.

Durante el presente curso usaremos gráficos para mostrar la estructura de las estructuras de datos dinámicas. El nodo anterior se representará asi:

Las estructuras dinámicas son una implementación de TDAs o TADs (Tipos Abstractos de Datos). En estos tipos el interés se centra más en la estructura de los datos que en el tipo concreto de información que almacenan.

Dependiendo del número de punteros y de las relaciones entre nodos, podemos distinguir varios tipos de estructuras dinámicas. Enumeraremos ahora sólo de los tipos básicos:

• Listas abiertas: cada elemento sólo dispone de un puntero, que apuntará al siguiente elemento de la lista o valdrá NULL si es el último elemento.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

• 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 sólo el elemento que está encima de la pila puede ser leído, y sólo pueden añadirse 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 sólo pueden añadirse 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 más 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 sólo puede apuntar a dos nodos. • Arboles binarios de búsqueda (ABB): son árboles binarios ordenados. Desde cada nodo todos los

nodos de una rama serán mayores, según la norma que se haya seguido para ordenar el árbol, y los de la otra rama serán menores.

• Arboles AVL: son también árboles de búsqueda, pero su estructura está más optimizada para reducir los tiempos de búsqueda.

• Arboles B: son estructuras más complejas, aunque también se trata de árboles de búsqueda, están mucho más 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 también veremos estructuras dinámicas en las que existen nodos de distintos tipos, en realidad no es obligatorio que las estructuras dinámicas estén compuestas por un único tipo de nodo, la flexibilidad y los tipos de estructuras sólo están limitados por tu imaginación como programador.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Listas

Fundamentos

Las listas son secuencias de elementos, donde estos elementos pueden ser accedidos, insertados o suprimidos en cualquier posición de la lista. No existe restricción alguna acerca de la localización de esas operaciones. Se trata de estructuras muy flexibles puesto que pueden crecer o acotarse como se quiera.

Matemáticamente, una lista es una secuencia de cero o más elementos de un tipo determinado (que por lo general denominaremos T). A menudo se representa una lista como una sucesión 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 vacía.

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. También se dice que el elemento a(i) está en la posición i de la lista.

Por lo que se ve, las estructuras pila y cola, estudiadas en el capítulo anterior, no son más 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 más costosas. Por ejemplo, supongamos la siguiente lista:

(Antonio, Bartolomé, Carlos, David, Emilio, Germán, Jaime, José, Luis, Manuel)

Si se desea añadir el valor 'Fernando' a esta lista ordenada de nombres, la operación se debe realizar en la sexta posición de la lista, entre los valores 'Emilio' y 'Germán'. Cuando la lista está representada con un array, dicha inserción implicará tener que desplazar una posición hacia la derecha todos los elementos situados ya en la lista a partir de la posición seis (Germán,...Manuel), para de esta forma dejar una posición 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 posición hacia la izquierda todos los elementos situados a partir de la cuarta posición.

Cuando el problema es manipular diferentes listas de tamaño variable, la representación secuencial prueba ser, de nuevo, poco apropiada. Si se decide almacenar en distintos arrays cada una de las listas, se tendrán grandes necesidades de almacenamiento. Si, por el contrario, se toma la decisión de usar un único array, se necesitará una cantidad mucho mayor de desplazamientos de información.

Una solución elegante al problema del desplazamiento de información en el almacenamiento secuencial se logra mediante la utilización de representaciones enlazadas (o ligadas). A diferencia de la representación secuencial, en la representación enlazada los elementos se pueden situar en cualquier posición de memoria, y no necesariamente igualmente distantes dentro de ella. También se puede decir que, si bien en la representación con arrays el orden de los elementos es el mismo que el orden en la lista, en una representación enlazada la secuencia de orden de la lista no tiene porque coincidir con la secuencia de almacenamiento en memoria.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Listas abiertas o Simples

La forma más simple de estructura dinámica 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á vacía.

El nodo típico para construir listas tiene esta forma:

struct nodo { int dato; struct nodo *siguiente; };

En el ejemplo, cada elemento de la lista sólo contiene un dato de tipo entero, pero en la práctica no hay límite 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 dirección vacía 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 declaración de tipos puede tener una forma parecida a esta:

typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 sólo 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 condición, 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 sólo 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 condición del bucle, tal vez encontremos un posible error: ¿Qué pasaría si ningún valor es mayor que 100, y alcancemos el final de la lista?. Podría pensarse que cuando indice sea NULL, si intentamos acceder a indice->dato se producirá un error.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

En general eso será cierto, no puede accederse a punteros nulos. Pero en este caso, ese acceso está dentro de una condición y forma parte de una expresión "and". Recordemos que cuando se evalúa una expresión "and", se comienza por la izquierda, y la evaluación se abandona cuando una de las expresiones resulta falsa, de modo que la expresión "indice->dato <= 100" nunca se evaluará si indice es NULL.

Si hubiéramos escrito la condición al revés, el programa nunca funcionaría bien. Esto es algo muy importante cuando se trabaja con punteros.

Operaciones básicas con listas:

Con las listas tendremos un pequeño repertorio de operaciones básicas que se pueden realizar:

• Añadir o insertar elementos. • Buscar o localizar elementos. • Borrar elementos. • Moverse a través 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 vacía, o al principio de una lista no vacía, o la final, o en una posición intermedia.

Insertar elementos en una lista abierta:

Veremos primero los casos sencillos y finalmente construiremos un algoritmo genérico para la inserción de elementos en una lista.

Insertar un elemento en una lista vacía:

Este es, evidentemente, el caso más sencillo. Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él, además 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 posición 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 vacía, pero siempre podemos, y debemos considerar una lista vacía 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 vacía:

El proceso sigue siendo muy sencillo:

1. Hacemos que nodo->siguiente apunte a Lista. 2. Hacemos que Lista apunte a nodo.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Insertar un elemento en la última posición de una lista:

Este es otro caso especial. Para este caso partiremos de una lista no vacía:

El proceso en este caso tampoco es excesivamente complicado:

1. Necesitamos un puntero que señale 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 continuación 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 continuación del cual insertaremos el nuevo nodo:

Suponemos que ya disponemos del nuevo nodo a insertar, apuntado por nodo, y un puntero al nodo a continuación del que lo insertaremos.

El proceso a seguir será:

1. Hacer que nodo->siguiente señale a anterior->siguiente. 2. Hacer que anterior->siguiente señale a nodo.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

{anterior=*lista; while(anterior->siguiente!=NULL) anterior=anterior->siguiente; anterior->siguiente=nuevo; nuevo->siguiente=NULL; } }

Borrar un elemento específico 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 información 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; } } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

PILAS Y COLAS

Las pilas y las colas son dos de las estructuras de datos más utilizadas. Se trata de dos casos particulares de las estructuras lineales generales (secuencias o listas) que, debido a su amplio ámbito de aplicación, conviene ser estudiadas de manera independiente.

PILAS. FUNDAMENTOS

La pila es una lista de elementos caracterizada porque las operaciones de inserción y eliminación 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 más inaccesible de la pila, está en el fondo de la pila (bottom) y que k, por el contrario, el más accesible, está en la cima.

Las restricciones definidas para la pila implican que si una serie de elementos A,B,C,D,E se añaden, 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 razón, 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 típico de pila lo constituye un montón de platos, cuando se quiere introducir un nuevo plato, éste se pone en la posición más accesible, encima del último plato. Cuando se coge un nuevo plato, éste se extrae, igualmente, del punto más accesible, el último que se ha introducido.

Otro ejemplo natural de la aplicación de la estructura pila aparece durante la ejecución de un programa de ordenador, en la forma en que la máquina procesa las llamadas a los procedimientos. Cada llamada a un procedimiento (o función) hace que el sistema almacene toda la información asociada con ese procedimiento (parámetros, variables, constantes, dirección 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 información almacenada pueda ser recuperada convenientemente cuando corresponda. Como en un procesador sólo se puede estar ejecutando un procedimiento, esto quiere decir que sólo 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 manipulación, é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. • Añadir elementos a la cima. • Eliminar elementos de la cima.

La especificación correcta de todas estas operaciones permitirá definir adecuadamente una pila.

Representacion de las pilas

Los lenguajes de programación 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

La forma más 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 información contenida en él.

El hecho de utilizar un vector para almacenar los elementos, puede conducir a la situación en que la pila esté llena, es decir, que no quepa ningún elemento más. Esto se producirá cuando el índice que señala la cima de la pila sea igual al tamaño del vector.

Al definir un array hay que determinar el número de índices válidos y, por lo tanto, el número de componentes definidos. Entonces, la estructura pila representada por un array tendrá limitado el número 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 posición. Es necesaria una variable, cima, que apunte al último elemento (ocupado) de la pila.

Con estas consideraciones prácticas, se puede pasar a definir las operaciones que definen la pila.

Crear pila:

Es necesario definir la variable que permitirá almacenar la información, indicando que la creación implica que la pila está vacía, por lo que deberá ser igual a NULL.

Comprobar si la pila está vacía:

Esta operación permitirá determinar si es posible eliminar elementos.

boolean Pila_vacia (Pila p)

{

boolean r=false;

If ( (*pila)==Null) r=true;

return r;

}

Operación de inserción

La operación de inserción normalmente se conoce por su nombre inglés push. La operación aplicada sobre una pila y un valor x, inserta x en la cima de la pila. Esta operación está restringida por el tipo de representación escogido. En el caso, la utilización de un array implica que se tiene un número máximo de posibles elementos en la pila, por lo tanto, es necesario comprobar, previamente a la inserción, que realmente hay espacio en la estructura para almacenar un nuevo elemento. Con esta consideración el algoritmo de inserción sería:



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Algoritmo Apilar

void InsertarPila(Pila *pila, int v) { pNodo nuevo; nuevo=(pNodo)malloc(sizeof(tipoNodo)); nuevo->dato=v; nuevo->sig=*pila; *pila=nuevo; }

Operación de eliminación

La operación de borrado elimina de la estructura el elemento situado en la cima. Normalmente recibe el nombre de pop en la bibliografía inglesa. El algoritmo de borrado sería:

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 función Pila_vacia nos devuelve un valor lógico (cierto o falso) que en este caso nos sirve como condición para el si)

En todos los algoritmos se podría suponer que las variables Pila y cima, lo mismo que n, son globales y, por lo tanto, no sería necesario declararlas como entradas o salidas.

Pilas Notación Prefija, Infija y Postfija • Expresión aritmética: – 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 evalúa primero el que primero aparece) 5*4/2 = (5*4)/2 = 10



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

• Cuando aparecen varios operadores de potenciación juntos la expresión se evalúa de derecha a izquierda 2^3^2 = 2^(3^2) = 2^9 = 512 • Notación Infija – Es la notación ya vista que sitúa el operador entre sus operandos. – Ventaja: Es la forma natural de escribir expresiones aritméticas – Inconveniente: Muchas veces necesita de paréntesis para indicar el

Orden de evaluación: A*B/(A+C) ¹ A*B/A+C

• Notación Prefija o Polaca – En 1920 un matemático de origen polaco, Jan Lukasiewicz, desarrollo un sistema para especificar expresiones matemáticas sin paréntesis. – Esta notación se conoce como notación prefija o polaca (en honor a la nacionalidad de Lukasiewicz) y consiste en situar al operador ANTES que los operandos. – Ejemplo: la expresión infija A*B / (A+C) se representaría en notación prefija como: /*AB+AC • Notación Postfija o Polaca Inversa – La notación postfija o polaca inversa es una variación de la notación prefija de forma que el operador de pone DESPUÉS de los operandos. – Ejemplo: la expresión infija A*B / (A+C) se representaría en notación postfija como: AB*AC+/ – Ventajas: • La notación postfija (como la prefija) no necesita paréntesis. • La notación postfija es más utilizada por los computadores ya que permite una forma muy sencilla y eficiente de evaluar expresiones aritméticas (con pilas).

Colas. Fundamentos

Las colas son secuencias de elementos caracterizadas porque las operaciones de inserción y borrado se realizan sobre extremos opuestos de la secuencia. La inserción 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 irán saliendo de la cola en el orden en que entraron. Por esa razón, 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).

Teniendo en cuenta que las operaciones de lectura y escritura en una cola hacen siempre en extremos distintos, lo más fácil será insertar nodos por el final, a continuación 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 aplicación habitual en muchos problemas informáticos. Quizás la aplicación más común de las colas es la organización 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 continuación. 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



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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.

Análogamente a las pilas, es necesario definir el conjunto de operaciones básicas para especificar adecuadamente una estructura cola. Estas operaciones serían:

• Crear una cola vacía. • Determinar si la cola está vacía, 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 representación para las colas.

Representacion de las colas Hay diferentes formas de implementar las operaciones relacionadas con colas, una de las más eficientes es representar el array Cola[1..n] como si fuese circular, es decir, cuando se dé la condición de cola llena se podrá continuar por el principio de la misma si esas posiciones no estan ocupadas. Con este esquema de representación, se puede pasar a especificar el conjunto de operaciones necesarias para definir una cola circular. Para nuestro erstudio partiremos de la creación sin arrays.

Crear cola: Esta operación consistirá en definir la variable que permitirá almacenar la información y las variables que apuntarán a los extremos de la estructura. Además, hay que indicar explícitamente que la cola, trás la creación, está vacía.

typedef struct nodo { int dato; struct nodo * sig; }tipoNodo; typedef tipoNodo * pNodo; typedef tipoNodo * Cola;

Comprobar si la cola está vacía: Con las condiciones establecidas, basta comprobar si inicio = fin:

boolean Cola_vacia Cola c)

{

boolean r=false;

If ( (*cola)==Null) r=true;

return r;

}

Acceder al elemento inicial o al final de la cola: Es importante poder acceder fácilmente 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 implementación estática de la estructura cola es necesario determinar si existen huecos libres donde poder insertar antes de hacerlo. Esto puede hacerse de varias formas:



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Void Añadir (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, añadimo 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 también 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 dirección 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;

}

Conclusión De todo esto puede sorprender que la condición de cola llena sea la misma que la de cola vacía. Sin embargo, en el caso de la inserción 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 posición libre, la anterior al primer elemento real de la cola. Pero si se decide insertar un elemento en esa posición, no sería posible distinguir si Cola.inicio = Cola.fin indica que la cola está llena o vacía. Se podría definir alguna variable lógica que indicase cual de las dos situaciones se está dando en realidad. Esta modificación implicaría introducir alguna nueva operación en los métodos de inserción y borrado, lo que, en general, resultaría peor solución que no utilizar un elemento del array. Suele ser mejor solución utilizar siempre 'n-1' elementos de la cola, y no 'n', que complicar dos operaciones que se tendrán que repetir múltiples veces durante la ejecución de un programa.

Pilas y colas múltiples Hasta ahora se ha tratado solamente con la representación en memoria y manipulación 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 sólo hay que representar dos pilas sobre un mismo array A[1..n], la solución 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Si se plantea representar más de dos pilas sobre ese mismo array A, no es posible seguir la misma estrategia, ya que un array unidimensional sólo tiene dos puntos fijos, A[1] y A[n], y cada pila requiere un punto fijo para representar el elemento más profundo. Cuando se requiere representar secuencialmente más 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 división inicial de A[1..n] en segmentos se puede hacer en base al tamaño esperado de cada una de las estructuras. Si no es posible conocer esa información, el array A se puede dividir en segmentos de igual tamaño. 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 dónde está su cima. En general, se hace que f(i) esté una posición por debajo del fondo real de la pila, de forma que se cumpla la condición f(i)=c(i) si y solamente si la pila i está vacía. La discusión realizada para el caso de pilas múltiples sirve de base para poder establecer estrategias de manipulación de varias colas en un mismo array, incluso la combinación de estructuras pilas y colas sobre la misma localización secuencial.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 añade un nodo especial de cabecera, de ese modo se evita la única excepción posible, la de que la lista esté vacía. El nodo típico 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 definición de tipo es equivalente a la anterior sólo se debe modificar la dirección a la que apunta el enlace ubicado en el último nodo.

Las operaciones sobre una lista circular resultan más 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 solución al problema anterior sería 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 vacía.

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; 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, también introducen algunas complicaciones. Por ejemplo, en un proceso de búsqueda, no es tan sencillo dar por terminada la búsqueda cuando el elemento buscado no existe.Por ese motivo se suele resaltar



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

un nodo en particular, que no tiene por qué ser siempre el mismo. Cualquier nodo puede cumplir ese propósito, y puede variar durante la ejecución 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 función de nodo cabecera. De este modo, la lista nunca estará vacía, y se eliminan casi todos los casos especiales.

Operaciones básicas 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:

• Añadir o insertar elementos. • Buscar o localizar elementos. • Borrar elementos. • Moverse a través 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 vacía, o cuando se elimina el único nodo de una lista.

Añadir elemento en una lista circular vacía:

Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él, además 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.

Añadir elemento en una lista circular no vacía:

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. Después que lista->siguiente apunte a nodo.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Añadir elemento en una lista circular, caso general:

Para generalizar los dos casos anteriores, sólo necesitamos añadir una operación:

1. Si lista está vacía hacemos que lista apunte a nodo. 2. Si lista no está vacía, hacemos que nodo->siguiente apunte a lista->siguiente. 3. 4. Después 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 sólo hay que tener una precaución, es necesario almacenar el puntero del nodo en que se empezó la búsqueda, para poder

detectar el caso en que no exista el valor que se busca. Por lo demás, la búsqueda 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 operación 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 excepción 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 continuación borramos nodo.En el caso de que sólo 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 más de un elemento:

Consideraremos los dos primeros casos como uno sólo.

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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 más 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 más de un nodo. Supongamos que queremos eliminar un nodo apuntado por nodo:

1. Copiamos el contenido del nodo->siguiente sobre el contenido de nodo. 2. Hhacemos que nodo->siguiente apunte a nodo->siguiente->siguiente. 3. Eliminamos nodo->siguiente. 4. Si lista es el nodo->siguiente, hacemos lista = nodo.

Este método también funciona con listas circulares de un sólo 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 números enteros. Haremos pruebas insertando varios valores, buscándolos y eliminándolos alternativamente para comprobar el resultado.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Algoritmo de la función "Insertar":

1. Si lista está vacía hacemos que lista apunte a nodo. 2. Si lista no está vacía, hacemos que nodo->siguiente apunte a lista->siguiente. 3. Después 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á vacía, la lista será el nuevo nodo // Si no lo está, insertamos el nuevo nodo a continuación 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 función "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 sólo tiene un nodo if(*lista == (*lista)->siguiente) { // Borrar toda la lista free(*lista); *lista = NULL; } else { // Si la lista tiene más de un nodo, borrar el nodo de valor v nodo = (*lista)->siguiente; (*lista)->siguiente = nodo->siguiente; free(nodo); }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

} }

Código del ejemplo:

Tan sólo nos queda escribir una pequeña 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á vacía, la lista será el nuevo nodo // Si no lo está, insertamos el nuevo nodo a continuación 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);



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

// Si existe un nodo con el valor v: if((*lista)->siguiente->valor == v) { // Y si la lista sólo tiene un nodo if(*lista == (*lista)->siguiente) { // Borrar toda la lista free(*lista); *lista = NULL; } else { // Si la lista tiene más 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 más 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"); }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 específico, solamente es posible moverse dentro de la lista en el sentido del único enlace existente para ese nodo, es decir, es fácil pasar al sucesor pero no es igualmente fácil 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 representación, 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 más de información y dos campos de enlace. En ocasiones, para facilitar aún más 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 manipulación de las estructuras circulares, sobre todo la inserción, y evitar en lo posible la consideración de casos especiales (lista vacia) se suele añadir un nodo inicial (cabeza), que no contiene ninguna información útil, y que existe aunque la lista esté vacía. De modo que, incluso la lista vacía 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 dirección.

Implementacion de Principales operaciones con Listas Circulares 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; } }

Insertar al inicio. void insertar_final(pnododoble *lista,int n) { pnododoble nodo;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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.

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); }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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); } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Pilas y colas enlazadas Se ha visto ya cómo representar pilas y colas de manera secuencial. Ese tipo de representación prueba ser bastante

eficiente, sobretodo cuando se tiene sólo una pila o una cola. Cuando sobre el mismo array se tiene que representar

más de una estructura, entonces aparecen problemas para poder aprovechar de manera eficiente toda la memoria

disponible. Vamos a presentar en esta sección una nueva representación de las pilas y las colas mediante la

estructura de lista enlazada.

En la representación de estas estructuras vamos a hacer que los enlaces entre los elementos de la misma sea tal

que faciliten las operaciones de inserción y borrado de elementos. Además, hay que tener en cuenta que, como en

cualquier otro tipo de representación, es necesario mantener variables que indiquen dónde están los extremos de las

estructuras (dónde 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 inserción y borrado

resultan muy simples. A continuación definiremos la estructura pila con esta nueva representación.

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)Asignación de pila vacía

cima <-- NULO

Comprobar si la pila está vacía: La pila estará vacía si y solamente si el puntero cima no hace referencia a ninguna dirección 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 fácilmente a través del puntero que le referencia, cima, que siempre

debe existir y ser adecuadamente actualizado.

Operación de inserción: Con la representación enlazada de la pila, la estructura tiene una menor limitación en cuanto al posible número de

elementos que se pueden almacenar simultáneamente. Hay que tener en cuenta que la representación de la pila ya no

requiere la especificación de un tamaño máximo, por lo que mientras exista memoria disponible se va a poder reservar

espacio para nuevos elementos. Por esa razón, se va a suponer en el siguiente algoritmo que la condición de pila llena

no se va a dar y, por lo tanto, no será necesaria su comprobación.

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 inserción utilizando esta nueva representación continua siendo muy simple,

siendo el coste del mismo constante (cuatro pasos).

Operación de eliminación: Lo único que hay que tener en cuenta a la hora de diseñar un algoritmo para esta operación es la utilización eficiente

de la memoria, de forma que el espacio ocupado por el nodo borrado vuelva a estar disponible para el sistema.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 solución dada se puede extender a "m" pilas, de hecho como los enlaces entre elementos son establecidos por el

programador, no por el método de representación, es como si las pilas siempre compartiesen espacios diferentes, no

interfieren unas con otras. Se trata de una solución conceptual y computacionalmente simple. No existe necesidad de

desplazar unas pilas para proporcionar más espacio a otras.

El incremento de espacio de almacenamiento que implica la representación enlazada se ve compensada por la

capacidad de representación de listas complejas de una forma simple y por la disminución del tiempo de cómputo

asociado a la manipulación de listas, respecto a la representación secuencial.

Colas enlazadas Análogamente 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)Asignación de cola vacía

inicio <-- NULO

final <-- NULO

Comprobar si la cola está vacía: De nuevo, la estructura estará vacía si y sólo si el puntero inicio no hace referencia a ningún nodo de la cola.

si inicio = NULO entonces devolver(cierto)

sino devolver(falso)

Acceso al primer elemento de la cola: Se puede acceder a este elemento de la cola mediante el puntero inicio que lo referencia.

Operación de inserción:

Algoritmo InsertarCola

Entrada

x: T

Variable



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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

Operación 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 Múltiplemente Enlazadas

Este tipo de listas contiene más de dos enlaces por nodo, los que tienen la posibilidad de apuntar a más de dos listas

enlazadas.

Vista gráfica de un nodo

p

p Dato p

p



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

RECURSIVIDAD

E l concepto de recursiv idad va l igado a l de repet ic ión. Son recurs ivos aquel los algor i tmos que, estando encapsulados dentro de una función, son l lamados desde el la misma una y ot ra vez, en contrapos ición a los algor i tmos i terat ivos, que hacen uso de bucles whi le, do-whi le, for , etc.

Características .

Un algor i tmo recursivo consta de una parte recurs iva, otra i terat iva o no recurs iva y una condición de terminación. La parte recurs iva y la condic ión de terminac ión siempre existen. En cambio la parte no recursiva puede co inc idi r con la condic ión de terminac ión.

Algo muy importante a tener en cuenta cuando usemos la recursiv idad es que es necesar io asegurarnos que l lega un momento en que no hacemos más l lamadas recursivas. Si no se cumple esta condición e l programa no parará nunca.

Ventajas e inconvenientes. La pr inc ipal ventaja es la s impl ic idad de comprensión y su gran potencia, favoreciendo la resolución de problemas de manera natural , senci l la y e legante ; y faci l idad para comprobar y convencerse de que la soluc ión del problema es correcta .

El pr incipa l inconveniente es la inef ic ienc ia tanto en t iempo como en memor ia, dado que para permit i r su uso es necesar io transformar el programa recurs ivo en ot ro i terat ivo, que ut i l iza Bucles y p i las para a lmacenar las var iables.

Ventajas : ef ic ientes y ráp idos.

Inconvenientes : Para cada elemento de la l ista se debe reservar un espac io para punteros lo que signi f ica un desaprovechamiento de memor ia en e l "manejo de l ista" .

Zona de Overflow. Se reserva espac io en cierta zona de externa a la propia tab la, de aprox imadamente el 10% de su tamaño, para int roduc ir las co l is iones. Cada sinónimo se almacena en la pr imera ce lda disponible de la zona de over f low.

Inconveniente : Desaprovechamiento de memor ia (poco).Es poco ef ic iente cuando se han producido col is iones, ya que la búsqueda en la zona de overf low es secuencial .

Ventajas : Ocupa menos memor ia que el anter ior . E l a lgor i tmo de búsqueda y de inserción es más senc i l lo.

Almacenamiento interno Cuando e l espacio usado para a lmacenar las col is iones esta dentro de los l ímites de la tabla .

Dentro de l a lmacenamiento interno están: Encadenamiento di recto y encadenamiento vac ío.

Encadenamiento directo.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Se usa dentro de la tabla un campo de t ipo puntero para qué apunte al s iguiente col is ionado, que estará dentro de la tabla. En ese campo se guarda la di recc ión del s igu iente col is ionado.

En e l encadenamiento directo con zona de overf low podemos sobredimensionar la tabla para almacenar las col is iones, en esta zona las casi l las estarán encadenadas con una var iab le que apunte al pr imer espacio l ibre de la zona de over f low. Cons iste en en lazar todos los elementos cuyas claves generan igual Índice pr imario por medio de en laces dentro de la tabla a las nuevas pos ic iones ocupadas por estos e lementos.

Inconvenientes : Espac io reservado en cada elemento para e l en lace.

Ventajas : Más ráp ido que el externo con zona de overf low ya que evita la búsqueda secuencial .

Ocupación de memoria: Depende del método usado. El pr imer caso ocupa menos memor ia , y e l segundo es más rápido.

Forma de Interpretación Algo es recurs ivo s i se def ine en términos de sí mismo (cuando para def in i rse hace mención a s í mismo). Para que una def inic ión recurs iva sea vál ida, la referenc ia a s í misma debe ser re lat ivamente más senci l la que el caso considerado.

Ejemplo: def inic ión de n° natura l :

-> El N ° 0 es natural

-> El N° n es natural s i n-1 lo es.

En un a lgor i tmo recursivo dist inguimos como mín imo 2 partes:

Caso t r iv ia l , base o de f in de recurs ión:

Es un caso donde e l problema puede resolverse sin tener que hacer uso de una nueva l lamada a s í mismo. Evi ta la cont inuación indef in ida de las partes recurs ivas.

b) . Parte puramente recurs iva:

Re lac iona el resultado del a lgor i tmo con resultados de casos más simples. Se hacen nuevas l lamadas a la func ión, pero están más próx imas al caso base.

EJEMPLO

ITERATIVO: Int Factor ia l ( int n ) { int i , res=l ; for ( i = l ; i<=n; i++) res = res* i ; return ( res) ; }

RECURSIVO: int Factor ial ( int n ) { i f (n == 0) return (1) ; return (n*Factor ia l (n -1) ) ; }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

TIPOS DE RECURSION

Recursividad simple: Aquel la en cuya def inic ión só lo aparece una l lamada recursiva. Se puede t ransformar con fac i l idad en algor i tmos i terat ivos.

Recursividad múlt iple: Se da cuando hay más de una l lamada a sí misma dent ro de l cuerpo de la func ión, resultando más d if íc i l de hacer de forma i terat iva.

int F ib ( int n ) /* e j : F ibonacc i */ { i f (n<=l ) return ( 1) ; return (F ib (n-1) + Fib(n-2) ) ; } Recursiv idad anidada: En a lgunos de los arg. de la l lamada recursiva hay una nueva l lamada a s í misma. int Ack ( int n, int m ) /* e j : Ackerman */

{

i f (n = = 0 ) return (m+1 ) ;

e lse i f (m= = 0) return (Ack (n-1 , 1) ) ;

return (Ack (n-1 , Ack (n,m- l ) ) ) ;

}

• Recurs iv idad cruzada o ind i recta: Son algor i tmos donde una función provoca una l lamada a s í misma de forma indi recta, a t ravés de ot ras funciones.

E j : Par o Impar:

int par ( int nump ) { i f (nump= = 0) return( l ) ; return ( impar (nump-1) ) ; int impar ( int numi ) { i f (numi==0) return (0) ; return ( par (numi- 1) ) ; }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

LA PILA DE RECURSION La memor ia del ordenador se d iv ide (de manera lógica, no f ís ica) en var ios segmentos (4) : Segmento de código: Parte de la memor ia donde se guardan las instrucc iones de l programa en cod. Máquina. Segmento de datos: Parte de la memor ia dest inada a almacenar las var iab les estát icas. Montícu lo: Parte de la memor ia dest inada a las var iab les dinámicas. Pi la del programa: Parte dest inada a las var iables loca les y parámetros de la función que está s iendo ejecutada. L lamada a una función: • Se reserva espac io en la pi la para los parámetros de la func ión y sus var iab les locales. • Se guarda en la p i la la di recc ión de la l ínea de código desde donde se ha l lamado a la func ión. • Se almacenan los parámetros de la función y sus valores en la pi la. • A l terminar la función, se l ibera la memor ia asignada en la pi la y se vuelve a la inst ruc . Actual . L lamada a una función recursiva: En e l caso recurs ivo, cada l lamada genera un nuevo ejemplar de la función con sus correspondientes objetos loca les: • La func ión se e jecutará normalmente hasta la l lamada a sí misma. En ese momento se crean en la p i la nuevos parámetros y var iables locales. • E l nuevo e jemplar de función comienza a ejecutarse. • Se crean más copias hasta l legar a los casos bases, donde se resuelve directamente el va lor , y se va sa l iendo l iberando memor ia hasta l legar a la pr imera l lamada (ú lt ima en cerrarse) EJERCICIOS a) . Tor res de Hanoi : Prob lema de soluc ión recursiva, cons iste en mover todos los discos (de di ferentes tamaños) de una aguja a otra, usando una aguja auxi l ia r , y

sabiendo que un disco no puede estar sobre otro menor que éste. /* Soluc ión: 1- Mover n-1 discos de A a B 2- Mover 1 d isco de A a C 3- Mover n-1 discos de B a C

*/ vo id Hanoi ( n, in ic ia l , aux, f ina l ) { i f ( n>0 ) { Hanoi (n-1, in ic ia l , f inal , aux ) ; pr intf ( "Mover %d de %c a %c", n, in ic ial , f ina l ) ; Hanoi (n -1, aux, in ic ia l , f inal ) ; b) . Ca lcu lar \ e levado a n de forma recurs iva: f loat xelevn( f loat base, int exp ) { i f (exp == O ) return (1) ; return( base*xelevn(base,exp-1)) ; c) . Mult ip l icar 2 n°s con sumas suces ivas recurs: int mult i ( int a, int b ) { i f (b == O ) return(0) ; return( a + mult i (a , b-1) ) ; d) . ¿Qué hace este programa?: vo id cosa ( char *cad, int i ) i f ( cad[ i ] '= '\O ' ) cosa(cad, i+1);

A B C



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

printf ( "%c", cad[ i ] ) ;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Árboles

Fundamentos y terminología básica 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 pasaría 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. También suele dar una definición recursiva: un arbol es una estructura compuesta por un dato y varios arboles. Los árboles establecen una estructura jerárquica entre los objetos. Los árboles genealógicos y los organigramas son ejemplos comunes de árboles. Un árbol es una colección de elementos llamados nodos, uno de los cuales se distingue del resto como raíz, junto con una relación que impone una estructura jerárquica entre los nodos. Formalmente, un árbol se puede definir de manera recursiva como sigue: Definición: una estructura de árbol con tipo base T es:

• (i) Bien la estructura vacía. • (ii) Un conjunto finito de uno o más nodos, tal que existe un nodo especial, llamado nodo raiz, y

donde los restantes nodos están separados en n >= 0 conjuntos disjuntos, cada uno de los cuales es a su vez un árbol (llamados subárboles del nodo raíz).

La definición implica que cada nodo del árbol es raíz de algún subárbol contenido en el árbol principal. El índice de un libro es un buen ejemplo de representación en forma de árbol. Ejemplos de estructuras arborescentes:

Antes de continuar avanzando en las características y propiedades de los árboles, veamos algunos términos importantes asociados con el concepto de árbol:

• Grado de un nodo: es el número de subárboles que tienen como raíz ese nodo (cuelgan del nodo). • Nodo terminal u hoja: nodo con grado 0. No tiene subárboles. • Grado de un árbol: grado máximo de los nodos de un árbol. • Hijos de un nodo: nodos que dependen directamente de ese nodo, es decir, las raíces de sus

subárboles. • Padre de un nodo: antecesor directo de un nodo del cual depende directamente. • Nodos hermanos: nodos hijos del mismo nodo padre. • Camino: sucesión 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 raíz del árbol hasta ese nodo. • Nivel de un nodo: longitud del camino desde la raíz hasta el nodo. El nodo raíz tiene nivel 1. • Altura o profundidad de un árbol: nivel máximo 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

La representación de un árbol general dependerá de su grado, es decir, del número de relaciones máximo que puede tener un nodo del árbol. Resulta más simple la representación y manipulación de una estructura árbol cuando el grado de éste es fijo e invariable. Por esa razón, para introducir los aspectos más concretos de la manipulación 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 aplicación. Estos árboles se caracterizan porque no existen nodos con grado mayor a dos, es decir, un nodo tendrá como máximo dos subárboles. Definición: un árbol binario es un conjunto finito de nodos que puede estar vacío o consistir en un nodo raíz y dos árboles binarios disjuntos, llamados subárbol izquierdo y subárbol derecho. En general, en un árbol no se distingue entre los subárboles de un nodo, mientras que en un árbol binario se suele utilizar la nomenclatura subárbol izquierdo y derecho para identificar los dos posibles subárboles de un nodo determinado. De forma que, aunque dos árboles tengan el mismo número de nodos, puede que no sean iguales si la disposición de esos nodos no es la misma:

Antes de pasar a la representación de los árboles binarios, vamos a hacer algunas observaciones relevantes acerca del número y características de los nodos en este tipo de árboles.

• Lema 1: el número máximo de nodos en el nivel i de un árbol binario es 2^(i-1), con i >= 1, y el número máximo de nodos en un árbol binario de altura k es (2^k) - 1, con k >= 1.

• Lema 2: para cualquier árbol binario no vacío, si m es el número de nodos terminales y n es el número de nodos de grado dos, entonces se cumple que m = n + 1.

Igualmente, para poder entender alguna de las formas de representación de los árboles binarios, vamos a introducir dos nuevos conceptos, lo que se entiende por árbol binario lleno y por árbol binario completo.

Definición: 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 número máximo de posibles nodos. Como en estos casos no existen subárboles vacíos excepto para los nodos terminales, es posible realizar una representación secuencial eficiente de este tipo de árboles. Esta representación suele implicar la numeración de los nodos. La numeración se realiza por niveles y de izquierda a derecha. Este proceso de numeración (etiquetado) de los nodos permite una identificación elegante de las relaciones de parentesco entre los nodos del árbol y se verá más adelante.

Definición(1): Los árboles de grado 2 t ienen una especial importancia. Se les conoce

con el nombre de árboles binar ios. Se def ine un árbol binar io como un conjunto f in i to de elementos (nodos) que b ien está vació o está formado por una raíz con dos árboles binar ios dis juntos, l lamados subárbol i zqu ierdo y derecho de la raíz .



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Definición (2): un árbol binario con n nodos y profundidad k se dice que es completo si y sólo 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, también es posible la representación secuencial eficiente de la estructura de nodos que lo componen. En los apartados que siguen se considerarán únicamente árboles binar ios y , por lo tanto , se ut i l izará la palabra árbol para refer i rse a árbo l binar io. Los árbo les de grado superior a 2 reciben e l nombre de árbo les mul t icamino.

Árbol b inar io de búsqueda.- Los árbo les b inar ios se ut i l i zan f recuentemente para representar conjuntos de datos cuyos e lementos se ident i f ican por una c lave única. Si e l árbo l está organizado de ta l manera que la c lave de cada nodo es mayor que todas las c laves su subárbol i zqu ierdo, y menor que todas las c laves del subárbol derecho se dice que este árbol es un árbo l binar io de búsqueda.

Ejemplo:

Representación 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 representación 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 fácilmente las posiciones de los nodos padre, hizo izquierdo e hijo derecho de cualquier nodo i en un árbol binario arbitrario que cumpla tales condiciones.

• 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 posición [i div 2] • si i <> 1. Si i=1, se trata del nodo raíz y no tiene padre. • • (2) El hijo izquierdo del nodo estará localizado en la posición [2i] • si 2i <= n. Si 2i>n, el nodo no tiene hijo izquierdo. • • (3) El hijo derecho del nodo estará localizado en la posición [2i+1] si • 2i+1 <= n. Si (2i+1) > n, el nodo no tiene hijo derecho.

Evidentemente, la representación puramente secuencial de un árbol se podría extender inmediatamente a cualquier árbol binario, pero esto implicaría, en la mayoría de los casos, desaprovechar gran cantidad del espacio reservado en memoria para el array. Así, aunque para árboles binarios completos la representación es ideal y no se desaprovecha espacio, en el peor de los casos para un árbol lineal (una lista) de profundidad k, se necesitaría espacio para representar (2^k) - 1 nodos, y sólo k de esas posiciones estarían realmente ocupadas. Además de los problemas de eficiencia desde el punto de vista del almacenamiento en memoria, hay que tener en cuenta los problemas generales de manipulación de estructuras secuenciales. Las operaciones de inserción y borrado de elementos en cualquier posición del array implican necesariamente el movimiento potencial de muchos nodos. Estos problemas se pueden solventar adecuadamente mediante la utilización de una representación enlazada de los nodos.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Representación enlazada Se podría 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 serían más que índices dentro del rango válido definido para el array. La estructura de esa representación enlazada pero ubicada secuencialmente en la memoria correspondería al siguiente esquema para cada nodo:

donde el campo informacion guarda toda la información asociada con el nodo y los campos hijo izquierdo e hijo derecho guardan la posición dentro del array donde se almacenan los respectivos hijos del nodo. Ejemplo:

Los problemas de esta representación están asociados con la manipulación de la misma. En el caso de la inserción de nuevos nodos, el único problema que puede aparecer es que se supere el espacio reservado para el array, en cuyo caso no se podrán insertar más nodos. Sin embargo, la operación de borrado implica mayores problemas de manipulación. Al poder borrar cualquier nodo del árbol, se van a dejar "huecos" en la estructura secuencial del array, esto se podría solucionar, como siempre, mediante el desplazamiento de elementos dentro del vector. Sin embargo, si de por sí esa operación 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 solución, podría consistir en almacenar las posiciones del array que están libres y que se pueden ocupar en la inserción de nodos. Esto podría resultar más eficiente, pues no implica el desplazamiento de información, pero requiere de la utilización de otra estructura de datos auxiliar que maneje esa información. La mejor solución, de nuevo, para evitar los problemas asociados con la manipulación de arrays, es la representación de los árboles binarios mediante estructuras dinámicas "puras", en el sentido de la



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Dato *izq *der

Nodo

Función

recursiva

creación en tiempo de ejecución de los nodos que sean necesarios (no más) y la utilización de punteros para enlazar estos nodos. La estructura de cada nodo en esta representación 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 implementación, sería:

#inc lude <conio.h> #inc lude <stdio.h> #inc lude <stdl ib.h> typedef st ruct nodo{ int dato; struct nodo *izq; struct nodo *der; }nodoarbol ;

Se puede comprobar como la representación en memoria de la estructura, en cuanto a definición 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 interpretación que hacemos de la representación en memoria la que define una estructura de datos, no la representación en sí misma. La representación enlazada tiene como principal desventaja que no resulta inmediato la determinación del padre de un nodo. Es necesario buscar el camino de acceso al nodo dentro del árbol para poder obtener esa información. Sin embargo, en la mayoría de las aplicaciones es la representación más adecuada. En el caso en que la determinación del padre de un nodo sea una operación importante y frecuente en una aplicación concreta, se puede modificar ligeramente la estructura de cada nodo añadiendo un cuarto campo, también de tipo enlace, que guarde la posición del padre de cada nodo. Al igual que en la representación enlazada de las listas, es necesario mantener un puntero al primer elemento de la estructura, en este caso el nodo raíz del árbol, que permita acceder a la misma.

Insertar Nodos vo id insertar (nodoarbol **raiz , int ind ice) {//proceso de insertar el e lemento en el arbo l i f (*ra iz==NULL){ *raiz=(nodoarbol *)mal loc(sizeof (nodoarbol ) ) ; (*ra iz ) ->dato=indice; (*ra iz ) ->izq=NULL; (*ra iz ) ->der=NULL; } e lse //recorre a la i zqu ierda i f ( indice<(*raiz) ->dato) insertar (&(*ra iz ) -> izq, indice) ; E lse //recorre a la derecha i f ( ind ice>(*raiz ) ->dato) insertar (&(*ra iz ) ->der, indice) ; e lse { (pr intf ( "\n No se puede insertar indice dupl icado \n\n" ) ) ; getch( ) ; } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Grafica un Arbol vo id GmuestraABJ(nodoarbol *p, int nivel , int col , int pos, int i ) { set l inesty le (0,1,0) ; i f ( ! P ) ) { GmuestraABJ(p->izquierda,n ive l+1,col -pos/2,pos/2,col ) ; s[0]=p->dato ; setco lor (4) ; l ine( i , (n ivel -1)*45,co l ,n ive l*45) ; c i rc le (co l ,nivel*45,10); setco lor (10) ; outtextxy (col -5 ,n ive l*45-5,s ) ; GmuestraABJ(p->derecha,n ive l+1,co l + pos/2, pos/2,col ) ; set l inesty le (0,1,0) ; } } Operaciones básicas

Una tarea muy común a real izar con un árbol es ejecutar una determinada operación con cada uno de los e lementos del árbol . Esta operac ión se cons idera entonces como un parámetro de una taré más general que es la v is i ta de todos los nodos o, como se denomina usualmente, del recorr ido del árbol .

Si se considera la tarea como un proceso secuencial , entonces los nodos indiv iduales se v is i tan en un orden espec íf ico , y pueden cons iderarse como organizados según una estructura l inea l . De hecho, se s impl i f ica considerablemente la descr ipc ión de muchos algor i tmos si puede hablarse de l proceso del s igu iente elemento en el árbol , según un cierto orden subyacente.

Recorrido de árboles binarios

Hay dos formas bás icas de recorrer un árbol : E l recorr ido en ampl i tud y el recorr ido en profundidad. Recorr ido en ampl i tud. - Es aquel recorr ido que recorre el árbol por niveles, en e l úl t imo e jemplo ser ía:

12 - 8,17 - 5 ,9,15

Recorr ido en profundidad. - Recorre el árbol por subárboles. Hay t res formas: Preorden, In orden y postorden.

Preorden: Raiz, subárbol izquierdo y subárbol derecho.

In Orden: Subarbol izqu ierdo, ra iz , subárbol derecho.

Postorden: Subarbol i zqu ierdo, subarbol derecho, raiz .



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

E jemplo: Preorden: 20 - 12 - 5 - 2 - 7 - 13 - 15 - 40 - 30 - 35 - 47 In Orden: 2 - 5 - 7 - 12 - 13 - 15 - 20 - 30 - 35 - 40 - 47 Postorden: 2 - 7 - 5 - 15 - 13 - 12 - 35 - 30 - 47 - 40 - 20

Ejemplo: Preorden: / + a b * c d

Orden In Orden: a + b / c * d

Postorden: a b + c d * /

Si se desea manipular la información contenida en un árbol, lo primero que hay que saber es cómo 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 información del árbol. Este orden puede ser útil en determinadas ocasiones. Cuando se recorre un árbol se desea tratar cada nodo y cada subárbol de la misma manera. Existen entonces seis posibles formas de recorrer un árbol binario.

• (1) nodo - subárbol izquierdo - subárbol derecho • (2) subárbol izquierdo - nodo - subárbol derecho • (3) subárbol izquierdo - subárbol derecho - nodo • (4) nodo - subárbol derecho - subárbol izquierdo • (5) subárbol derecho - nodo - subárbol izquierdo • (6) subárbol derecho - subárbol izquierdo - nodo

Si se adopta el convenio de que, por razones de simetría, siempre se recorrera antes el subárbol 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 posición en que se procesa la información del nodo, reciben, respectivamente, el nombre de recorrido prefijo, infijo y posfijo y dan lugar a algoritmos eminentemente recursivos:

Algoritmo Prefi jo (Pre Orden)

void preorder(NODOARBOL *cabeza){ if(cabeza!=NULL){ printf("%d ", cabeza->dato); preorder(cabeza->izq); preorder(cabeza->der); } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Algoritmo Inf i jo ( 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:



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Operaciones con árboles binarios La primera operación a considerar sobre árboles binarios será su generación. En este caso, no vamos a entrar a considerar todos los casos que pueden aparecer al insertar un nuevo nodo en un árbol, la problemática puede ser amplia y el proceso de generación de un árbol dependerá de las reglas impuestas por una aplicación particular. Vamos a ver, sin embargo, algún ejemplo concreto que permita ilustrar esta operación. Al manipular la estructura árbol, la situación más habitual es que el problema imponga una serie de reglas para la construcción del árbol en función de los datos de entrada. Estos datos, en principio, serán desconocidos antes de la ejecución del programa. El procedimiento de generación del árbol deberá, por tanto, reproducir de la manera más eficiente posible esas reglas de generación.

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 notación secuencial que permita la interpretación simple de las relaciones. Ésta notación es similar a la representación secuencial que se comentó para árboles binarios completos, y que se extendió a cualquier árbol arbitrario. La notación consiste en una secuencia de caracteres que indica la información de cada nodo en el árbol completo asociado, de manera que se indica también si algún subárbol está vacío y se supone que la información del subárbol izquierdo va siempre antes que la del subárbol derecho. En realidad se trata de una representación secuencial del recorrido prefijo del árbol. Se considerará, para simplificar, que la información asociada con cada nodo es simplemente un carácter y que los subárboles vacíos se representan con un '.'. Entonces la entrada al algoritmo de generación 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 generación del árbol binario a partir de su representación secuencial serían: (1) Leer carácter a carácter la secuencia de entrada. (2) Si el carácter que se lee es '.' no hay que crear ningún nodo, el subárbol está vacío. (3) Si se lee un carácter distinto de '.' entonces se crea un nuevo nodo con la información leída y se pasa a generar los subárboles izquierdo y derecho de ese nodo, según los mismos criterios y en ese mismo orden. Un algoritmo que implemente estas reglas de generación podría 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 generación.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Ejemplo 2:

Generar el árbol binario de representación de una expresión aritmética. Para ello se realizan las siguientes consideraciones: (1) La entrada del programa deberá ser una expresión escrita en notación infija. (2) En las expresiones sólo se tendrán en cuenta los cuatro operadores binarios básicos: +, -, *, / y no se considerarán paréntesis. (3) Los operandos serán exclusivamente caracteres. La generación del árbol se facilita considerablemente si se traduce la expresión a notación posfija y se almacenan los elementos de la expresión en una pila, según 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: función 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



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

devolver(p) fin_sino Fin

Ejemplo 4: función 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: eliminación de nodos.

El borrado de nodos es otra operación habitual de manipulación de árboles binarios. Hay que tener en cuenta que esta operación debe mantener la estructura del árbol y, por tanto, dependerá del orden que se haya establecido dentro del árbol. Esto hace que la eliminación de nodos se pueda convertir en una operación más compleja y que no se pueda hablar de un algoritmo general de borrado, más 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 están 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 más simple, implica borrar un nodo que tenga al menos un subárbol vacío. El segundo caso, más complejo, aparece cuando se desea borrar un nodo cuyos dos subárboles son no vacíos. 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 subárboles no vacíos, el proceso de reestructuración de las relaciones dentro del árbol resulta más 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 subárbol no vacío, el nodo debe ser sustituido por su nodo hijo. Estas dos últimas situaciones no implican una reestructuración 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 sería:



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

(In Orden)

Si se desea borrar el nodo C, que tiene dos nodos hijos, el nodo que debería sustituirle sería el nodo G, ya que es su sucesor en el orden establecido por el recorrido infijo. En general, sea cuál 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 ordenación de los nodos van a dar lugar a distintos algoritmos para determinar el sucesor de un nodo, según el orden establecido, y para modificar los enlaces entre nodos. Hace falta especificar los algoritmos que permitirán encontrar el padre y el sucesor infijo de un nodo del árbol.

Representación de árboles generales como árboles binarios Vamos a ver en este apartado que cualquier árbol se puede representar como un árbol binario. Esto es importante porque resulta más complejo manipular nodos de grado variable (número variable de relaciones) que nodos de grado fijo. Una posibilidad evidente de fijar un límite en el número de relaciones sería seleccionar un número k de hijos para cada nodo, donde k es el grado máximo para un nodo del árbol. Sin embargo, esta solución desaprovecha mucho espacio de memoria.

• Lema 4:para un árbol k-ario (es decir, de grado k) con n nodos, cada uno de tamaño fijo, el número 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, más de 2/3 de los enlaces serán nulos. Y la proporción 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 sólo la mitad de los enlaces son nulos, además de facilitar su manipulación. Para representar cualquier árbol por un árbol binario, vamos a hacer uso implícito de que el orden de los hijos de un nodo en un árbol general no es importante. La razón por la cual, para representar un árbol general, se necesitarían nodos con muchos enlaces es que, hemos pensado en una representación basada en la relación padre-hijo dentro del árbol, y un nodo puede tener un gran número de hijos. Sin embargo, se puede encontrar una forma de representación donde cada nodo sólo necesite tener dos relaciones, una que lo una con el hijo que tenga más 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 podría ser el hijo que está más a la izquierda, el nodo padre y cualquiera de los nodos hermanos podría ser el siguiente hermano por la derecha. Por lo tanto, la elección de estos nodos no dejará de ser, hasta cierto punto, arbitraria. Podemos basarnos para esta elección en la representación gráfica 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 más a la izquierda.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Este tipo de representación 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 raíz nunca tendrá un subárbol derecho, ya que no tiene ningún hermano. Pero esto nos permite representar un bosque de árboles generales como un único árbol binario, obteniendo primero la transformación binaria de cada árbol y después uniendo todos los árboles binarios considerando que todos los nodos raíz son hermanos. Ver el ejemplo de la figura:

En todas estas representaciones de árbol general a árbol binario hay que tener en cuenta la interpretación 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 manipulación de árboles binarios que se han visto hasta ahora. De hecho, en todos estos algoritmos se diferenciaba claramente entre el tratamiento del subárbol izquierdo y el del subárbol derecho



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

ANEXOS



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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) {



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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(); }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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)



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

{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; } } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

• 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 función para poder insertar un nuevo elemento a la lista antes de un elemento determinado

• Construir una función para poder insertar un nuevo elemento a la lista después 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){



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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; } } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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; } 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;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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(); } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 )



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

{ //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; } } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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);

getch(); continue;

}

switch(opcion){

case 6:

clrscr();

printf("\nIngrese elemento a insertar [0 : 99]: "); gets(dato);



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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;

case 14:

clrscr();

printf("El rbol postorder es: "); postorder(raiz);



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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 */

/****************************************************************/


int dato;

struct nodo *izq;

struct nodo *der;

} NODOARBOL;

void insertar(NODOARBOL **cabeza, int elemento){

if(*cabeza==NULL){

*cabeza= (NODOARBOL *) malloc(sizeof(NODOARBOL));

if(*cabeza==NULL){

printf("No hay memoria\n");

return;

}

(*cabeza)->dato=elemento;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

(*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);

}

}

void postorder(NODOARBOL *cabeza){

if(cabeza!=NULL){

postorder(cabeza->izq);

postorder(cabeza->der);

printf("%d ",cabeza->dato);

}

}



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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){

p1=cabeza->izq;

free(cabeza);

return(p1);

}

else{

p2=cabeza->der;

p1=cabeza->der;

while(p1->izq) p1=p1->izq;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

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);}

}



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

/****************************************************************/

/* 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);


cprintf(" Insertar ");

aux=getch();

textcolor(15);

textbackground(4);

gotoxy(28,pos);


break;


textcolor(YELLOW);


cprintf(" Eliminar ");

aux=getch();

textcolor(15);

textbackground(4);

gotoxy(28,pos);


break;



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I


textcolor(YELLOW);


cprintf(" Inorder ");

aux=getch();

textcolor(15);

textbackground(4);

gotoxy(28,pos);


break;


textcolor(YELLOW);


cprintf(" Preorder ");

aux=getch();

textcolor(15);

textbackground(4);

gotoxy(28,pos);


break;


textcolor(YELLOW);


cprintf(" Postorder ");

aux=getch();

textcolor(15);

textbackground(4);

gotoxy(28,pos);


break;


textcolor(YELLOW);


cprintf(" Graficar ");

aux=getch();

textcolor(15);



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

textbackground(4);

gotoxy(28,pos);


break;


textcolor(YELLOW);


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();

}

}

}

/****************************************************************/

/* ACERCA DE ... */

/****************************************************************/

int acerca_de(void){

window(10,6,70,18);

textcolor(BLACK);



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

textbackground(WHITE);

clrscr();

cprintf("\n\r ESCUELA POLIT CNICA NACIONAL");

cprintf("\n\n\r CARRERA DE INGENIERÖA DE SISTEMAS\n\r\n\r");

cprintf(" PROGRAMACIàN II\n\r\n\r");

cprintf(" Autor: Adri n Fernando Vaca C rdenas\n\r");

cprintf(" Curso: GR1\n\r\n\r");

cprintf(" 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);




ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

gotoxy(28,8);


gotoxy(28,10);


gotoxy(28,12);


gotoxy(28,14);


gotoxy(28,16);


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);

cprintf(" Utilize las flechas del cursor para desplazarse.");

gotoxy(50,1);

textcolor(WHITE);

cprintf(" Enter para aceptar su opci¢n.");

}



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

UNIVERSIDAD TECNICA DE MANABI CIENCIAS INFORMATICAS

APORTE DE ESTRUCTURA DE DATOS

NOMBRE: SEMESTRE: Tercero “__” PARCIAL: Primero FECHA: PROFESOR: Ing. ______________ La empresa eléctrica Emelmanabi desea mejorar su servicio a los usuarios, Se esta pensando usar una lista abierta, en la cual se pueda almacenar la siguiente información sobre los clientes: Ruta ( entero) Secuencia(entero) n_medidor(entero) propietario(cadena) dirección (cadena)

Se solicita Implementar:

1. Una función para insertar los datos digitados en la lista abierta de forma ordenada con respecto al n_medidor.

2. Una función para Mostar la lista abierta. 3. Una función que permita Eliminar datos específicos de un X n_medidor de la lista abierta. 4. Crear la estructura del nodo, implemente el programa principal, y registre 20 clientes.


APORTE DE ESTRUCTURA DE DATOS NOMBRE: SEMESTRE: Tercero “__” PARCIAL: Primero FECHA: PROFESOR: Ing. _______________

La empresa eléctrica Emelmanabi desea mejorar su servicio a los usuarios, Se esta pensando usar una lista abierta, en la cual se pueda almacenar la siguiente información sobre los clientes:

Ruta ( entero) Secuencia(entero) n_medidor(entero) propietario(cadena) dirección (cadena)


1. Una función para insertar los datos digitados al final de la lista abierta. 2. Una función para Mostar la lista abierta. 3. Una función que permita ordenar los datos de la lista abierta. 4. Crear la estructura del nodo, implemente el programa principal, y registre 20 clientes.



NOMBRE: SEMESTRE: Tercero “________” PARCIAL: Primero FECHA: PROFESOR: Ing. __________ La empresa eléctrica Emelmanabi desea mejorar su servicio a los usuarios, Se esta pensando usar una lista abierta, en la cual se pueda almacenar la siguiente información sobre los clientes:

Ruta ( entero) Secuencia(entero) n_medidor(entero) propietario(cadena) dirección (cadena)


1. Una función para insertar los datos digitados al inicio de la lista abierta. 2. Una función para Mostar la lista abierta. 3. Una función 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

UNIVERSIDAD TECNICA DE MANABI

CIENCIAS INFORMATICAS

EXAMEN DE ESTRUCTURA DE DATOS

NOMBRE:

SEMESTRE: Tercero “C” PARCIAL: Segundo

FECHA: jueves 9 de agosto del 2007 PROFESOR: Ing. Christian Torres

1. Con el siguiente recorrido en In Orden llenar el siguiente árbol, y responder las siguientes incógnitas

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 Raíz: ____________

2. Escriba una función recursiva que permita calcular el factorial de un número cualquiera.

3. Diseñe 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, deberán ser almacenados en una pila, sus nombres y promedio (N1 + N2) y de la lista doblemente enlazados deberán 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.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I




NOMBRE:

SEMESTRE: Tercero “__” PARCIAL: Segundo

FECHA: ____________________ PROFESOR: Ing. _______________

1.- Dado el siguiente árbol encuentre: (2.5pts.)

a) Numero de Hojas_______________________

b) Nodos Hojas __________________________

c) Nodo Raíz ____________________________

d) Nodos Ramas__________________________

e) Profundidad___________________________

f) Altura________________________________

g) Grado________________________________

h) Recorrido en In Orden____________________

i) Recorrido en Post Orden __________________

j) Recorrido en Pre Orden ___________________

2) Escriba la estructura de una lista doblemente enlazada e implemente una función para Ingresar la información (usted elija la información 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 comparación de los datos que están en el árbol con los que están en la lista cerradas, para generar una pila que almacene los datos del árbol que no están en la lista cerrada, y finalmente imprimir los datos de la lista y los de la pila generada.

La información que maneja tanto el árbol como la lista cerrada es un número entero.

Cree las funciones:

- generar la pila - imprimir lista, y - imprimir pila

A

N B

C J

D

E

F

G

H

I

K

L

M

Q

P

R



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I

Universidad Técnica de Manabí

Facultad de Ciencias Informáticas 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 sería 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:_____________________________________

4) Con los siguientes Datos construya un árbol binario 83 - 69 – 13 – 2 - 8 – 56 - 21 - 34

/

+ G

* ↑

+ / E F

A B C D



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I




NOMBRE:

SEMESTRE: Tercero “__” PARCIAL: Primero

FECHA: ___________________ PROFESOR: Ing. _____________________

Se desea implementar un sistema para la Clínica San Antonio, el cual utilice listas abiertas. El mismo deberá almacenar la siguiente información sobre los pacientes:

historia_clinica, nombres, cedula, edad, dirección, sexo


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 función para insertar los datos digitados en la lista abierta de forma ordenada con respecto al historia_clinica. (1.0pts)

3. Cree una función que llene otra lista con los datos de los pacientes que tengan menos de 20 años. 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


LISTA QUE SE GENERARIA


003 AMARILIS ZAMORA 1312526241 15 PORTOVIEJO FEMENINO


4. Una función 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 también la nueva lista generada con los menores a 20 años.



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I



PERIODO SEPTIEMBRE 2007 – MARZO 2008


NOMBRE:

SEMESTRE: Tercero “_______” PARCIAL: Primero

FECHA: ____________________ PROFESOR: Ing. ___________________________

Se tiene una lista abierta con los campos:

int codigo:

char nombre[35];

float sueldo;

1) Implemente una función 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 función 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 gráficamente lo que realiza este procedimiento, cual seria el verdadero nombre de este procedimiento y para que serviría 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; } } }



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I




NOMBRE:

SEMESTRE: Tercero “__” PARCIAL: Segundo

FECHA: _______________________ PROFESOR: Ing. ________________

4. Construya un árbol binario a partir del siguiente árbol valor:

1.00pts

5. De su respuesta en la pregunta anterior: valor:

1.00pts a. Realizar el recorrido en Post Orden. b. Grado : _________ c. Altura:_________

6. Diseñe 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 función que escriba la observación 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

• .Finalmente imprima la lista doble y luego la lista simple. valor:

1.00pts • Llamado a las funciones(Programa principal) valor: 0.25pts

Implemente las funciones necesarias



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I



EXAMEN DE RECUPERACIÓN DE ESTRUCTURA DE DATOS

NOMBRE:

SEMESTRE: Tercero “C”

PROFESOR: Ing. Christian Torres FECHA: jueves 16 de agosto del 2007

typedef struct nodo typedef tipoNodo * pNodo;

{char nombre[40]; typedef tipoNodo *Lista;

char apellido[30];

char fono[15];

int edad;

struct nodo * sig;

}tipoNodo;

1. Teniendo la presente estructura y definición de tipos de datos, implemente una función para insertar nodos al inicio de una lista abierta. (1.5 pts)

2. Implemente una función 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 función. ( 4.0pts)

3. Escriba una función 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 función que permita invertir una pila. ( 3.0pts)



ES

TR

UC

TU

RA

DE

DA

TO

S I

--

FC

I



EXAMEN DE RECUPERACIÓN 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 número de envió, peso, destino, el remitente y el costo del envió. Por razones de no contar con el suficiente personal de entrega, la empresa envía 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 serán despachados en el fin de semana (sábado 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 (sábado y domingo) (5pts)

2. Explique teóricamente o gráficamente, como poder entregar a las personas que tienen varios paquetes por recibir de diferente tamaño (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________________________________




INFORMÁTICOS


De acuerdo con el

reglamento

todavía no realizó

ningún tipo de

vinculación puesto

que aún no estoy

en 6to nivel.




INFORMÁTICOS


Durante este período he realizado las siguientes gestiones para la mejora de la Universidad Técnica de Manabí, lugar donde me desempeño como estudiante:

Minga realizada en la Universidad Técnica de Manabí.

Limpieza y adecuación del aula de matemáticas con el Profesor Ing. Emilio Suarez




INFORMÁTICOS


estructura portafolio

Documents