Portafolio2 aestructuragene

UNIVERSIDAD TÉCNICA DE MANABÍ

FACULTAD DE CIENCIAS INFORMATICA

ESTRUCTURA DE DATOS ING. CRISTHIAN TORRES

SEGUNDO “B”

PORTAFOLIO DE ESTRUCTURA DE DATOS.

Elaborado por:

GENESIS GINA PEÑAFIEL PIN

Periodo: Abril ~ Septiembre

2013


MISIÓN

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.

VISIÓN

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.

FACULTAD DE CIENCIAS INFORMATICA

MISIÓN:

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.

VISIÓN:

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.

INDICE DE CONENIDOS.

SYLLABUS

PRONTUARIO DEL CURSO

CARTA DE PRESENTACIÓN

AUTORRETRATO

DIARIO META COGNITO

ARTICULOS DE REVISTA PROFESIONALES

TRABAJNO DE EJECUCION

TAREAS

MATERIALES RELACIONADOS CON LA CLASE.

ANEXOS

RESUMEN DE CIERRE


FACULTAD DE CIENCIAS INFORMATICA CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS

SYLLABUS

I.-INFORMACIÓN GENERAL

FACULTAD/DEPARTAMENTO: FACULTAD DE CIENCIAS INFORMÁTICAS

CARRERA: INGENIERÍA EN SISTEMAS INFORMÁTICOS

ASIGNATURA/MÓDULO: ESTRUCTURA DE DATOS CÓDIGO: OF-0201

Nivel / Semestre: 2 N° de Créditos:5 Modalidad : Presencial Paralelo: 2do. “B” Período Académico: Sept. 25/2012 – Feb 14/2013 Área Académica: SOFTWARE

PRERREQUISITO (S): CORREQUISITO (S): CONTENIDOS DISCIPLINARES QUE DEBEN SER APROBADAS ANTES DE

CURSAR ESTE CONTENIDO DISCIPLINAR

CÓDIGO

CONTENIDOS DISCIPLINARES QUE DEBEN SER CURSADOS AL

MISMO TIEMPO QUE ESTE CONTENIDO DISCIPLINAR

CÓDIGO

PROGRAMACIÓN I OC-0100

DOCENTE: Ing. CHRISTIAN RONALD TORRES MORÁN

Título: MAGITER EN GERENCIA EDUCATIVA E-mail: [email protected]

Datos personales: Profesor contratado a tiempo completo de la asignatura Estructura de Datos, y Herramientas Web

Director de Tesis de Ingeniería en Sistemas Informáticos, miembro de los equipos de Vinculación con la sociedad, Docente

Tutor 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 FORMATIVA

a.- 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ón haciendo 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 en los diseños, construcciones y usos principales de algoritmos en la estructuración de datos lineales y no lineales

c.- DESCRIPCIÓN DE LA ASIGNATURA: 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.

mailto:[email protected]

Resultados del Aprendizaje

(Objetivos Específicos)

Formas

Evidenciarlos (Apreciación)

Niveles del resultado de aprendizaje

Ponderación

1.- Identificar los tipos estructurados de datos estáticos y dinámicos empleados en la creación de aplicaciones, considerando los lenguajes de programación. (Nivel Taxonómico: Conocimiento)

1.- Pruebas escritas, orales (fotos), talleres, informes de ensayo, investigación y Prácticas en el Lenguaje de programación C++.

Describirá la definición de la estructura de

datos, los tipos de datos simples, básicos y

compuestos en un ensayo técnico con:

descripción general del tema clara; ideas que

tienen relación, claridad y objetividad con el

tema; y una conclusión clara con aporte personal.

Describirá la definición de la estructura de datos,

los tipos de datos simples, básicos y

compuestos en un ensayo técnico con: descripción

general del tema confusa; pocas ideas que

tienen relación, claridad y objetividad con

el tema; y una conclusión confusa con aporte

personal.

Describirá la definición de la estructura de

datos, los tipos de datos simples, básicos y

compuestos en un ensayo técnico con:

descripción general del tema confusa; poca o

ninguna idea que tienen relación, claridad y

objetividad con el tema; y una conclusión confusa

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

2.- Elaborar aplicaciones dinámicas de estructura lineal, almacenamiento y recuperación de los mismos en unidades de almacenamiento, aplicarán soluciones de administración de memoria mediante el desarrollo de aplicaciones científicas y comerciales. (Nivel Taxonómico: Aplicación)


Comparará con la utilización de un cuadro

comparativo tres semejanzas y tres diferencias

entre los tipos de datos que permiten almacenar

más de un dato; reflejando las relaciones de

las comparaciones con ideas claras.

Comparará con la utilización de un cuadro

comparativo tres semejanzas y tres diferencias

entre los tipos de datos que permiten almacenar

más de un dato; reflejando las relaciones de

las comparaciones con ideas pocos claras.

Comparará con la utilización de un

cuadro comparativo dos semejanzas y dos

diferencias entre los tipos de datos que permiten

almacenar más de un dato; reflejando las

relaciones de las comparaciones con ideas

confusas.

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

III.- RESULTADOS DE APRENDIZAJE DE LA ASIGNATURA

3.- Implementar aplicaciones

dinámicas de estructura Lineal, almacenamiento y recuperación de los mismos en unidades de almacenamiento, aplicarán soluciones de administración de memoria mediante el desarrollo de aplicaciones científicas y

comerciales (Nivel Taxonómico: Aplicación)


Implementará aplicaciones dinámicas de

estructura Lineal, almacenamiento y recuperación

de los mismos en unidades de

almacenamiento, aplicarán soluciones de

administración de memoria mediante el desarrollo

de aplicaciones científicas y comerciales.


estructura Lineal, almacenamiento y recuperación

de los mismos en unidades de

almacenamiento, aplicarán soluciones de

administración de memoria mediante el desarrollo

de aplicaciones comerciales.


estructura No Lineal, almacenamiento y

recuperación de los mismos en unidades de

almacenamiento.

NIVEL ALTO:

86-100

NIVELMEDIO

71-85

NIVEL BÁSICO

70

4.- Implementar aplicaciones dinámicas de estructura no Lineal, almacenamiento y recuperación de los mismos en unidades de almacenamiento, aplicarán soluciones de administración de memoria mediante el desarrollo de aplicaciones científicas y comerciales (Nivel Taxonómico: Aplicación)


Elaborará un programa con estructuras dinámicas

no lineales bien detallado.

Elaborará un programa con estructuras dinámicas

no lineales con poca claridad.

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

NIVEL ALTO:

86-100

NIVEL MEDIO

71-85

NIVEL BÁSICO

70

5.- Organizar la información en algoritmos y estructuras AVL y su relación con los gestores de Base de Datos (Nivel Taxonómico: Aplicación)


Elaborará un programa que emplee estructuras

arborescentes de forma AVL uso de forma clara.

Elaborará un programa que emplee estructuras

arborescentes de forma AVL de forma poco clara.

Elaborará un programa que emplee estructuras arborescentes 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° TOT AL

HOR AS P-A

HORAS PRESENCIALES

HORAS AUTÓNOMAS

ESTRATEGIAS PARA EL TRABAJO AUTÓNOMO

1. UNIDAD I: GENERALIDADES Y

DEFINICIONES DE ESTRUCTURA DE

DATOS

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.

23 Tareas extra- clases. Investigación del tema de la unidad Tareas en el lenguaje de programación C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Técnica de Manabí, Internet. Guardar la evidencia en el Portafolio Digital.

-Formarán equipos de 2 estudiantes -Del taller o tarea respectivas se escogerán ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicará la técnica de procesos. -Al final de la tarea se 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. (Aporte Significativo de Aprendizaje de la Tarea o Taller).

-Para el ensayo del tema respetivo se Tomarán lo lineamientos más importantes de la introducción llamativa, fundamentación y conclusión crítica.

2. UNIDAD II: ESTRUCTURAS SIMPLES

Y COMPUESTAS

Listas Abiertas

60 30

Experiencia:

Aplicando lluvia de ideas

concretar conocimientos

relativo a problemas

30 Tareas extra- clases. Investigación del tema de la unidad Tareas en el lenguaje de

-Formarán equipos de 2 estudiantes -Del taller o tarea respectivas se escogerán ejercicios representativos de acuerdo al resultado de aprendizaje

-Se aplicará la técnica de procesos. -Al final de la tarea se

Definición de listas abiertas

Declaración e implementación

de 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


de una lista circular






Listas doblemente enlazadas abiertas

y cerradas


de una lista doblemente

enlazada






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:

Resolución de ejercicios

demostrativos y de


programación C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Técnica de Manabí, Internet. Guardar la evidencia en el Portafolio 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. (Aporte Significativo de Aprendizaje de la Tarea o Taller). -Para el ensayo del tema respetivo se Tomarán lo lineamientos más importantes de la introducción llamativa, fundamentación y conclusión crítica.

3. UNIDAD III: ESTRUCTURAS

ARBORESCENTES

Definición, implementación

26 13

Experiencia:

• Aplicando debates

definir la importancia de

aplicar algoritmos generales de

13 Tareas extra- clases. Investigación del tema de la unidad Tareas en el

-Formarán equipos de 2 estudiantes -Del taller o tarea respectivas se escogerán ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicará la técnica de procesos.

Tipos de recorridos:

PreOrden

InOrden

PostOrden

Operaciones con Árboles Binarios de

Bú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 árboles

vací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 de programación C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Técnica de Manabí, Internet. Guardar la evidencia en el Portafolio Digital.

-Al final de la tarea se 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. (Aporte Significativo de Aprendizaje de la Tarea o Taller). -Para el ensayo del tema respetivo se Tomarán lo lineamientos más importantes de la introducción llamativa, fundamentación y conclusión crítica.

4. UNIDAD IV: TIPOS DE ÁRBOLES

ESPECIALES

Á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 la

derecha.

Rotación doble de nodos s la

izquierda.

Reequilibrados de árboles

AVL.

Reequilibrados en árboles AVL 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:

14 Tareas extra- clases. Investigación del tema de la unidad Tareas en el lenguaje de programación C++. CD. interactivo libros PDF. Apoyo para el estudiante, Espacio virtual de la Universidad Técnica de Manabí, Internet. Guardar la evidencia en el Portafolio Digital.

-Formarán equipos de 2 estudiantes -Del taller o tarea respectivas se escogerán ejercicios representativos de acuerdo al resultado de aprendizaje -Se aplicará la técnica de procesos. -Al final de la tarea se 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. (Aporte Significativo de Aprendizaje de la Tarea o Taller).

-Para el ensayo del tema respetivo se Tomarán lo lineamientos más importantes de la introducción llamativa, fundamentación y conclusión crítica.

MEDIO CICLO FINAL DE CICLO EXAMEN DE RECUPERACIÓN

ASISTENCIA

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

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

Participación 2.5 2.5 Exposiciones 2.5 2.5

ACTIVIDADES DE INVESTIGACIÓN PORTAFOLIO PROYECTO INFORME FINAL (30%)

5 10

5

10

TOTAL

Reequilibrados en árboles

AVL por borrado de un nodo. Resolución de ejercicios

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ÓN Las evaluaciones estarán orientadas a los procesos, lo que conlleva a que ninguna evaluación tenga una ponderación determinante para la acreditación. Durante el periodo académico, el estudiante de la Universidad Técnica de Manabí, se someterá obligatoriamente a los siguientes parámetros de evaluación de los aprendizajes: evaluación de medio ciclo, evaluación de final de cic lo, evaluación de actividades varias y evaluaciones de investigaciones.

ACREDITACIÓN

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

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

practica con objetos orientados a objetos

7° 2008 Elda Quiroga

TORRES, Christian Manuales de estructura de Datos 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 Estructura de 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

http://c.conclase.net/edd/

http://www.utm.edu.ec/

http://evirtual.utm.edu.ec/course/view.php

http://www.dc.uba.ar/

http://www.programacion.com/articulo/estructuras_de_datos_y_algoritmos_en_java_309/2

http://www.youtube.com/watch

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

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

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

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

d. Capacidad para funcionar como parte de un equipo de profesionales de distintas áreas del conocimiento, demostrando una efectiva cooperación, comunicación, con habilidades para resolver conflictos y contribuyendo proactivamente en la propuesta de líneas estratégicas desde 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ía planteados de acuerdo a las necesidades del medio.

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

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

h. Habilidad y capacidad para comprender el impacto de las soluciones informáticas a la realidad local, 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, con capacidad 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 de software 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

UNIVERSIDAD TÉCNICA DE MANABÍ FACULTAD DE CIENCIAS INFORMATICA

CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS

PROGRAMA CODIFICACIÓN DEL CURSO:

Título del curso: estructura de dato

Número créditos: cinco (5) créditos

Total de Horas del Curso: 80 horas

PRONTUARIO

I. INFORMACIÓN GENERAL

II. DESCRIPCIÓN DEL CURSO

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.


CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS CARTA DE PRESENTACIÓN Este portafolio presenta mi trayectoria en el curso de: ESTRUCTURA DE DATO, este curso tuvo como objetivos desarrollar las destrezas de. Las habilidades y agilidad. Durante este semestre pude conocer sobre. Las estructuras anidadas, funciones, punteros, listas simples, pilas, y colas, listas doblemente enlazadas, arboles abb, arboles avl. Las técnicas presentadas por el docente me ayudaron a mejorar como futuro profesional de la Informática. Las áreas más dificultosas del curso fueron:

Lo más dificultoso fue sobre las listas simples, y las estructura anidadas



AUTORRETRATO

Mi nombre es Peñafiel Pin Genesis Gina. Soy estudiante de la asignatura de ESTRUCTURA DE DATO,

actualmente curso el segundo semestre en la Facultad de Ciencias Informáticas de la Universidad Técnica de

Manabí. Soy una persona responsable, organizada y me gusta trabajar en equipo.

Mis metas son convertirme en un profesional de la Ingeniería en Sistemas Informáticos.



Clase: #1

Fecha: 06 Mayo 2013.

Tema: APLICACIÓN DE LA PROGRAMACION BÁSICA

INTRODUCCIÓN.

Una de las aplicaciones más interesantes y potentes de la memoria dinámica y de los punteros son, sin

duda, las estructuras dinámicas de datos. Las estructuras básicas disponibles en C y C++ (structs y arrays)

tienen una importante limitación: no pueden cambiar de tamaño durante la ejecución. Los arrays 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.

Generalidades y definiciones de Estructura de Datos

- 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


FACULTAD DE CIENCIAS INFORMATICA CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS

Clase: #2


SINTAXIS DE UNA ESTRUCTURA:

Struct [Etiqueta]

{ Iniciar la estructura

Campo 1 o miembros;

Campo 2 o miembros;

Campo 3 o miembros;

}; Llave de finalizar que termina en (;)

CAMPOS (se definen como las variables de tipo de datos, enteros, float, char, Boolean, entre

otros)

ETIQUETA en algunos caso se suprimen pero siempre una etiqueta reconocer a la estructura que se a

creado.

Palabra reservada en Borland que permite

crear espacio de memoria

Es el nombre que se le va a dar a una estructura

[Campos] identifican el tipo de datos se

definen como las variables de tipo de

datos.

Variable es el espacio de memoria.

#include <iostream.h>

#include <string.h>

#include <conio.h>

Struct tnotas{

char nom_est[30];

float calif ;

};

Void main()

{

Struct tnotas c;

c.calif=7.5; \\ el . Identifica que se va a acceder a la estructura y luego se escribe un nombre que se va a dar

strcpy(c.nom_est,”Juan Jose Flores”);

getch();

}

Nom_est calif

Juan Jose Flores 7.5



Clase: #3


Tema:

Estructura que permita almacenar nombre, apellidos, sueldo, ciudad. Departamento de empleados de una

fábrica.



Clase #4

Fecha: 15 mayo 2013

Asignar:

En cualquier lugar del programa.

Usa el = en algunos caso como string, se usa strcy, strcat.

Los mecanismos son d argumento get, printf.

Solo es posible cuando se crea la variable.

Se usa el = y la {}; detallando cada elemento y separado con (,) , se debe tener en cuenta al ser usado en estructura por la variable de tipo de dato.

¿QUÉ ES UNA ESTRUCTURA?

Una estructura es un grupo de variables los cuales pueden ser de diferentes tipos sostenidos.

cabeceras.h

funciones

prototipos

tipos de datos

main

implemenación por prototipo

AMBITO GLOBAL

AMBITO LOCAL


CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS Clase # 5 Fecha: 20 mayo 2013

EJERCICIO DE ESTRUCTURA DE DATO

#include <conio.h>

#include <stdio.h>


#include <iomanip.h>

//creacion de la estructura control_asistencia

struct control_asistencia{

char est[30];

char nivel[30];

char aula[];

char hora_inicio[30];

char hora_fin[30];

int dia;

int mes;

int anio;

};

//Se puede enviar un array de estructura de datos

//pasamos unas etructura normal, si se envia paso de parametros

//por valor loque se efetue en la variable no se devuelve a la variable global

void registrar(struct control_asistencia &c);

void imprimir(struct control_asistencia c);

//implementacion del programa

void registrar (control_asistencia &c)

{clrscr ();

printf("\nIngreso de la informacion");

printf("\n Ingrese el nombre del estudiante");

cin>>c.est;

printf("\n ingrese el paralelo");

cin>>c.nivel;

printf ("\n ingrese el codigo de aula del estudiante");

cin>>c.aula;

printf ("\n ingrese la hora de inicio ");

cin>>c.hora_inicio;

printf("\n ingrese hora de salida");

cin>>c.hora_fin;

char ch;

printf("\n ingrese la fecha en el formato dd/mm/anio");

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

cout <<"*******....ingreso finalizado...********";

}

void imprimir (control_asistencia c)

{

cout<<"\ndatos ingresados";

cout<<"\nnombre"<<"\t"<<"nivel"<<"\t"<<"paralelo"<<"\t"<<"aula"<<"\t"<<"hora inicio"<<"\t"<<"hora

final"<<"\t"<<"fecha";

cout<<setw(9)<<c.est<<setw(12)<<c.aula<<setw(1)<<c.nivel<<setw(6)<<c.hora_inicio<<setw(6)<<c.hora_fin

<<setw(2)<<c.dia<<"/"<<setw(2)<<c.mes<<"/"<<setw(4)<<c.anio<<endl;

}

void main()

{control_asistencia e;

registrar(e);

imprimir(e);

getch();

}

ESTRUCTURA ANIDADAS:

E.D----> contiene campos de tipo: Primitivo (int, float, char………….), Estructurado estático (array), estructura

de datos.

E.A----> puede darse de dos formas:

1. Internas

2. externas


CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS Clase # 6

Fecha: 20 mayo 2013.

Tema: FUNCIONES

Una función es un módulo de un programa separado del cuerpo principal, que realiza una tarea específica y

que puede regresar un valor a la parte principal del programa u otra función o procedimiento que la

invoque.

La forma general de una función es:

Tipodato Nomfun (parametros)

{

cuerpo de instrucciones;

return [dato,var,expresion];

}

Donde tipodato especifica el tipo de dato que regresara la función.

La instrucción RETURN es quien regresa un y solo un dato a la parte del programa

que la esté llamando o invocando, sin embargo es de considerar que return puede

regresar un dato, una variable o una expresión algebraica(no ecuación

o formula) como lo muestran los siguientes ejemplos;

a) return 3.1416;

b) return area;

c) return x + 15/2;

La lista de parametros formales es una lista de variables separadas por comas (,) que almacenaran los

valores que reciba la funcion, estas variables actúan como locales dentro del cuerpo de la funcion.

PASÓ DE STRUCTURA EN PARAMETRO.



Fecha : 22 mayo 2013

EJERCICIO

EJERCICIO:


CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS Clase # 8 Fecha:27 mayo 2013 Tema: Estructuras anidadas Una estructura puede estar dentro de otra estructura a esto se le conoce como anidamiento o estructuras

anidadas.

Ejemplo:

Crear un programa para mostrar fecha actual de una persona .

Se crea estructura : (día,mes,año)

NOTA: Setfill: filas Setw: espacios d caracteres (el tamaño)

Se crea void main

PUNTERO:

&= OPERADOR DE DIRECCIÓN.

*= OPERADOR DE INDIRECCIÓN – COTENIDO.

Int a;

Una posición d memoria es entregada a una variable.

Estas se crean un espacio de memoria (distribución de memoria), esa porción de menoría está distribuida en

hexadecimales.

a=10, *p;

P=&a;

P++;

El operador de memoria es extraer

P crea un vínculo en el espacio (control) y la tiene marcado.

Direccion es dond esta ubicada la variable 10,

Contenido es el valor k s le da a la variables en este caso

En las variable de aumento: p++

Puntero puede abandonar sin la necesidad de volver al mismo enlace.

NULL: para k no tenga ninguna complicación con ninguna mala aplicación….

Cuando el puntero se basa a un array, se crea el puntero y con el & quita el contenido(estas en direccion de

memoria).

Cout<< mat[0];

PUNTERO – ARRAY

Operador de indirección

Para sacarle a mat cad una de las posiciones a direccion de memoria dond esta el contenido

Una cadena de caracteres es un array de caracteres. La forma de definir un puntero


CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS Clase # 9 Fecha: 29 mayo 2013.



Fecha: 03 junio 2013

#include <conio.h>

#include <stdio.h>





char est[30];

char nivel[30];

char aula[];


char hora_fin[30];

int dia;

int mes;

int anio;

};




void registrar(struct control_asistencia &c);



void registrar (control_asistencia &c)

{clrscr ();



cin>>c.est;


cin>>c.nivel;


cin>>c.aula;


cin>>c.hora_inicio;


cin>>c.hora_fin;

char ch;


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


}


{


cout<<"\nnombre"<<"\t"<<"nivel"<<"\t"<<"paralelo"<<"\t"<<"aula"<<"\t"<<"hora inicio"<<"\t"<<"hora




}

void main()


registrar(e);

imprimir(e);

getch();

}

/*El mismo ejecicio anterior usando punteros */

#include <conio.h>

#include <stdio.h>





char est[30];

char nivel[30];

char aula[];


char hora_fin[30];

int dia;

int mes;

int anio;

};




void registrar(struct control_asistencia *c);



void registrar (control_asistencia *c)

{clrscr ();



cin>>c->est;


cin>>c->nivel;


cin>>c->aula;


cin>>c->hora_inicio;


cin>>c->hora_fin;

char ch;


cin>>c->dia>>ch>>c->mes>>ch>>c->anio;



{


cout<<"\nnombre"<<"\t"<<"nivel"<<"\t"<<"paralelo"<<"\t"<<"hora inicio"<<"\t"<<"hora

final"<<"\t"<<"fecha"



}

void main()


registrar(&e);

imprimir(e);

getch();

}

/*El mismo ejecicio anterior mediante asignacion a la estructura verdadera */

#include <conio.h>

#include <stdio.h>



#include <string.h>



char est[30];

char nivel[30];

char aula[];

char paralelo;


char hora_fin[30];

int dia;

int mes;

int anio;

};




void registrar(struct control_asistencia *c,char e[],char n[],char p,char a[],char hi[],char hf[],int d,int m,int

anio);



void registrar (control_asistencia *c,char e[],char n[],char p,char a[],char hi[],char hf[],int d,int m,int anio)

{clrscr ();

strcpy(c->est,e);

strcpy(c->nivel,n);

c->paralelo=p;

strcpy(c->aula,a);

strcpy(c->hora_inicio,hi);

strcpy(c->hora_fin,hf);

c->dia=d;

c->mes=m;

c->anio=anio;


}


{


cout<<"\nnombre"<<"\t"<<"nivel"<<"\t"<<"paralelo"<<"\t"<<"hora inicio"<<"\t"<<"hora


cout<<"\n"<<c.est<<"\t"<<c.nivel<<"\t"<<c.paralelo<<"\t"<<"\t"<<c.hora_inicio<<"\t"<<"\t"<<c.hora_fin<<"

\t"<<"\t"<<c.dia<<"/"<<c.mes<<"/"<<c.anio<<endl;

}

void main()


registrar(&e,"kelvin","tecero",'A',"Fci-102","14:00","17:00",3,6,2013);

imprimir(e);

getch();

}



ESTRUCTURAS ANIDADAS

#include<iostream.h>

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

typedef struct _alumnos{

char nom[25];

struct _alumnos *sig;

} tipoAlumno;

typedef tipoAlumno *pnodo;

typedef tipoAlumno *Lista;

//funciones prototipos

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

void ver_lista(Lista l);

void main()

{

Lista L1=NULL;

int op;

do{

prinf

almacenar(&L1,"ANA MARIA");

almacnar (&L,"CARLOS BRAVO")

ver_lista(L1);

}

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

{

pnodo nodo;

nodo=(pnodo)malloc(sizeof(tipoAlumno));

if (nodo==NULL)

{

cout<<"\n SIN ESPACIO DE MEMORIA" ;

return;

}

//se llena la informacion del nodo

strcpy(nodo-> nom,c);

//procedo hacer los enlaces

if(!*l)

{ //es el primer nodo que va a ingresar a la lista

nodo ->sig=NULL;

*l=nodo;

}





Clase # 13

Fecha: 12 mayo 2013

Definición

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;

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.

#include<conio.h>

#include<stdio.h>


#include<stdlib.h>

#include <string.h>


char nom[30];


}tipoAlumno;






void main()

{Lista L1=NULL;

int op;

do{

clrscr();

printf("\n1. Registrar Nombre");

printf("\n2. Mostrar Lista");

printf("\n3. Salir");

do{ cin>>op;

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

if (op==1)

{ char nombre[25];

clrscr();

printf("\nREGISTRO DE NUEVO CLIENTE\n");

printf("\n Ingrese un Nombre:");

fflush(stdin);

gets(nombre);

almacenar(&L1,nombre);

}

else if (op==2)

{clrscr();

ver_lista(L1);

}

}while(op!=3);

}

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

{pnodo nodo;


if (nodo==NULL)

{ cout<<"\n Sin espacio de memoria";

return;

}

//Se llena la informacion del nodo

strcpy(nodo->nom,c);

//Procedo hacer los enlaces

if (!*l)

{//es el primer nodo que va a ingresar a la lista

nodo->sig=NULL;

*l=nodo;

}

else

{nodo->sig=*l;

*l=nodo;

}

}

EJERCICIO:

//ahora se cambiara para ingresar al final de la lista

#include<conio.h>

#include<stdio.h>


#include<stdlib.h>

#include <string.h>


char nom[30];


}tipoAlumno;






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

void main()

{Lista L1=NULL;

int op;

do{

clrscr();

printf("\n1. Registrar Nombre");

printf("\n2 registrar al final");

printf("\n3. Mostrar Lista");

printf("\n4. Salir");

do{ cin>>op;

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

if (op<=2)

{ 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

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;

}




// (1)se simplifico el codigo anterior

nodo->sig=*l;

*l=nodo;

}

void ver_lista(Lista l)

{pnodo n=l;

while (n)

{cout<<"\n"<<n->nom;

n=n->sig;

}

getch();

}

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

aux->sig=nodo;

nodo->sig=NULL;

}

}


CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS Clase # 14 Fecha: 17 mayo 2013}

Tema: Pilas

*Es un tipo especial de listas abiertas *Es colección de nodos apilados uno encima de otro * tiene una cima o tope es la que indica por donde ingresan los nodos *Emplea un método LIFO(ultimo en entrar primero en salir) *La pila tiene dos estados -llena -vacía *Tiene 2 operaciones: -Apilar (Ingresar nodos por la cima). Son las mismas operaciones de la función ingresar al inicio de las listas abiertas.

-Desapilar (Leer y Eliminar el elemento de la cima)

EJERCICIO:

include<iostream.h>

#include<string.h>

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>


char nom[25];


}tipoAlumno;


typedef tipoAlumno *lista;

//funciones prototipo

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

void ver_lista(lista l);

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

void ordenar(lista *l, char c[]);

void eliminar(lista *l,char c[]);

void eliminar_all(lista *l);

void main ()

{clrscr();

lista l1=NULL;

int op;

char nombre[25];

do{

clrscr();

printf("\n !****************************************!");

printf("\n 1.REGISTRAR NOMBRE AL INICIO");

printf("\n 2.REGISTRAR NOMBRE AL FINAL");

printf("\n 3.MOSTRAR LISTA");

printf("\n 4.INGRESAR ORDENADA LA LISTA");

printf("\n 5.ELIMINAR UN ELEMENTO CUALQUIERA");

printf("\n 6.ELIMINAR TODA LA LISTA");

printf("\n 7.SALIR");

printf("\n !*****************************************!\n");

do{ cin>>op;

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

if (op<=2)

{

clrscr();

printf ("\n****REGISTRO NUEVO CLIENTE****\n");

printf ("\n*****Ingrese un nombre********\n");

fflush(stdin);

cin>>nombre;

if(op==1)

almacenar (&l1,nombre);

else

almacenar_fin(&l1,nombre);

}

else if(op==3)

{clrscr();

ver_lista(l1);

}

else if (op==4)

{

clrscr();

printf ("\n****REGISTRO NUEVO CLIENTE****\n");

printf ("\n*****Ingrese un nombre********\n");

fflush(stdin);

cin>>nombre;

ordenar(&l1,nombre);

}

else if(op==5)

{

clrscr();

printf ("\n****BORRAR NODO****\n");

printf ("\n*****Ingrese el nombre a eliminar********\n");

scanf("\n%s",nombre);

eliminar(&l1,nombre);

}

else if(op==6)

{

clrscr();

eliminar_all(&l1);

printf ("\n*****Lista borrada con exito********");

getch();

}

}

while (op!=7);

}

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

{pnodo nodo;

nodo=(pnodo) malloc(sizeof(tipoAlumno));

if (nodo==NULL)

{cout <<"\n SIN ESPACIO DE MEMORIA";

return ;

}

//LENO LA INFORMACION DLE NODO

strcpy (nodo->nom,c);

//PROCESO HACER LOS ENELACES

/* if(!*l) de las dos formas es lo mismo asi q mejor se elimina los casos

{//es e; [rimer nodo que va ingresra a la lista

nodo->siguiente=NULL;

*l=nodo;

}

else

{*/

nodo->sig=*l;

*l=nodo;

}

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

{pnodo nodo;


if (nodo==NULL)


return ;

}


//PROCESO HACER LOS ENELACES

if(!*l)

{nodo->sig=*l;

*l=nodo;

}

else

{pnodo aux=*l;

while(aux->sig!=NULL) //(aux->sig)

aux=aux->sig;

aux->sig=nodo;

nodo->sig=NULL;

}

}

void ver_lista(lista l)

{

if(!l)

{

cout<<"**********************LA LISTA ESTA VACIA********************";

}

else

{

while (l)

{

cout<<"\n" <<l->nom;

l=l->sig;

}

}

getch();

}

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

{

pnodo aux=*l,nodo;


if (nodo==NULL)


return ;

}

//LENO LA INFORMACION DEL NODO


//PROCESO HACER LOS ENELACES */

if(!*l) //de las dos formas es lo mismo asi q mejor se elimina los casos

{

nodo->sig=*l;

*l=nodo;

}

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

{ nodo->sig=*l;

*l=nodo;

}

else

{ while((aux->sig)&& (strcmp(aux->sig->nom,c)<0))

aux=aux->sig;

nodo->sig=aux->sig;

aux->sig=nodo;

}

getch();

}

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

getch();

}

}

}

}

void eliminar_all(lista *l)

{pnodo aux;

while(*l)

{ aux=*l; *l=aux->sig; free(aux); } }

(INDIVIDUALES)



TAREA # 1 Hacer una sopa de letras de dimensión 10x10 incluyendo 5 palabras el programa deberá generar, la serie y también que palabras existen escondidas.

Código del programa #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <iostream> int main(){ //En este bloque estamos creando el array sopa con el tipo de datos char char sopa[10][12]= {{'r','z','k','j','m','d','o','c','t','o','r','i'}, {'p','a','l','v','i','j','b','a','j','s','a','r'}, {'r','s','d','y','a','i','l','n','g','v','a','w'}, {'t','u','y','i','x','l','i','c','v','a','f','v'}, {'w','w','d','i','o','e','g','i','c','c','r','e'}, {'x','q','o','c','d','b','a','o','f','e','a','n'}, {'o','i','u','x','u','x','c','n','b','f','e','s'}, {'e','l','e','c','t','r','i','c','i','s','t','a'}, {'u','o','t','a','u','z','o','c','p','y','e','h'}, {'o','r','w','t','o','b','n','v','d','e','a','r'}}; //En este bloque de aca procedemos a imprimir por pantalla el array ya //generado anteiormente for (int x=0; x<10; x++){ printf ("\n"); for (int y=0; y<12; y++){ printf(" %c", sopa[x][y]); }}

//Desplegamos un mensaje mencionando las palabras a generar printf("\nEn la siguiente sopa de letras encontrar las siguintes palabras"); printf("\ndoctor\nobligacion\nelectricista\nradio\ncancion"); getch(); } Observación.- El deber indicaba una sopa de letras de 10X10, pero en mi programa se genera una sopa de letras de 10X12. #include <conio.h> #include <stdio.h> #include <stdlib.h> int main(){ int arreglo_sopa_letras[3][3]={{1,2,3},{4,5,6},{7,8,9}}; int suma=0; for (int x=0; x<3; x++){ printf ("\n"); for (int y=0; y<3; y++){ printf ("%d",arreglo_sopa_letras[x][y]); } suma=arreglo_sopa_letras[x][x]+suma; } printf("\nla suma de la diagonal es igual %d",suma); getch(); return 0; }

El programa en ejecución

Figura 1.- El programa en ejecución

Comentario.- En esta imagen se puede ver la sopa de letras ya impresa por pantalla, y un mensaje el cual nos indica las palabras que debemos buscar.



TAREA #2

Realizar una consulta sobre los pasos de parámetros en c++ empleando array como argumentos. Emplee la estructura de presentación de trabajos indicada en clase y que se detalla en la tarea 1, recuerde adjuntar la bibliografía empleada.

#include<conio.h>


#include<stdio.h>

struct fecha

{

int d;

int m;

int a;

};

struct datos_p

{

char nombre [25];

char autor [25];

char editorial [25];

fecha fecha_edicion;

};

struct biblioteca

{

datos_p datos_libro;

float costo;

} BIBLIO;

void main()

{

clrscr ();

cout<<"ingrese nombre del libro";

gets (BIBLIO.datos_libro.nombre);

cout<<"ingrese autor";

gets (BIBLIO.datos_libro.autor);

cout<<"ingrese editorial";

gets (BIBLIO.datos_libro.editorial);

cout<<"ingrese fecha de edicion";

cout<<"****DIA***";

cin>>BIBLIO.datos_libro.fecha_edicion.d;

cout<<"****MES***";

cin>>BIBLIO.datos_libro.fecha_edicion.m;

cout<<"****A¤O***";

cin>>BIBLIO.datos_libro.fecha_edicion.a;

cout<<"ingrese el costo del libro";

cin>>BIBLIO.costo;

cout<<BIBLIO.datos_libro.nombre <<endl;

cout<<BIBLIO.datos_libro.autor <<endl;

cout<<BIBLIO.datos_libro.editorial <<endl;

cout<<BIBLIO.datos_libro.fecha_edicion.d <<endl;

cout<<BIBLIO.datos_libro.fecha_edicion.m <<endl;

cout<<BIBLIO.datos_libro.fecha_edicion.a <<endl;

cout<<BIBLIO.costo;

getch();

}



TAREA # 3

Investigar sobre Estructuras Anidadas Internas y Externas

Estructuras Anidadas

Una estructura puede estar dentro de otra estructura a esto se le conoce como anidamiento o estructuras anidadas. Ya que se trabajan con datos en estructuras si definimos un tipo de dato en una estructura y necesitamos definir ese dato dentro de otra estructura solamente se llama el dato de la estructura anterior.

Definamos una estructura en nuestro programa:

struct empleado /* creamos una estructura llamado empleado*/ { char nombre_empleado[25]; char direccion[25]; char ciudad[20]; char provincia[20]; long int codigo_postal; double salario; }; /* las estructuras necesitan punto y coma (;) al final */

Y luego necesitamos una nueva estructura en nuestro programa:

struct cliente /* creamos una estructura llamada cliente */ { char nombre_cliente[25]; char direccion[25]; char ciudad[20]; char provincia[20]; long int codigo_postal; double saldo; }; /* las estructuras necesitan punto y coma (;) al final */

Podemos ver que tenemos datos muy similares en nuestras estructuras, así que podemos crear una sola estructura llamada infopersona con estos datos idénticos:

struct infopersona /* creamos la estructura que contiene datos parecidos */ { char direccion[25]; char ciudad[20]; char provincia[20]; long int codigo_postal; }; /* las estructuras necesitan punto y coma (;) al final */

Y crear las nuevas estructuras anteriores, anidando la estructura necesaria:

struct empleado /* se crea nuevamente la estructura */ { char nombre_empleado[25]; /* creamos direcc_empleado con "struct" del tipo "estructura infopersona" */ struct infopersona direcc_empleado; double salario; }; /* las estructuras necesitan punto y coma (;) al final */ <source lang=c> struct cliente /* se crea nuevamente la estructura */ { char nombre_cliente[25]; /* creamos direcc_cliente con "struct" del tipo "estructura infopersona" */ struct infopersona direcc_cliente; double saldo; }; /* las estructuras necesitan punto y coma (;) al final */

Y acá el ejemplo completo con estructuras anidadas:

#include <stdio.h> #include <string.h>

/* creamos nuestra estructura con datos similares */

struct infopersona { char direccion[25]; char ciudad[20]; char provincia[20];

long int codigo_postal; }; /* las estructuras necesitan punto y coma (;) al final */ /* creamos nuestra estructura empleado */ struct empleado { char nombre_empleado[25]; /* agregamos la estructura infopersona * con nombre direcc_empleado */ struct infopersona direcc_empleado; double salario; }; /* las estructuras necesitan punto y coma (;) al final */ /* creamos nuestra estructura cliente */ struct cliente { char nombre_cliente[25]; /* agregamos la estructura infopersona * con nombre direcc_cliente */ struct infopersona direcc_cliente; double saldo; }; /* las estructuras necesitan punto y coma (;) al final */ int main(void) { /* creamos un nuevo cliente */ struct cliente MiCliente; /*inicializamos un par de datos de Micliente */ strcpy(MiCliente.nombre_cliente,"Jose Antonio"); strcpy(MiCliente.direcc_cliente.direccion, "Altos del Cielo"); /* notese que se agrega direcc_cliente haciendo referencia * a la estructura infopersona por el dato direccion */ /* imprimimos los datos */ printf("\n Cliente: "); printf("\n Nombre: %s", MiCliente.nombre_cliente); /* nótese la forma de hacer referencia al dato */ printf("\n Direccion: %s", MiCliente.direcc_cliente.direccion); /* creamos un nuevo empleado */

struct empleado MiEmpleado; /*inicializamos un par de datos de MiEmplado */ strcpy(MiEmpleado.nombre_empleado,"Miguel Angel"); strcpy(MiEmpleado.direcc_empleado.ciudad,"Madrid"); /* para hacer referencia a ciudad de la estructura infopersona * utilizamos direcc_empleado que es una estructura anidada */ /* imprimimos los datos */ printf("\n"); printf("\n Empleado: "); printf("\n Nombre: %s", MiEmpleado.nombre_empleado); /* notese la forma de hacer referencia al dato */ printf("\n Ciudad: %s", MiEmpleado.direcc_empleado.ciudad); return 0; }

ESTRUCTURAS ANIDADAS INTERNAS.

También está permitido anidar estructuras, con lo cual se pueden conseguir superestructuras muy elaboradas.

Ejemplo:

struct stDireccion { char Calle[64]; int Portal; int Piso; char Puerta[3]; char CodigoPostal[6]; char Poblacion[32]; }; struct stPersona { struct stNombre { char Nombre[32]; char Apellidos[64]; } NombreCompleto; stDireccion Direccion; char Telefono[10]; };

...

En general, no es una práctica corriente definir estructuras dentro de estructuras, ya que tienen un ámbito local, y para acceder a ellas se necesita hacer referencia a la estructura más externa.

Por ejemplo para declarar un objeto del tipo stNombre hay que utilizar el operador de acceso (::):

stPersona::stNombre NombreAuxiliar;

Sin embargo para declarar un objeto de tipo stDireccion basta con declararla:

stDireccion DireccionAuxiliar;

ESTRUCTURAS ANIDADAS EXTERNAS. Es posible crear estructuras que tengan como miembros otras estructuras. Esto tiene di-

versas 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 producto).



TAREA # 5 ACCESO A ESTRUCTURA DE DATOS.

Al siguiente programa agregar:

1. Función suma para agregar días a la fecha y poder obtener la nueva fecha.

2. Calcular la edad de una persona comparara con la fecha del sistema.

#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 Suma(int d); 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(); }



TAREAS# 6

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 "iomanip.h" #include "conio.h" #include "stdio.h" int dia,mes,anio; void Pidedatos(); void Prt(); void Suma(int d); void Suma(int dias){

int nd=0,nm=0,a; dia +=dias;//se suman los nuevos dias //hacer que el algoritmo de sumar dias, considerando los meses de 30 dias while(dia>30) { dia-=30; nd++; } mes+=nd; while(mes>12) { mes-=12; nm++; } anio+=nm; // return temp; } void Prt() { cout<<setfill('0')<<setw(2)<<dia<<'/'<<setw(2)<<mes<<'/'<<setw(4)<<anio; } void Pidedatos() {char ch; cout<<"Escriba fecha de la forma dd/mm/aa\n"; cin>>dia>>ch>>mes>>ch>>anio; } void main() {clrscr(); int num; Pidedatos();//pedir fecha 2 cout<< "\nfecha 2:\n "; Prt(); cout<< "\nNumeros dias a sumar: "; cin>> num; cout<< " mas "<< num << " dias = "; Suma(num); Prt(); cout<<" \nHe terminado.."; getch(); }



TAREA # 7 CODIFICACION DEL PROGRAMA.

En el cual se creó una función que permita ordenar la lista de nombres ingresados por el teclado de forma alfabética.

CAPTURA DE PANTALLA

LA FUNCIÓN ORDENAR.

Para realizar la ejecución de la función ordenar se puede realizar mediante estos pasos:

1°- el primer nodo se inserta.

Lista vacía.

2°- listas con elementos

Si el contenido de la cabecera es mayor al que está por insertar, debemos hacer una

inserción al inicio.

While (strcmp (aunx,nom,c)<0)

Usan un aux para avanzar mientras que el nodo siguiente exista y el contenido de ese nodo

siguiente.

*nodo->sig=aux->sig;

*aux->sig=nodo;

Peñafiel Genesis

NULL

CABECERA

Peñafiel Genesis

Viteri Miguel NULL

Cedeño Alexander

CABECERA

>>codificación:

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

{pnodo aux=*l;

pnodo nodo=(pnodo)malloc(sizeof(tipoAlumno));


if (!*l)

{ nodo->sig=*l; //1a

*l=nodo;

}

else

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

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

}

}

}



TAREA # 8

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 todas las listas. Incorpore en el menú las dos opciones y ejecute el programa.

CREÓ UNA FUNCIÓN QUE PERMITA BORRAR NODO Y ELIMINE UNA LISTA.

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

getch();

}

}

}

}

v oid eliminar_all(lista *l)

{pnodo aux;

while(*l)

{

aux=*l;

*l=aux->sig;

free(aux);

}

}

CODIFICACION DEL PROGRAMA

EJECUCIÓN DEL PROGRAMA



TRABAJO INDIVIDUAL EN CLASE.

/* Crear un programa que utilice una estructura para almacenar rutas de

buses identificando placa, disco, chofer, hora_salida, parada. En donde

paradas debe ser un array estructurado que indique la hora en que realizo

una parada.

Empleando puntero a estructuras, que accedan a un array de estructura, para permitir el

ingreso de 10 recorrido de buses, con sus respectivas paradas. No utilice la variable de

array de estructuras de ámbito local.

Elaborado por: GENESIS DINA PEÑAFIEL PIN [2"B"] 05/06/2013

*/


#include<conio.h>

#include<stdio.h>

struct rutas_buses{

char placa[10];

char disco[10];

char chofer[30];

char parada[20];

int rp;

};

void buss_salida(struct ruta_buses *g);

void recorrido(struct ruta_buses *g);

void imprimir(struct ruta_buses *g);

void buss_salida (struct rutas_buses *g)

{

cout<<"\nINGRESE LA PLACA DEL BUSS\n";

cin>>g ->placa;

cout<<"\nINGRESAR EL NUMERO DE DISCO DEL BUSS\n";

cin>>g ->disco;

cout<<"\nINGRESE EL NOMBRE DEL CHOFER\n";

cin>>g->chofer;

cout<<"\nINGRESE LA PARADA DEL BUSS\n" ;

cin>>g->parada;

cout<<"\n INGRESE EL NUMERO DE PARADAS QUE REALIZA EL BUSS";

cin<<g->rp;

}

void recorrido(struct rutas_buses *g)

{

int i;

cout<<"INGRESAR PARADA DEL BUSS\n";

for(i=0;i<g->np;i++)

{

cout<<"\n INGRESE LA " <<i+1<<""LUGAR Y HORA:" ;

cin>>g->parada[i];

}

}

void imprimir(struct rutas_buses *g)

{

cout<<"\n\t DATOS INGRESADOS\n";

cout<<"\n placa" <<"\t"<<"disco"<<"\t"<<"chofer" <<"\t"<<"parada\n" ;

cout<<g->placa<<"\t"<<g->disco<<"\t"<<g->chofer<<"\t"<<g->parada<<"\t"<<g->rp;

}

void main()

clrscr();

struct ruta_buses *g;

p=r;

buss_salida(g);

recorrido(g);

imprimir(g);

getch ();

}

Documents

Portafolio2 aestructuragene