You are on page 1of 140

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA EN SISTEMAS INFORMTIVOS

POTAFOLIO DE ESTRUCTURA DE DATO SEGUNDO SEMESTRE DE CARRERA

2DOC
AUTOR: PAREDES BRAVO JONATHAN ANDRS

DOCENTE: ING. CHRISTIAN TORRES.

PORTOVIEJO, NOVIEMBRE DEL 20012

PERODO ACADMICO: SEPTIEMBRE 2012-FEBRERO 2013

FACULTAD DE CIENCIAS INFORMATICAS

Misin:
Ser una unidad con alto prestigio acadmico, con eficiencia, transparencia y calidad en la educacin, organizada en sus actividades, protagonistas del progreso regional y nacional.

Visin:
Formar profesionales eficientes e innovadores en el campo de las ciencias informticas, que con honestidad, equidad y solidaridad, den respuestas a las necesidades de la sociedad elevando su nivel de vida.

UNIVERSIDAD TCNICA DE MANABI

Misin:
Formar acadmicos, cientficos y profesionales responsables, humanistas, ticos y solidarios, comprometidos con los objetivos del desarrollo nacional, que contribuyan a la solucin de los problemas del pas como universidad de docencia con investigacin, capaces de generar y aplicar nuevos conocimientos, fomentando la promocin y difusin de los saberes y las culturas, previstos en la Constitucin de la Repblica del Ecuador.

Visin:
Ser institucin universitaria, lder y referente de la educacin superior en el Ecuador, promoviendo la creacin, desarrollo, transmisin y difusin de la ciencia, la tcnica y la cultura, con reconocimiento social y proyeccin regional y mundial.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

NDICE DE CONTENIDOS
Syllabus Prontuario del curso

Carta de presentacin

Autorretrato

Diario meta cognitivo

Artculos de revistas profesionales

Trabajo de ejecucin Tereas Materiales relacionados con la clase. Anexos Resumen de cierre

UNIVERSIDAD TCNICA DE MANAB SYLLABUS


Asignatura: Estructura de Datos. 1.- Datos Generales: Unidad Acadmica: Facultad de Ciencias Informticas. Carrera: Ingeniera en Sistemas Informticos. Ciclo Acadmico: septiembre 2012- febrero 2013. Nivel o Semestre: Segundo Nivel. rea de Competencia: Software. Tipo de Asignatura: Obligatoria de Carrera. Cdigo: OC-0201. Requisito para: OC-0301. Pre-requisitos: OC-0100. Co-requisitos: N de Crditos: 5 N de Horas: 80 Docente Responsable: Ing. Christian Ronald Torres Morn. Correo Electrnico del Docente Responsable: crtorres@utm.edu.ec 2.- Descripcin de la Asignatura La materia introduce al estudiante a los conceptos y aplicacin en la administracin de memoria, aplicando programacin estructurada y orientada a objetos, permite conocer la estructura bsica operacional de la memoria RAM y de los grandes diseos de software, aplicando C++ el estudiante desarrollar proyectos cientficos tanto con interfaces en modo grfico y en modo texto, tomando como referencia aplicaciones en el campo general de otras carreras. 3.- Objetivo General de la Asignatura Capacitar al estudiante con los conocimientos significativos en administracin de memoria dinmica y herramientas tiles en los diseos, construcciones y usos principales de algoritmos en la estructuracin de datos lineales y no lineales.

4.- Competencias Especficas del Perfil del Graduado Objetivos Educacionales de la Facultad de Ciencias Informticas

Carrera de Ingeniera de Sistemas Informticos


1. Aplica las ciencias bsicas y las matemticas en la solucin de problemas del entorno. 2. Toma decisiones que ayudan a desarrollar organizaciones proactivas que contribuyen al buen vivir. 3. Construye soluciones informticas de calidad que mejoren la eficiencia y eficacia de una organizacin haciendo uso correcto de la tecnologa. 4. Demuestra compromiso de aprendizaje continuo y trabajo en equipo multidisciplinario con tica profesional 5. Capacidad para realizar estudios de posgrado con exigencia internacional en reas afines. 6. Es emprendedor, innovador y utiliza los ltimos avances tecnolgicos en el desempeo de su profesin.

3 x

6 x

5.- Resultados del Aprendizaje


Resultados del Aprendizaje Nivel de
aprendizaje

METODOLOGA DE EVALUACIN DE LOS RESULTADOS DE APRENDIZAJE Mtodo de Evaluacin


Un Ejercicio Prctico problema del medio.

Criterios

Niveles del Resultado de Aprendizaje


Describir la definicin de la estructura de datos, los tipos de datos imples, bsicos y compuestos en un ensayo tcnico con: descripcin general del tema clara; ideas que tienen relacin, claridad y objetividad con el tema; y una conclusin clara con aporte personal. Describir la definicin de la estructura de datos, los tipos de datos simples, bsicos y compuestos en un ensayo tcnico con: descripcin general del tema confusa; pocas ideas que tienen relacin, claridad y objetividad con el tema; y una conclusin confusa con aporte personal. Describir la definicin de la estructura de datos, los tipos de datos simples, bsicos y compuestos en un ensayo tcnico con: descripcin general del tema confusa; poca o ninguna idea que tienen relacin, claridad y objetividad con el tema; y una conclusin confusa sin aporte personal.

Ponderacin Alto (100 puntos)

Identificar los Tipos estructurados de datos estticos y dinmicos empleados en la creacin de aplicaciones, considerando los lenguajes de programacin

Conocimient o.

Descripcin de la definicin de la Estructura de datos. Descripcin de las tres capas de la estructura de datos. Descripcin de la introduccin de forma clara. Descripcin del contenido con ideas que tengan relacin, claridad y objetividad con el tema. Descripcin de la conclusin en forma clara y con aporte personal. Identificacin de 4 tipos de datos estructurados. Implementacin de cdigo de extensin .cpp Diferenciacin del uso de tipos de datos estructurados estticos frente a los tipos de datos estructurados dinmicos.

Medio (70 puntos)

Bsico (50 punto)

Elaborar aplicaciones dinmicas de estructura lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales.

Aplicacin

Cuadro comparativo . Trabajo en equipo.

Comparacin de 3 semejanzas entre los tipos de datos que permiten almacenar ms de un dato: Array de una dimensin, array de 2 dimensiones, array de mltiples dimensiones. Relaciones de las comparaciones con ideas claras.

Comparar con la utilizacin de un cuadro comparativo 3 semejanzas y 3 diferencias entre los tipos de datos que permiten almacenar ms de un dato; reflejando las relaciones de las comparaciones con ideas claras. Comparar con la utilizacin de un cuadro comparativo 3 semejanzas y 3 diferencias entre los tipos de datos que permiten almacenar ms de un dato; reflejando las relaciones de las comparaciones con ideas pocos claras. Comparar con la utilizacin de un cuadro comparativo 2 semejanzas y 2 diferencias entre los tipos de datos que permiten almacenar ms de un dato; reflejando las relaciones de las comparaciones con ideas confusas.

Alto (100 puntos)

Medio (70 puntos)

Bsico (50 punto)

Implementar Aplicacin aplicaciones dinmicas de estructura Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales

Trabajo en Equipo dentro de laboratorio.

Aplicacin dinmica empleando estructuras lineales para manejo de informacin Descripcin de las estructuras enlazadas doblemente. Descripcin general. Descripcin de Abiertas y Cerradas

Implementar aplicaciones dinmicas de estructura Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales. Implementar aplicaciones dinmicas de estructura Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones comerciales. Implementar aplicaciones dinmicas de estructura No Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento

Alto (100 puntos)

Medio (70 puntos)

Bsico (50 punto)

Implementar aplicaciones dinmicas de estructura no Lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales

Aplicacin

Informe. Trabajo en equipo.

Aplicacin dinmica empleando estructuras no lineales para manejo de informacin

con estructuras dinmicas no lineales bien detallado. con estructuras dinmicas no lineales con poca claridad. n programa con estructuras dinmicas no lineales de forma confusa.

Alto (100 puntos)

Medio (70 puntos)

Bsico (50 punto)

Organizar la Aplicacin informacin en . algoritmos y estructuras AVL y su relacin con los gestores de Base de Datos

Ejercicios de laboratorio emplear arboles Binarios y su forma de balanceo.

del arboles binarios Balanceados. del AVL

que emplee estructuras arborescentes de forma AVL uso de forma clara. rama que emplee estructuras arborescentes de forma AVL de forma poco clara. que emplee estructuras arborescente

Alto (100 puntos)

Medio (70 puntos)

Bsico (50 punto)

1.1 Resultados de aprendizaje de la carrera especficos a los que apunta la materia (ABET).
Resultados de aprendizaje de la carrera de Ingeniera de Sistemas Informticos a. Capacidad de realizar anlisis, sntesis y aplicacin de las matemticas y ciencias bsicas en la solucin de problemas de ingeniera en sistemas informticos. b. Capacidad de planificar, disear, conducir e interpretar resultados de experimentos orientados a la informtica. c. La capacidad de disear sistemas, procesos, modelos y componentes informticos que cumplan los estndares nacionales o internacionales, tomando en cuenta las limitaciones econmicas, ambientales, sociales, polticas, de salud y seguridad del entorno, y cumpliendo satisfactoriamente con las especificaciones y restricciones existentes o indicadas por los interesados o por los criterios de sostenibilidad. d. Capacidad para funcionar como parte de un equipo de profesionales de distintas reas del conocimiento, demostrando una efectiva cooperacin, comunicacin, con habilidades para resolver conflictos y contribuyendo proactivamente en la propuesta de lneas estratgicas desde el punto de vista informtico, para la solucin de problemas. e. Capacidad para identificar, formular, evaluar y resolver tcnicamente problemas de ingeniera planteados de acuerdo a las necesidades del medio. f. Capacidad para comprender, reconocer y aplicar valores y cdigos de tica profesional, que le permitan desenvolverse sin perjudicar a sus clientes y contribuyendo al desarrollo de la sociedad. 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 tecnologas de la informacin. h. Habilidad y capacidad para comprender el impacto de las soluciones informticas a la realidad local, nacional e internacional en un contexto econmico global, ambiental y social. 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 tcnicas, habilidades y herramientas en el desarrollo de software y hardware para implementar soluciones a problemas de su profesin. Contribucin de la materia a los resultados de aprendizaje de la carrera:

A: Alta M: Medio B: Baja A B C M D E M F B G B H I B J B k B

6.- Programacin
1. Resultado del Aprendizaje: Identificar los tipos estructurados de datos estticos y dinmicos empleados
en la creacin de aplicaciones, considerando los lenguajes de programacin Fechas No. de Horas TOTAL 23 18/04/2012 1
Generalidades y definiciones de Estructura de Datos

Temas

Estrategias metodolgicas

Recursos

Bibliografa

18/04/2012 21/04/2012 21/04/2012

datos.

Experiencia: Aplicando lluvia de ideas concretar conocimientos relativo a la memoria y sus diferentes importancias en el funcionamiento del computador Reflexin: En equipos de trabajo, analizar el funcionamiento general del computador y de los programas, considerando las siguientes aplicaciones: Procesadores de texto, Hojas de clculo, Reproductores, Tareas del sistema operativo como Impresin, etc. Conceptualizacin:

Computador

datos.

Estructura de Programacin en Proyector C. PrisHard. www.prishard.co Dispositivos de m Almacenamien Folleto to rpido. elaborado por el docente, Pizarra de tiza pginas inciales Liquida Marcadores

25/04/2012 28/04/2012 28/04/2012 02/05/2012 05/05/2012

de Datos (Estticas) ras de Datos

2 3

Esttica y Dinmica

Bibliografa recomendada y referencias en el Internet

05/05/2012 09/05/2012 09/05/2012 12/05/2012 12/05/2012 16/05/2012 16/05/2012 19/05/2012

punteros

memoria

2 1 2

memoria

conceptuales, cuadros de funcionamiento y estructurales de la memoria. Aplicacin: solucin de ejercicios demostrativos y de planteamiento de problemas.

de punteros

2. Resultado del Aprendizaje: Elaborar aplicaciones dinmicas de estructura lineal, almacenamiento y


recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales.

TOTAL 30
19/05/2012

Estructuras simples y Compuestas

Experiencia: concretar conocimientos relativo a problemas informticos planteados

Computador Proyector

18/05/2012 23/05/2012 23/05/2012 26/05/2012 26/05/2012 30/05/2012 02/06/2012 02/06/2012 06/06/2012 09/06/2012

1 1 2 2 1 5

Estructura de Datos, Referencia Dispositivos de practica con Listas Abiertas Almacenamien objetos Definicin de listas Reflexin: to rpido. orientados abiertas Declaracin e En grupos de trabajo, a objetos, implementacin de una analizar el funcionamiento Pizarra de tiza Romn lista liquida Martnez Elda Operaciones con Listas general de los diferentes algoritmos considerando Quiroga, Pg. Insercin de un nodo las diferentes Marcadores 56,57,58,81 aplicaciones. Bsqueda de un nodo Bibliografa Recorridos de una lista Conceptualizacin: recomendada Folleto Eliminacin de un nodo y referencias elaborado Listas y Archivos conclusiones en el Internet por el docente Variaciones de listas conceptuales, cuadros de Pilas y Colas funcionamiento y alternativas estructurales de solucin. Listas circulares o cerradas Declaracin e implementacin de una lista circular Operaciones con Listas Insercin de un nodo Bsqueda de un nodo Recorridos de una lista Eliminacin de un nodo Listas doblemente enlazadas abiertas y cerradas Declaracin e Aplicacin: Resolucin de ejercicios demostrativos y de planteamiento de problemas.

09/06/2012

13/06/2012

16/06/2012 16/06/2012 16/06/2012 20/06/2012 20/06/2012 23/06/2012

1 1 2

implementacin de una lista doblemente enlazada 23/06/2012 04/07/2012 04/06/2012 07/07/2012 2 1 1 1 Operaciones con Listas Insercin de un nodo Bsqueda de un nodo Recorridos de una lista Eliminacin de un nodo

3. Resultado del Aprendizaje: Elaborar aplicaciones dinmicas de estructura no lineal, almacenamiento y recuperacin de los mismos en unidades de almacenamiento, aplicarn soluciones de administracin de memoria mediante el desarrollo de aplicaciones cientficas y comerciales.

TOTAL 13
07/07/2012 2

Estructuras arborescentes Definicin, implementacin Tipos de recorridos: PreOrden InOrden PostOrden

Experiencia: Computador definir la importancia de aplicar algoritmos generales de rboles binarios y su importancia en la agilidad y seguridad de los datos en el campo empresarial en general. Reflexin: analizar el funcionamiento general de los principales sistemas informticos, considerando el avance tecnolgico del software en la base de datos Conceptualizacin: propuestas algortmicas, prcticas y de alternativas de resolucin. Proyector Pizarra de tiza Liquida Marcadores Texto de apoyo y/o diapositivas Estructura de Datos, Referencia practica con objetos orientados a objetos, Romn Martnez Elda Quiroga, Pg. 115-131 Folleto proporcionado por el profesor

11/07/2012 14/07/2012

14/07/2012 13/07/2012 18/07/2012

1 1 1

Operaciones con rboles Binarios de Bsqueda Bsqueda de elementos. Insercin de elementos. Borrado de elementos. * Nodo hoja. *Nodo rama.

18/07/2012 21/07/2012

Movimiento a travs del rbol. Comprobacin de rboles vacos. Comprobacin del nodo hoja.

21/07/2012

21/07/2012

Clculo de: *Nmero de nodos. *Altura del rbol. *Altura de un nodo.

Aplicacin: demostrativos y de planteamiento de problemas.

25/07/2012 1 rboles degenerados. 4. Resultado del Aprendizaje: Organizar la informacin en algoritmos y estructuras AVL y su relacin con los gestores de Base de Datos TOTAL 14 25/07/2012 28/07/2012 28/07/2012 28/07/2012 01/08/2012 01/08/2012 2 Tipos de rboles especiales rboles equilibrados. Definicin Operaciones en AVL. Factor de equilibrio. Rotacin simple de nodos. Rotacin simple a la derecha. Rotacin simple a la izquierda. Rotacin doble de nodos a la derecha. Rotacin doble de nodos s la izquierda. Requilibrados de rboles AVL. Reequilibrados en rboles AVL por insercin de un nodo.

Experiencia: planteamiento de problemas, identificar dificultades y generar la necesidad de encontrar soluciones algortmicas. Reflexin: analizar el funcionamiento de los diferentes algoritmos propuestos. Conceptualizacin: laboracin de propuestas de funcionamiento y alternativas estructurales de solucin. Aplicacin: demostrativos y de planteamiento de problemas.

Computador Proyector Pizarra de tiza liquida Marcadores Texto de apoyo y/o diapositivas

1 1 1 1

Estructura de Datos, Referencia practica con objetos orientados a objetos, Romn Martnez Elda Quiroga, Pg. 137-161 Folleto proporcionado por el profesor

04/08/2012

1 1

04/08/2012

04/08/2012

08/08/2012

08/08/2012 11/08/2012

11/08/2012

Reequilibrados en rboles AVL por borrado de un nodo.

7.- Compromisos Disciplinarios y ticos Asistencia y puntualidad


La asistencia es obligatoria a todas las actividades programadas en esta asignatura El estudiante ingresar a clases a la hora establecida, y solo por una ocasin se aceptar el retraso de 10 minutos. El docente asistir igualmente con toda puntualidad a las actividades establecidas y los estudiantes esperaran 10 minutos despus de la hora de inicio, en caso de que el docente no se hubiera comunicado con el representante del curso en este lapso los estudiantes se retiraran y el docente tiene la obligacin de recuperar estas horas. El estudiante deber justificar al docente sus inasistencias o atraso, independiente de la justificacin reglamentaria. El estudiante por ningn concepto puede utilizar los celulares en el aula, igual comportamiento tendr el docente. En caso de emergencia el estudiante solicitar al docente el respectivo permiso para el uso del celular. El intento de copia de cualquier estudiante ser sancionado con la calificacin de cero y no habr oportunidad de recuperacin independiente de las sanciones establecidas por la universidad. Los trabajos se entregaran en la fecha establecidas y no se recibir en otro oportunidad. No se aceptarn una segunda oportunidad para la entrega de trabajos. El estudiante ingresar al aula sin gorra y no consumir alimentos dentro del aula. El trabajo escrito ser realizado con las propias palabras e ideas del estudiante. Si se descubre la copia textual de un prrafo de un texto se calificar con 0.

8.- Parmetros para la Evaluacin de los Aprendizajes.

Primera Evaluacin Exmenes Lecciones Tareas Proyectos Informes de investigacin Participacin en clase TOTAL 15% 5% 2.5% 10% 15% 2.5% 50% 15% 5% 2.5% 10% 15% 2.5% 50%

Segunda Evaluacin

N.. Evaluacin

30% 10% 5% 20% 30% 5% 100%

9.- Bibliografa Bsica:


Autor: Romn Martnez Libro: Estructura de Datos, Referencia practica con objetos orientados a objetos Edicin: Sptima. Editorial: Elda Quiroga, 2008.

Complementaria:
Autor: Docente Estructura de Datos Pgina 8 Libro: Manuales e instructivos preparado para los estudiantes. Edicin: Primera. Editorial: Libre.

10.- Revisin y Aprobacin

DOCENTE RESPONSABLE

DIRECTOR (A) DE CARRERA

PRESIDENTE (A) COMISIN ACADMICA Firma:

Firma: Firma: Ing. Christian Ronald Torres Morn

Fecha:

Fecha:

Fecha:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

PRONTUARIO

I.

INFORMACIN GENERAL

Programa Codificacin del curso: Ttulo del curso: estructura de dato Nmero crditos: cinco (5) crditos Total de Horas del Curso: 80 horas

II.

DESCRIPCIN DEL CURSO

La materia introduce al estudiante a los conceptos y aplicacin en la administracin de memoria, aplicando programacin estructurada y orientada a objetos, permite conocer la estructura bsica operacional de la memoria RAM y de los grandes diseos de software, aplicando C++ el estudiante desarrollar proyectos cientficos tanto con interfaces en modo grfico y en modo texto, tomando como Referencia aplicaciones en el campo general de otras carreras.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CARTA DE PRESENTACIN

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 parcial pude conocer sobre. Las estructura anidadas, funciones, punteros, listas simples, pilas, y colas. Las tcnicas presentadas por el docente me ayudaron a mejorar como futuro profesional de la Informtica.

Las reas ms dificultosas del curso fueron:

Lo ms dificultoso fue sobre las listas simples, y las estructura anidadas

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

AUTORRETRATO

Mi nombre es Paredes Bravo Jonathan Andrs. Soy estudiante de la asignatura de ESTRUCTURA DE DATO, actualmente curso el segundo semestre en la Facultad de Ciencias Informticas de la Universidad Tcnica de Manab. Soy una persona responsable, organizada y me gusta trabajar en equipo.

Mis metas son convertirme en un profesional de la Ingeniera en Sistemas Informticos.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#1: FECHA:26 de septiembre del 2012 TEMA: Aplicacin de la programacin bsica

INTRODUCCION Una de las aplicaciones ms interesantes y potentes de la memoria dinmica y de los punteros son, sin duda, las estructuras dinmicas de datos. Las estructuras bsicas disponibles en C y C++ (structs y arrays) tienen una importante limitacin: no pueden cambiar de tamao durante la ejecucin. Los arrays estn compuestos por un determinado nmero de elementos, nmero que se decide en la fase de diseo, antes de que el programa ejecutable sea creado.

EJERCICIO DE ESTRUCTURA DE DATO #include<conio.h> #include<stdio.h> void main() { clrscr(); char nom[30]; int edad; struct struct.curso3; printf("INGRESE EL NOMBRE: "); scanf("%s", curso3.nom); printf("INGRESE LA EDAD: "); scanf("%d",&curso3.edad); printf("\n EL ESTUDIANTE %s TIENE %d AOS DE EDAD",curso3.nom,curso3.edad); getch(); }

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE #2: FECHA: 27 de septiembre del 2012 TEMA: creacin de una estructura bsica

Sintaxis etiqueta, {} , ; Creacin de la variable (A. global, A. local) Acceso a los campos (punto) Struct { Char nom [40]; Char ced [10]; Int edad; Char direc [50]; Char tel [10]; } A; ESTRUCTURA ANIDADAS: E.D----> contiene campos de tipo: Primitivo (int, float, char.), Estructurado esttico (array), estructura de datos. E.A----> puede darse de dos formas: 1. Internas 2. externas

EJERCICIO DE ESTRUCTURAS INTERNAS.


#include<conio.h> #include<stdio.h> struct empresa { struct informacin { char nombre[50]; char direccin[50]; char ruc[13]; char telfono[18]; }empre; struct proveedor_ { char ruc [13]; char nombre[40]; char direccin[50]; char telfono[18]; char ciudad[20]; } proveedor; struct cliente_ { char nombre[50]; char cedula[10]; char direccin[30]; }cliente[200]; struct producto_ { char nombre[50]; int cant; float pvp; } producto; }; void main() { struct empresa E; scanf("%s", E.cliente[0].nombre); }

EJERCICIO DE ESTRUCTURAS EXTERNAS.


#include<conio.h> #include<stdio.h> struct datos { char nombre[50]; char direccin[60]; char ruc[15]; }; struct information { struct dato dato; char telfono[18]; }; struct proveedor_ { struct datos dato; char telfono[18]; char ciudad[20]; }; struct producto_ { char nombre[50]; int cant; float pvp; } producto; struct empresa { struct informativo empresa; struct proveedor_ proveedor; struct datos cliente[200]; struct producto_ producto; }; void main() { struct empresa E; struct proveedor_ proveedor[200]; scanf("%s", E.proveedor.dato.nombre); }

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE #3: FECHA: 03 de octubre del 2012 TEMA: inicializacin de una variable estructurada

INICIALIZACIN DE UNA VARIABLE ESTRUCTURADA:


Las variables de tipo estructura de datos, igual que cualquier otra variable, pueden inicializarse a un valor determinado en el momento de la declaracin. En el ejemplo de la parte inferior se ve todo esto ms claramente.

EJERCICIO DE INICIALIZACIN DE UNA VARIABLE ESTRUCTURADA

#include<conio.h> #include<stdio.h> struct notas_ { int nclases; int notas; char tema[50]; }; struct datos_ { char nombre[50]; char direccion[100]; int anio; struct notas_ nota; };

void main () { struct datos_ A={"segundo","portoviejo",1993,{3,7,"estructura "}}; printf("\n NOMBRE: %s",A.nombre); printf("\n DIRECCION: %s",A.direccion); printf("\n AO DE NACIMIENTO: %i",A.anio); printf("\n N DE CLASES: %i",A.nota.nclases); printf("\n CALIFICACION: %i",A.nota.nota); printf("\n TEMA ABORDADO: %s",A.nota.tema); getch(); }

CAPTURA DE PANTALLA

FIGURA: #1.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#4. FECHA:04 de octubre del 2012 TEMA: estructuras

EJERCICIO
#include <stdio.h> #include <conio.h> struct persona{ char nombre[40]; int edad; }; void calcular_edad(char n[],int edad,int anioa, int aniof) { int resta; resta=aniof-anioa; printf("\n%s tendra en el %d %d anios",n,aniof,edad+resta); } void calculare2(struct persona p,int anioa, int aniof) { int resta; resta=aniof-anioa; printf("\n%s tendra en el %d %d anios",p.nombre,aniof,p.edad+resta); } void main() { struct persona e={"Juan Carlos",20}; calcular_edad(e.nombre,e.edad,2012,2025); calculare2(e,2012,2020); getch(); }

CAPTURA DE PANTALLA FIGURA2:

EJERCICIO
#include <conio.h> #include <stdio.h> struct datos{ char nombre[20]; char direccion[50]; char ruc[15]; }; struct informativo{ struct datos dato; char telefono[15]; }; struct proveedor_{ struct datos dato; char telefono[15]; char ciudad[15]; }; struct producto_{

char nombre[15]; int cont; float pvp; }; struct empresa{ struct informativo empre; //struct datos cliente[200]; //struct producto_ producto; int nproveedor; struct proveedor_ proveedor[200]; }; void main() { struct empresa e={{{"Juan S.A.","UTM","136111"},"2568478"}}; int op,i; do{ clrscr(); printf("\n1.- ver datos de la empresa"); printf("\n2.- ingreso de proveedor para la empresa"); printf("\n3.- ver proveedores de la empresa"); printf("\n4.- productos de la empresa"); printf("\n5.- ver productos de la empresa"); printf("\n6.- salir"); scanf("%d",&op); /*if(op==1) { clrscr(); printf("Registro de los datos de la empresa"); printf("\nRUC");scanf("%s",e.empre.dato.ruc); printf("\nNombre");scanf("%s",e.empre.dato.nombre); printf("\nDireccion");scanf("%s",e.empre.dato.direccion); printf("\nTelefono");scanf("%s",e.empre.telefono); e.nproveedor=0; }*/ if(op==1) { clrscr();

printf("datos de la empresa"); printf("\nRUC: %s",e.empre.dato.ruc); printf("\nNombre: %s",e.empre.dato.nombre); printf("\nDirrecion: %s",e.empre.dato.direccion); printf("\nTelefono: %s",e.empre.telefono); getch(); } else if(op==2) { clrscr(); printf("Registro de proveedore # %d",e.nproveedor+1); printf("\nRUC\t");scanf("%s",e.proveedor[e.nproveedor].dato.ruc); printf("\nNombre\t");scanf("%s",e.proveedor[e.nproveedor].dato.nombre); printf("\nDireccion\t");scanf("%s",e.proveedor[e.nproveedor].dato.direccion); printf("\nTelefono\t");fflush(stdin);scanf("%s",e.proveedor[e.nproveedor].telefono); printf("\nCiudad\t");scanf("%s",e.proveedor[e.nproveedor].ciudad); e.nproveedor++; } else if (op==3) { clrscr(); printf("Informacion de proveedores\n"); printf("RUC\t\tNombre\t\tDireccion\ttelefono\tcuidad"); for(i=0;i<e.nproveedor;i++) printf("\n%s\t\t%s\t\t%s\t\t%s\t\t%s",e.proveedor[i].dato.ruc,e.proveedor[i].dato.nombre,e.pr oveedor[i].dato.direccion,e.proveedor[i].telefono,e.proveedor[i].ciudad); getch(); } }while(op!=6); }

CAPTURA DE PANTALLA FIGURA#3:

FIGURA#4:

FIGURA#5:

FIGURA#6:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#5: FECHA:10 de octubre del 2012 TEMA: funciones

FUNCIONES
Una funcion es un modulo de un programa separado del cuerpo principal, que realiza una tarea especifica y que puede regresar un valor a la parte principal del programa u otra funcion o procedimiento que la invoque. La forma general de una funcion es: Tipodato Nomfun (parametros) { cuerpo de instrucciones; return [dato,var,expresion]; } Donde tipodato especifica el tipo de dato que regresara la funcin. La instruccin 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 expresin algebraica(no ecuacin 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 actan como locales dentro del cuerpo de la funcion.

EJERCICIO
#include <string.h> #include <conio.h> #include <stdio.h> struct datos{ char nombre[20]; char direccion[50]; char ruc[15]; }; struct informativo{ struct datos dato; char telefono[15]; }; struct proveedor_{ struct datos dato; char telefono[15]; char ciudad[15]; }; struct producto_{ char nombre[15]; int cont; float pvp; }; struct empresa{ struct informativo empre; int nproveedores; int nclientes; int productos; struct proveedor_ proveedor[50]; struct datos cliente[100]; struct producto_ producto[100]; }; void ver_datosempresa(struct informativo e); void ingreso_pro(struct proveedor_ &p); void imprimir_proveedor(struct proveedor_ p);

void main() { struct empresa e;

int op,i; strcpy(e.empre.dato.ruc,"136111"); strcpy(e.empre.dato.nombre,"DATOS 2C"); strcpy(e.empre.dato.direccion,"UTM"); strcpy(e.empre.telefono,"052625111"); e.nproveedores=0;

do{ clrscr(); printf("\n1.- Datos de la empresa"); printf("\n2.- Registro de proveedor para la empresa"); printf("\n3.- Buscar Proveedores"); printf("\n4.- Mostrar Proveedores"); printf("\n5.- Registar Productos"); printf("\n6.- Mostrar Productos"); printf("\n7.- salir"); scanf("%d",&op); switch (op) { case 1: ver_datosempresa (e.empre); break; case 2: ingreso_pro(e.proveedor[e.nproveedores]); e.nproveedores++; break; case 3: clrscr(); printf("\n\t\tInformacion de proveedores\n"); printf("RUC\t\tNombre\t\tDireccion\ttelefono\tcuidad"); for(i=0;i<e.nproveedores;i++) imprimir_proveedor(e.proveedor[i]); getch(); break; case 4: break; case 5: break; case 6:

break; } }while (op!=7); } //implementacion de funciones void ver_datosempresa(struct informativo e) {clrscr(); printf("datos de la empresa"); printf("\nRUC: %s",e.dato.ruc); printf("\nNombre: %s",e.dato.nombre); printf("\nDirrecion: %s",e.dato.direccion); printf("\nTelefono: %s",e.telefono); getch(); }

void ingreso_pro(struct proveedor_ &p) { clrscr(); printf("\nRUC\t");scanf("%s",p.dato.ruc); printf("\nNombre\t");scanf("%s",p.dato.nombre); printf("\nDireccion\t");scanf("%s",p.dato.direccion); printf("\nTelefono\t");fflush(stdin);scanf("%s",p.telefono); printf("\nCiudad\t");scanf("%s",p.ciudad); }

void imprimir_proveedor(struct proveedor_ p) { printf("\n%s\t\t%s\t\t%s\t\t%s\t\t%s",p.dato.ruc,p.dato.nombre,p.dato.direccion,p.telefono,p.ciudad); // getch(); }

CAPTURA DE PANTALLA FIGURA#7:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#6: FECHA:11 de octubre del 2012 TEMA: funciones

EJERCICIO
#include <conio.h> #include <stdio.h> struct datos{ char nombre[20]; char direccion[50]; char ruc[15]; }; struct informativo{ struct datos dato; char telefono[15]; }; struct proveedor_{ struct datos dato; char telefono[15]; char ciudad[15]; }; struct producto_{ char nombre[15]; int cont; float pvp; }; struct empresa{ struct informativo empre; //struct datos cliente[200]; //struct producto_ producto; int nproveedor;

struct proveedor_ proveedor[200]; }; void ingreso_pro(struct proveedor_ &p); void ingreso_proveedor(char nom[],char di[],char ruc[],char tel[],char ciu[]); void imprimir_proveedor(struct proveedor_ p); void ver_proveedores(struct proveedor p[],int n );

void main() { struct empresa e={{{"Juan S.A.","UTM","136111"},"2568478"}}; int op,i; do{ clrscr(); printf("\n1.- ver datos de la empresa"); printf("\n2.- ingreso de proveedor para la empresa"); printf("\n3.- ver proveedores de la empresa"); printf("\n4.- productos de la empresa"); printf("\n5.- ver productos de la empresa"); printf("\n6.- salir"); scanf("%d",&op); if(op==1) { clrscr(); printf("datos de la empresa"); printf("\nRUC: %s",e.empre.dato.ruc); printf("\nNombre: %s",e.empre.dato.nombre); printf("\nDirrecion: %s",e.empre.dato.direccion); printf("\nTelefono: %s",e.empre.telefono); getch(); } else if(op==2) { // ingreso_proveedor(e.proveedor[e.nproveedor].dato.ruc,e.proveedor[e.nproveedor].dato.nombre,e.pr

oveedor[e.nproveedor].dato.direccion,e.proveedor[e.nproveedor].telefono,e.proveedor[e.nproveedor ].ciudad); ingreso_pro(e.proveedor[e.nproveedor]); e.nproveedor++; } else if (op==3) { clrscr(); printf("\n\t\tInformacion de proveedores\n"); printf("RUC\t\tNombre\t\tDireccion\ttelefono\tcuidad"); for(i=0;i<e.nproveedor;i++) imprimir_proveedor(e.proveedor[i]); getch(); } }while(op!=6); }

void ingreso_pro(struct proveedor_ &p) { clrscr(); printf("\nRUC\t");scanf("%s",p.dato.ruc); printf("\nNombre\t");scanf("%s",p.dato.nombre); printf("\nDireccion\t");scanf("%s",p.dato.direccion); printf("\nTelefono\t");fflush(stdin);scanf("%s",p.telefono); printf("\nCiudad\t");scanf("%s",p.ciudad); } void ingreso_proveedor(char nom[],char di[],char ruc[],char tel[],char ciu[]) { clrscr(); printf("\nRUC\t");scanf("%s",ruc); printf("\nNombre\t");scanf("%s",nom); printf("\nDireccion\t");scanf("%s",di);

printf("\nTelefono\t");fflush(stdin);scanf("%s",tel); printf("\nCiudad\t");scanf("%s",ciu); } void imprimir_proveedor(struct proveedor_ p) { printf("\n%s\t\t%s\t\t%s\t\t%s\t\t%s",p.dato.ruc,p.dato.nombre,p.dato.direccion,p.telefono,p.ciudad) ; // getch(); } void ver_proveedores(struct proveedor_ p[],int n ) { clrscr(); printf("\n\t\tInformacion de proveedores\n"); printf("RUC\t\tNombre\t\tDireccion\ttelefono\tcuidad"); for(int i=0;i<n;i++) printf("\n%s\t\t%s\t\t%s\t\t%s\t\t%s",p[i].dato.ruc,p[i].dato.nombre, p[i].dato.direccion,p[i].telefono, p[i].ciudad); getch(); }

Captura de pantalla FIGURA#8:

FIGURA#9:

FIGURA#10:

FIGURA#11:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#7: FECHA: 24 de octubre del 2012 TEMA: listas simples

Definicin
La forma ms simple de estructura dinmica es la lista abierta. En esta forma los nodos se organizan de modo que cada uno apunta al siguiente, y el ltimo no apunta a nada, es decir, el puntero del nodo siguiente vale NULL. En las listas abiertas existe un nodo especial: el primero. Normalmente diremos que nuestra lista es un puntero a ese primer nodo y llamaremos a ese nodo la cabeza de la lista. Eso es porque mediante ese nico puntero podemos acceder a toda la lista. Cuando el puntero que usamos para acceder a la lista vale NULL, diremos que la lista est vaca. El nodo tpico para construir listas tiene esta forma:

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

Normalmente se definen varios tipos que facilitan el manejo de las listas, en C, la declaracin de tipos puede tener una forma parecida a esta: typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; 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.

EJERCICIO
#include<conio.h> #include<stdio.h> void main () { clrscr(); int a,b; char c[50]="ANA CEDENO"; int d[10]={10,20,30,40,50,60,70,80,90,100}; b=7; a=10; printf("\n la informacion de las variables es:"); printf("a=%d ,b=%d ,c=%s",a,b,c); for(int f=0;f<10;f++) printf("\nd[%d]=%d",f+1,d[f]); printf("\n\n la dereccion de las variables es:"); printf("a=%p ,b=%p ,c=%p",&a,&b,&c); for(int i=0;i<10;i++) printf("\nd[%d]=%p",i+1,&d[i]);

int *p; //puntero a enteros p=&a; //enlazamiento al puntero a la la direccion de la variable"a" *p=800; // modificando el contenido existente en la direccion enlazada printf("\n\n variable 'a' modificada con un puntero \n\n"); printf("a=%d ,b=%d ,c=%s",a,b,c); printf("\n la direccion de puntero es:%p", p); p=&b; printf("\n\n el contenido de la direccion del puntero es:%d",*p); printf("\n\n contenido del array 'd'leido desde el puntero\n"); p=d; // el puntero toma la direccion del indice '0' del array for(int j=0;j<10;j++) { printf("\nd[%d]=%d",j+1,*p); p++; //ingrementa 2byte, debido a q el puntero es un entero } getch(); }

CAPTURA DE PANTALLA FIGURA#12:

EJERCICIO
#include<conio.h> #include<stdio.h> #include<string.h> typedef struct agenda { char nombre[25]; char apellido[25]; char fono[18]; char correo[40]; int edad ; }_agenda; void ingresar (_agenda &a, char nom[], char ape[], char fon[], char cor[],int e); void mostrar (_agenda a); void main() { clrscr(); _agenda amigo1,amigo2 ; ingresar(amigo1,"segundo","c","121345678","ised2c@utm.edu.ec",27); ingresar(amigo2,"carlos","macias","052777665","cmacias@utm.edu.ec",30); mostrar(amigo1); mostrar(amigo2); getch(); } void ingresar (_agenda &a, char nom[],char ape[],char fon[], char cor[],int e) { strcpy (a.nombre,nom); strcpy (a.apellido,ape); strcpy (a.fono,fon); strcpy (a.correo,cor); a.edad=e ; } void mostrar (_agenda a) { _agenda *q=&a; printf("\nNombre: %s\n Apellido: %s\n fono: %s\n Correo: %s\n edad: %d",q->nombre,q->apellido,q>fono,q->correo,q->edad); getch(); }

CAPTURA DE PANTALLA FIGURA#13:

FIGURA#14:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#8: FECHA: 25 de octubre del 2012 TEMA: listas simples

EJERCICIO
#include<conio.h> #include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct agenda { char nombre[25]; char apellido[25]; char fono[18]; char correo[40]; int edad ; struct agenda *sig; }_agenda; typedef _agenda *lista; //tipo de datos puntero para crear la lista typedef _agenda *pnodo; //tipo de datos puntero para crear nodo void ingresar (lista *l, char nom[], char ape[], char fon[], char cor[],int e); void mostrar (lista l); void main() { clrscr(); lista la=NULL;

ingresar(&la,"segundo","c","121345678","ised2c@utm.edu.ec",27); ingresar(&la,"Carlos","Macias","052777665","cmacias@utm.edu.ec",30); ingresar(&la,"Marcos","Macias","254346","marcos@utm.edu,ec",40); mostrar(la); getch(); } void ingresar (lista *l, char nom[],char ape[],char fon[], char cor[],int e) { pnodo nodo; nodo=(pnodo)malloc(sizeof(_agenda)); //creacion del espacio de mamoria para nodo strcpy (nodo->nombre,nom); strcpy (nodo->apellido,ape); strcpy (nodo->fono,fon); strcpy (nodo->correo,cor); nodo->edad=e ; //nodo->sig=NULL; nodo->sig=*l; // paso 1 *l=nodo; // paso 2 } void mostrar (lista l) { pnodo q=l; do{ printf("\nNombre: %s\n Apellido: %s\n fono: %s\n Correo: %s\n edad: %d",q->nombre,q->apellido,q>fono,q->correo,q->edad); q=q->sig; }while(q!=NULL); }

CAPTURA DE PANTALLA FIGURA#15:

EJERCICIO
#include<conio.h> #include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct agenda { char nombre[25]; char apellido[25]; char fono[18]; char correo[40]; int edad ; struct agenda *sig; }_agenda; typedef _agenda *lista; //tipo de datos puntero para crear la lista

typedef _agenda *pnodo; //tipo de datos puntero para crear nodo void ingresar (lista *l, char nom[], char ape[], char fon[], char cor[],int e); void mostrar (lista l); void main() { clrscr(); lista la=NULL; int op,e; char n[50],a[50],f[20],c[60]; do{ printf("\n*****************REGISTRO DE AGENDA**********************\n"); printf("\n**MENU:/_________________________________________________\n"); printf("\n1. REGISTRO DE NUEVO CONTACTO"); printf("\n2. MOSTRAR LISTA DE CONTACTO"); printf("\n3. SALIR"); scanf ("%d",&op); if(op==1) { printf("\n DATOS DEL NUEVO CONTACTO"); printf("\n NOMBRE: "); fflush (stdin); gets(n); printf("\n APELLIDO: "); fflush (stdin); gets(a); printf("\n TELEFONO: "); fflush (stdin); scanf("%s",f); printf("\n CORREO: "); fflush (stdin); scanf("%s",c); printf("\n EDAD: "); scanf("%d",e); ingresar (&la,n,a,f,c,e); printf("\n SE REGISTRO CON EXITO....\n");

} else if(op==2) { printf("\n LISTA DE CONTACTO ALMACENADA\n"); mostrar(la); }

}while(op!=3);

/*ingresar(&la,"segundo","c","121345678","ised2c@utm.edu.ec",27); ingresar(&la,"Carlos","Macias","052777665","cmacias@utm.edu.ec",30); ingresar(&la,"Marcos","Macias","254346","marcos@utm.edu,ec",40); mostrar(la); */ getch(); } void ingresar (lista *l, char nom[],char ape[],char fon[], char cor[],int e) { pnodo nodo; nodo=(pnodo)malloc(sizeof(_agenda)); //creacion del espacio de mamoria para nodo strcpy (nodo->nombre,nom); strcpy (nodo->apellido,ape); strcpy (nodo->fono,fon); strcpy (nodo->correo,cor); nodo->edad=e ; //nodo->sig=NULL; nodo->sig=*l; // paso 1 *l=nodo; // paso 2 } void mostrar (lista l) { pnodo q=l; if(l==NULL) { printf("\n lista de contacto vacia......\n"); } else{ printf("\nlista de contacto almacenada\n"); printf("\nNombre\t\tApellido\t\ttelefono\t\tCorreo\t\tedad\n"); do{ printf("\n%s\t\t%s\t\t%s\t\t%s\t\t%d",q->nombre,q->apellido,q->fono,q->correo,q->edad); q=q->sig;

}while(q!=NULL); } getch(); }

CAPTURA DE PANTALLA

FIGURA#16:

FIGURA#17:

FIGURA#18:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#9: FECHA: 31 de octubre del 2012 TEMA: listas simples

EJERCICIO
#include<conio.h> #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct agenda{ char nombre[25]; char apellidos[25]; char fono[18]; char correo[40]; int edad; struct agenda *sig; }_agenda; typedef _agenda *Lista; //tipo de dato puntero para crear la lista typedef _agenda *pnodo; //tipo de dato puntero para crear nodos void ingresarINI(Lista *l, char nom[],char ape[],char fon[],char cor[],int e); void ingresarFIN(Lista *l, char nom[],char ape[],char fon[],char cor[],int e); void mostrar(Lista l); void main() {clrscr(); Lista La=NULL; int op,e; char n[25],a[25],f[18],c[40];

do{ clrscr(); printf("\n***************REGISTRO DE AGENDA*******************\n"); printf("\n**Menu:_____________________________________________\n"); printf("\n1. Registro de Nuevo Contacto Al Inicio"); printf("\n2. Registro de Nuevo Contacto Al Final"); printf("\n3. Mostrar Lista de Contactos"); printf("\n4. Salir"); scanf("%d",&op); if ((op==1)||(op==2)) {/*printf("\n Datos del Nuevo Contacto"); printf("\nNombres: "); fflush(stdin); gets(n); printf("\nApellidos: "); fflush(stdin); gets(a); printf("\nTelefono: "); fflush(stdin); scanf("%s",f); printf("\nCorreo: "); fflush(stdin); scanf("%s",c); printf("\nEdad: ");scanf("%d",&e); if (op==1) ingresarINI(&La,n,a,f,c,e); else ingresarFIN(&La,n,a,f,c,e); */ if(op==1) { ingresarINI(&La,"Carlos","Navia","245120","cnavia@utm.edu.ec",20); ingresarINI(&La,"Martha","Vallejo","2639070","mvallejo@utm.edu.ec",23); ingresarINI(&La,"Luis","Moreira","2639714","lmoreira@utm.edu.ec",30); ingresarINI(&La,"Andrea","Romero","2315025","aromero@utm.edu.ec",19); } else {ingresarFIN(&La,"Carlos","Navia","2451201","cnavia@utm.edu.ec",20); ingresarFIN(&La,"Martha","Vallejo","2639070","mvallejo@utm.edu.ec",23); ingresarFIN(&La,"Luis","Moreira","2639714","lmoreira@utm.edu.ec",30); ingresarFIN(&La,"Andrea","Romero","2315025","aromero@utm.edu.ec",19); } printf("\nSe registro con exito...\n"); } else if(op==3) { mostrar(La); } getch(); }while (op!=4); }

void ingresarINI(Lista *l,char nom[],char ape[],char fon[],char cor[],int e) {pnodo nodo; nodo=(pnodo)malloc(sizeof(_agenda));//creacion de espacio-memoria para nodo strcpy(nodo->nombre,nom); strcpy(nodo->apellidos,ape); strcpy(nodo->fono,fon); strcpy(nodo->correo,cor); nodo->edad=e; nodo->sig=*l; //1 *l=nodo; //2 } void ingresarFIN(Lista *l,char nom[],char ape[],char fon[],char cor[],int e) {//crear elnodo pnodo nodo,ult; nodo=(pnodo)malloc(sizeof(_agenda));//creacion de espacio-memoria para nodo //almacenar la informacion al nodo strcpy(nodo->nombre,nom); strcpy(nodo->apellidos,ape); strcpy(nodo->fono,fon); strcpy(nodo->correo,cor); nodo->edad=e; //enlaces if (!*l) *l=nodo; else {ult=*l; while(ult->sig) // ult->sig!=NULL ult=ult->sig; ult->sig=nodo; } nodo->sig=NULL; }

void mostrar(Lista l) {pnodo q=l; if (l==NULL) // if !(l) {printf("\nLista de Contactos vacia...\n"); }

else{ printf("\nLista de Contactos Almacenados\n"); printf("\nNombre\t\tApellidos\t\Telefono\t\tCorreo\t\tEdad\n"); do{ printf("\n%s\t\t%s\t\t%s\t\t%s\t%d",q->nombre,q->apellidos, q->fono,q->correo,q->edad); q=q->sig; }while(q!=NULL); } }

CAPTURA DE PANTALLA

FIGURA#19:

FIGURA#20:

FIGURA#21:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#10: FECHA: 01 de noviembre del 2012 TEMA: ejercicio de listas simples

EJERCICIO
#include<conio.h> #include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct agenda { char nombre[25]; char apellido[25]; char fono[18]; char correo[40]; int edad ; struct agenda *sig; }_agenda; typedef _agenda *lista; //tipo de datos puntero para crear la lista typedef _agenda *pnodo; //tipo de datos puntero para crear nodo void ingresarINI (lista *l, char nom[], char ape[], char fon[], char cor[],int e); void ingresarFIN (lista *l, char nom[], char ape[], char fon[], char cor[],int e); void buscarxape (lista l, char ape[]); void mostrar (lista l); void main() {

clrscr(); lista la=NULL; int op,e; char n[50],a[50],f[20],c[60]; do{ printf("\n*****************REGISTRO DE AGENDA**********************\n"); printf("\n**MENU:/__________________________________________________\n"); printf("\n1. REGISTRO DE NUEVO CONTACTO AL INICIO"); printf("\n2. REGISTRO DE NUEVO CONTACTO AL FINAL"); printf("\n3 BUSCAR UN CONTACTO POR APELLIDO"); printf("\n4. MOSTRAR LISTA DE CONTACTO"); printf("\n5. SALIR"); scanf ("%d",&op); if((op==1)||(op==2)) { /* printf("\n DATOS DEL NUEVO CONTACTO"); printf("\n NOMBRE: "); fflush (stdin); gets(n); printf("\n APELLIDO: "); fflush (stdin); gets(a); printf("\n TELEFONO: "); fflush (stdin); scanf("%s",f); printf("\n CORREO: "); fflush (stdin); scanf("%s",c); printf("\n EDAD: "); scanf("%d",e); ingresarINI (&la,n,a,f,c,e); */ if(op==1) {ingresarINI(&la,"Mario","Mendoza","254125","mmendoza@utm.edu.ec",20); ingresarINI(&la,"Kerly","Velez","236523","kvelez@utm.edu.ec",18); ingresarINI(&la,"Cristina","Alcivar","145658","calcivar@utm.edu.ec",19); } else { ingresarFIN(&la,"Mario","Mendoza","254125","mmendoza@utm.edu.ec",20); ingresarFIN(&la,"Kerly","Velez","236523","kvelez@utm.edu.ec",18); ingresarFIN(&la,"Cristina","Alcivar","145658","calcivar@utm.edu.ec",19); } printf("\n SE REGISTRO CON EXITO....\n"); } else if(op==2) {

printf("\n LISTA DE CONTACTO ALMACENADA\n"); mostrar(la); } }while(op!=5); getch(); } void ingresarINI (lista *l, char nom[],char ape[],char fon[], char cor[],int e) { //CREAR EL NODO pnodo nodo,ult; nodo=(pnodo)malloc(sizeof(_agenda)); //creacion del espacio de mamoria para nodo //ALMACENAR LA INFORMACION AL NODO strcpy (nodo->nombre,nom); strcpy (nodo->apellido,ape); strcpy (nodo->fono,fon); strcpy (nodo->correo,cor); nodo->edad=e ; // ENLACESS nodo->sig=*l; *l=nodo; } void ingresarFIN (lista *l, char nom[],char ape[],char fon[], char cor[],int e) { //CREAR EL NODO pnodo nodo,ult; nodo=(pnodo)malloc(sizeof(_agenda)); //creacion del espacio de mamoria para nodo //ALMACENAR LA INFORMACION AL NODO strcpy (nodo->nombre,nom); strcpy (nodo->apellido,ape); strcpy (nodo->fono,fon); strcpy (nodo->correo,cor); nodo->edad=e ; // ENLACESS if (!*l) { nodo->sig=NULL;

*l=nodo; } else { ult=*l; while(ult->sig) // ult->sig!=NULL ult=ult->sig; ult->sig=nodo; } nodo->sig=NULL; } void buscarxape (lista l, char ape[]) { pnodo aux=l; while((aux && strcmp(aux->apellido,ape)!=0)) aux=aux->sig; if(aux) printf("\n CONTACTO %s %s \n telefono:%s \n correo: %s \n edad: %d",aux-> nombre,aux->apellido,aux->fono,aux->correo,aux->edad); } void mostrar (lista l) { pnodo q=l; if(l==NULL) { printf("\n lista de contacto vacia......\n"); } else{ printf("\nlista de contacto almacenada\n"); printf("\nNombre\t\tApellido\t\ttelefono\t\tCorreo\t\tedad\n"); do{ printf("\n%s\t\t%s\t\t%s\t\t%s\t\t%d",q->nombre,q->apellido,q->fono,q->correo,q->edad); q=q->sig; }while(q!=NULL); } getch(); }

CAPTURA DE PANTALLA FIGURA#22:

FIGURA#23:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#11: FECHA: 7 de noviembre del 2012 TEMA: localizar y eliminar

Consideremos la siguiente estructura a nuestra clase

#include<conio.h> #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct empleado{char nombre[30]; char apellido[30]; long int cedula; char departamento[100]; float sueldo; struct empleado *sig; }tipoempleado; typedef tipoempleado *Lista; //tipo de dato puntero para manejar listas typedef tipoempleado *pnodo; //tipo de dato puntero para crear nodos Ahora sumemos a nuestras funciones de ingreso ya realizadas y modificadas las funciones prototipos para buscar y eliminar void ingresarINI(Lista *l, char nom[],char ape[],long int ced, char dep[],float suel); void ingresarFIN(Lista *l, char nom[],char ape[],long int ced, char dep[],float suel); int verificarxcedula(Lista l, char ape[]); void buscarxdpt(Lista l, char dep[]); void buscarxdpt_all(Lista l, char dep[]); void mostrar(Lista l); void eliminar(Lista *l, char ape[]); void eliminar_all(Lista *l); void eliminar_nodos(Lista *l, char ape[]);

Proceso de modificar la funcion para evitar introducir nuevos nodos con la misma informacin: Debemos pensar en una funcin buscar que localice a un nodos con una informacin que no se repita... pensando un poco podemos creer que la informacin puede contener nombre o apellidos de igual valor.. Pero el valor de cedula no es un dato que se repita. Si cambiamos la funcin void verificarxcedula(Lista l, long int ced) {pnodo aux=l; while(aux && (aux->cedula!=ced)) aux=aux->sig; if(aux) return (1); else return (0); } Esta funcin solo generar 2 estados 1. Si existe =1 2. No existe =0 Al emplearlo podamos emplear en las funciones de ingreso de la siguiente forma: La funcin verificarxceula antes de crear el espacio de memoria con malloc Observen que la funcion fue diseada para devolver 1 si existe y 0 en caso de no existir void ingresarINI(Lista *l, char nom[],char ape[],long int ced, char dep[],float suel) {pnodo nodo; if (verificarxcedula(*l,ced)==1) return; // si

nodo=(pnodo)malloc(sizeof(tipoempleado));//crear nodo solic. al S.O. strcpy(nodo->nombre,nom); strcpy(nodo->apellido,ape); strcpy(nodo->departamento,dep); nodo->cedula=ced; nodo->sueldo=suel; //enlaces de los nodos al inicio nodo->sig=*l; *l=nodo; } PROCESO DE ELIMINACION DE NODOS ELIMINAR TODA UNA LISTA Recorrer cada nodo y en cada pasada debemos ir desplazando la cabecera de la lista para ir desplazndola y poder tomar la direccin de ese primer nodo <<El que se va a eliminar>> Teniendo la siguiente funcin: void eliminar_all(Lista *l) {pnodo aux; while(*l) {aux=*l; *l=aux->sig; free(aux); } }

ELIMINAR UN NODO ESPECFICO Asumimos eliminar nodos de un empleado Tendramos que localizarlo y luego destruirlo con la funcion free void eliminar(Lista *l, char ape[]) {pnodo nodo, aux; if (!*l) printf("\nLista Vacia...\nImposible eliminar elementos.."); else {if (strcmp((*l)->apellido,ape)==0) {aux=*l; *l=aux->sig; free(aux); printf("\nSe elimino elemento %s con exito",ape); } else {aux=*l; while((aux->sig)&&(strcmp(aux->sig->apellido,ape)!=0)) aux=aux->sig; if (aux->sig) {nodo=aux->sig; aux->sig=nodo->sig; free(nodo); printf("\nSe elimino elemento %s con exito",ape); } }} }

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#12: FECHA: 8 de noviembre del 2012 TEMA: ejercicio de eliminar

EJERCICIO
ELIMINAR TODOS LOS NODOS QUE COINCIDEN CON UN CRITERIO
Podramos usar el cdigo de la funcion de eliminar un nodo especifico, pero debemos procurar realizar nuestra operacin hasta llegar al final de los nodos con el fin de explorar todos los nodos
void eliminar_nodos(Lista *l, char ape[]) {pnodo nodo, aux, tem=*l; int c=0; while(tem) //nuevo while { if (!*l) printf("\nLista Vacia...\nImposible eliminar elementos.."); else {if (strcmp((*l)->apellido,ape)==0) {aux=*l; *l=aux->sig; free(aux); tem=*l; c++; } else {aux=*l; while((aux->sig)&&(strcmp(aux->sig->apellido,ape)!=0)) aux=aux->sig; if (aux->sig) {nodo=aux->sig; aux->sig=nodo->sig;

free(nodo); tem=*l; c++; } else tem=tem->sig; } } }//cierre de nuevo while if(c==0) printf("\no se encontr el nodo con apellido %s",ape); else printf("\nSe encontraron %d elementos con apellido %s y fueron eliminados con xito",c,ape); }

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#13: FECHA: 14 de noviembre del 2012 TEMA: pilas

*Es un tipo especial de listas abiertas *Es coleccion de nodos apilados uno encima de otro * tiene una cima o tope es la que indica por donde ingresan los nodos *Emplea un metodo LIFO(ultimo en entrar primero en salir) *La pila tiene dos estados -llena -vacia *Tiene 2 operaciones: -Apilar (Ingresar nodos por la cima). Son las mismas operaciones de la funcion ingresar al inicio de las listas abiertas. -Desapilar(Leer y Eliminar el elemento de la cima) Definicin:

typedef struct persona{long int cedula; struct persona *sig; }_persona;

typedef _persona *Pila; //para manejar la cima typedef _persona *pnodo;//para crear nodos void apilar(Pila *p, long int ced); long int desapilar(Pila *p); //implementacion de funciones void apilar(Pila *p, long int ced) {pnodo nodo; nodo=(pnodo) malloc(sizeof(_persona)); nodo->cedula=ced; nodo->sig=*p; *p=nodo; } long int desapilar(Pila *p)// *p representa a la cima {long int dato=-1; if (*p) {pnodo aux=*p; //1- se ubica un puntero auxiliar en la cima dato=aux->cedula; // 2- sacamos la informacion *p=aux->sig; //3- desplazamos a la cima free(aux); //4- destruir el nodo leido } return (dato); } void main() {clrscr(); Pila pA=NULL; apilar(&pA,1312); apilar(&pA,1315); apilar(&pA,1311);

apilar(&pA,1719); getch(); }

EJERCICIO
#include<conio.h> #include<stdlib.h> #include<stdio.h> #include<string.h> typedef struct persona{long int cedula; char nombre[50]; int edad; struct persona *sig; }_persona;

typedef _persona *Pila; //para manejar la cima typedef _persona *pnodo;//para crear nodos //funciones prototipos void apilar(Pila *p, long int ced,char nom[],int ed); pnodo desapilar(Pila *p); //implementacion de funciones void apilar(Pila *p, long int ced,char nom[],int ed) {pnodo nodo; nodo=(pnodo) malloc(sizeof(_persona)); nodo->cedula=ced; strcpy(nodo->nombre,nom); nodo->edad=ed; nodo->sig=*p; *p=nodo; } pnodo desapilar(Pila *p)// *p representa a la cima {pnodo dato=NULL; if (*p) {pnodo aux=*p; //1- se ubica un puntero auxiliar en la cima dato->cedula=aux->cedula; // 2- sacamos la informacion dato->edad=aux->edad;

strcpy(dato->nombre,aux->nombre); *p=aux->sig; //3- desplazamos a la cima free(aux); //4- destruir el nodo leido } return (dato); } void main() { Pila pA=NULL; pnodo elemento; long int c; char n[50]; int e,opc; do{clrscr(); printf("\n Registro de Cedulas"); printf("\n 1.Apilar una cedula"); printf("\n 2.Desapilar cedulade la cima"); printf("\n 3. Salir"); scanf("%d",&opc); if (opc==1) {printf("Ingrese su cedula");fflush(stdin); scanf("%ld",&c); printf("Ingrese su nombre");fflush(stdin); scanf("%s",n); printf("Ingrese su edad");fflush(stdin); scanf("%d",&e); apilar (&pA,c,n,e); printf("\nSe apilo con exito..."); } else if(opc==2) {if (pA) {elemento=desapilar(&pA); printf("\n El elemento de la cima de la pila es:\ncedula=%ld\n nombre:%s\nedad:%d",elemento>cedula,elemento->nombre,elemento->edad); } else printf("\nPila vacia..."); } getch(); }while (opc!=3); }

CAPTURA DE PANTALLA

FIGURA#24:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#14: FECHA: 15 de noviembre del 2012 TEMA: ejercicio de pilas

EJERCICIO
#include<conio.h> #include<stdlib.h> #include<stdio.h> #include<string.h> typedef struct persona{long int cedula; char nombre[50]; int edad; struct persona *sig; }_persona;

typedef _persona *Pila; //para manejar la cima typedef _persona *pnodo;//para crear nodos char mensaj[100]; //funciones prototipos void apilar(Pila *p, long int ced,char nom[],int ed); pnodo desapilar(Pila *p); void mostrar(Pila *p); int buscar(Pila *p, long int c); //implementacion de funciones void apilar(Pila *p, long int ced,char nom[],int ed) {pnodo nodo; if (buscar(p,ced)==1) {strcpy(mensaj,"Elemento ya registrado"); return; }

nodo=(pnodo) malloc(sizeof(_persona)); nodo->cedula=ced; strcpy(nodo->nombre,nom); nodo->edad=ed; nodo->sig=*p; *p=nodo; strcpy(mensaj,"Se apilo con exito..."); } pnodo desapilar(Pila *p)// *p representa a la cima {pnodo dato=NULL; if (*p) {pnodo aux=*p; //1- se ubica un puntero auxiliar en la cima dato->cedula=aux->cedula; // 2- sacamos la informacion dato->edad=aux->edad; strcpy(dato->nombre,aux->nombre); *p=aux->sig; //3- desplazamos a la cima free(aux); //4- destruir el nodo leido } return (dato); } void mostrar(Pila *p) {pnodo elemento; Pila Paux=NULL; if (!*p) {printf("\nPilaVacia.."); return ; } while (*p) {elemento=desapilar(p); printf("\n El elemento de la cima de la pila es:\ncedula=%ld\n nombre:%s\nedad:%d",elemento>cedula,elemento->nombre,elemento->edad); apilar(&Paux,elemento->cedula,elemento->nombre,elemento->edad); } while(Paux) { elemento=desapilar(&Paux); apilar(p,elemento->cedula,elemento->nombre,elemento->edad); } } int buscar(Pila *p, long int c) {pnodo aux;

Pila Paux=NULL; int M=0; if (*p) { do{aux=desapilar(p); apilar(&Paux,aux->cedula,aux->nombre,aux->edad); }while((aux)&&(aux->cedula!=c)); if (aux->cedula==c) M=1; while(Paux) {aux=desapilar(&Paux); apilar(p,aux->cedula,aux->nombre,aux->edad); } } return (M); }

void main() { Pila pA=NULL; pnodo elemento; long int c; char n[50]; int e,opc; do{clrscr(); printf("\n Registro de Cedulas"); printf("\n 1.Apilar una cedula"); printf("\n 2.Desapilar cedula de la cima"); printf("\n 3.Mostar Pila"); printf("\n 4. Salir"); scanf("%d",&opc); if (opc==1) {printf("Ingrese su cedula");fflush(stdin); scanf("%ld",&c); printf("Ingrese su nombre");fflush(stdin); scanf("%s",n); printf("Ingrese su edad");fflush(stdin); scanf("%d",&e); apilar (&pA,c,n,e); printf("%s",mensaj); } else if(opc==2) {if (pA) {elemento=desapilar(&pA);

printf("\n El elemento de la cima de la pila es:\ncedula=%ld\n nombre:%s\nedad:%d",elemento>cedula,elemento->nombre,elemento->edad); } else printf("\nPila vacia..."); } else if(opc==3) {mostrar(&pA); } getch(); }while (opc!=4); }

CAPTURA DE PANTALLA

FIGURA#25:

FIGURA#26:

FIGURA#27:

FIGURA#28:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#15: FECHA: 21 de noviembre del 2012 TEMA: colas

DEFINICIN
Una cola es un tipo especial de lista abierta en la que slo se pueden insertar nodos en uno de los extremos de la lista y slo se pueden eliminar nodos en el otro. Adems, como sucede con las pilas, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo ledo. Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir. El smil cotidiano es una cola para comprar, por ejemplo, las entradas del cine. Los nuevos compradores slo pueden colocarse al final de la cola, y slo el primero de la cola puede comprar la entrada. El nodo tpico para construir pilas es el mismo que vimos en los captulos anteriores para la construccin de listas y pilas: struct nodo { int dato; struct nodo *siguiente; }; Declaraciones de tipos para manejar colas en C ^ Los tipos que definiremos normalmente para manejar colas sern casi los mismos que para manejar listas y pilas, tan slo cambiaremos algunos nombres:

typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Cola; tipoNodo es el tipo para declarar nodos, evidentemente. pNodo es el tipo para declarar punteros a un nodo. Cola es el tipo para declarar colas.

Cola Es evidente, a la vista del grfico, que una cola es una lista abierta. As que sigue siendo muy importante que nuestro programa nunca pierda el valor del puntero al primer elemento, igual que pasa con las listas abiertas. Adems, debido al funcionamiento de las colas, tambin deberemos mantener un puntero para el ltimo elemento de la cola, que ser el punto donde insertemos nuevos nodos. Teniendo en cuenta que las lecturas y escrituras en una cola se hacen siempre en extremos distintos, lo ms fcil ser insertar nodos por el final, a continuacin del nodo que no tiene nodo siguiente, y leerlos desde el principio, hay que recordar que leer un nodo implica eliminarlo de la cola.

EJERCICIO
#include<conio.h> #include<stdio.h> #include<stdio.h> #include<stdlib.h> typedef struct _cola{ char dato; struct _cola *sig; }tipocola; typedef tipocola *cola; typedef tipocola *pnodo; void encolar(cola *p, cola *u, char d); char desencolar(cola *p, cola *u); void main() {int op; cola cop=NULL,cou=NULL; char ca; do{ printf("\n MENU DE COLA....."); printf("\n1. encolar caracter"); printf("\n2. desencolar caracteres"); printf("\n3. salir"); printf("\n digite su opcion: "); scanf("%d",&op) ; if(op==1) { printf("ingrese un caracter"); fflush(stdin);scanf("%c",&ca); encolar(&cop,&cou,ca); getch(); } else if (op==2) {printf("\n el elemento desencolado: %c",desencolar(&cop,&cou)); } }while(op!=3); } void encolar(cola *p, cola *u, char d) {

pnodo nuevo; nuevo=(pnodo)malloc(sizeof(tipocola)); nuevo->dato=d; nuevo->sig=NULL; if(!*p) *p=nuevo; if(*u) (*u)->sig=nuevo; *u=nuevo; } char desencolar(cola *p, cola *u) { char r=' '; pnodo aux; if(!*p) {printf("\ncola vacia...."); getch(); } else {aux=*p; *p=aux->sig; r=aux->dato; if(!*p) {*u=NULL; } free(aux); } return (r); }

CAPTURA DE PANTALLA

Figura#29:

FIGURA#30:

FIGURA#31:

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

CLASE#16: FECHA: 22 de noviembre del 2012 TEMA: lista simples cerradas

DEFINICIN
Una lista circular es una lista lineal en la que el ltimo nodo a punta al primero. Las listas circulares evitan excepciones en las operaciones que se realicen sobre ellas. No existen casos especiales, cada nodo siempre tiene uno anterior y uno siguiente. En algunas listas circulares se aade un nodo especial de cabecera, de ese modo se evita la nica excepcin posible, la de que la lista est vaca. El nodo tpico es el mismo que para construir listas abiertas: struct nodo { int dato; struct nodo *siguiente; }; Declaraciones de tipos para manejar listas circulares en C 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.

Lista circular A pesar de que las listas circulares simplifiquen las operaciones sobre ellas, tambin introducen algunas complicaciones. Por ejemplo, en un proceso de bsqueda, no es tan sencillo dar por terminada la bsqueda cuando el elemento buscado no existe. Por ese motivo se suele resaltar un nodo en particular, que no tiene por qu ser siempre el mismo. Cualquier nodo puede cumplir ese propsito, y puede variar durante la ejecucin del programa. Otra alternativa que se usa a menudo, y que simplifica en cierto modo el uso de listas circulares es crear un nodo especial de har la funcin de nodo cabecera. De este modo, la lista nunca estar vaca, y se eliminan casi todos los casos especiales.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

TRABAJO DE EJECUCIN (EN CLASE, TAREAS INDIVIDUALES Y GRUPALES, INVESTIGACIN)

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

TAREAS

TAREA #1:
Supongamos que nos enfrentamos a un problema como este: Una empresa que cuenta con 150 empleados, desea establecer una estadstica sobre los salarios de sus empleados, y quiere saber cual es el salario promedio, y tambin cuantos de sus empleados gana entre $1250.00y $2500.00.

#include<iostream.h> #include<conio.h> #include<stdio.h> void main () { clrscr (); int x, c=0; char n[150]; float sp[150], t=0; for(x=0; x<150; x++) { cout<<ingrese el nombre del empleado: <<endl; cin>>n[x]; cout<<ingrese el sueldo: <<endl; cin>>sp[x]; if((sp[x]>1250)&&(sp[x<2500])) { c=c+1; } t=t=sp[x]; getch(); } for(x=0; x<150; x++) { cout<<n[x]; cout<<sp[x]; }

cout<<sueldo promedio: <<t; cout<<personas que reciben sueldo entre 1250 y 2500: <<c; getch(); }

TAREAS #2

PRIMER EJERCICIO
Calcular el sueldo mensual de un empleado que trabaja por horas, el pago de cada hora trabajada depende de su categora: Categora pago x hora (S/.) A 35.60 B 33.40 C 28.45 Adems si el empleado trabaja ms de 115 horas mensuales tiene una bonificacin del 2.5 % de sueldo. Usar estructuras #include <conio.h> #include <stdio.h> <iostream.h> struct sueldo { float total; float bono; }; struct categoria_ { char categor; float a; float b; float c; }; struct datos { char nombre[50];

#include

struct categoria_ categoria; int horas; int dias_mes; struct sueldo varsueldo; }empleado; void main () { empleado.categoria.a=26.90; empleado.categoria.b=24.30; empleado.categoria.c=21.50; clrscr(); printf("Ingrese el nombre del empleado:"); scanf("%s",&empleado.nombre); printf("Ingrese numero de horas diarias de labor:"); scanf("%d",&empleado.horas); printf("Ingrese numero de das del mes laborados:"); scanf("%d",&empleado.dias_mes); printf("Ingrese la categoria (A B o C):"); scanf("%s",&empleado.categoria.categor); empleado.horas=empleado.horas*empleado.dias_mes; if(empleado.categoria.categor=='a') {empleado.varsueldo.total=empleado.horas*empleado.categoria.a;} if(empleado.categoria.categor=='b') {empleado.varsueldo.total=empleado.horas*empleado.categoria.b;} if(empleado.categoria.categor=='c') {empleado.varsueldo.total=empleado.horas*empleado.categoria.c;} if(empleado.horas>=150) {empleado.varsueldo.bono=empleado.varsueldo.total*0.05;}

empleado.varsueldo.total=empleado.varsueldo.total+empleado.varsueldo.bono;

clrscr(); printf("Nombre del empleado: %s\n",empleado.nombre); printf("horas laboradas: %d\n",empleado.horas); printf("dias al mes laborados: %d\n",empleado.dias_mes); printf("Categoria: %c\n",empleado.categoria.catg); printf("Bono: %f\n",empleado.varsueldo.bono); printf("Total: %f\n",empleado.varsueldo.total); getch(); } FIGURA: 1

el un

Ingresando nombre de empleado

FIGURA: 2

Ingresando las horas diarias de labor del trabajo FIGURA: 3

Ingresando los das del mes laborados

FIGURA: 4

Ingresando la categoria del empleado FIGURA: 5

Impresin de los datos del trabajador trabajador SEGUNDO EJERCICIO Definicin de estructura y manipulacin de varias estructura Defina un tipo de datos llamado TFECHA, con los campos adecuados para almacenar el da, mes y ao de las fechas.

Defina un tipo de datos llamado TCD con campos adecuados para guardar el nombre del lbum, el cantante o grupo, la fecha que lo adquiri (que debe ser del tipo TFECHA), y el tipo de msica (Pop, Rock, etc.). Declare un arreglo MisCDsde tamao 25 de tipo TCD. Asigne en la primera posicin del arreglo MisCDs, los datos correspondientes a su lbum musical favorito (si no recuerda la fecha en que lo adquiri, puede poner cualquiera) #include <conio.h> #include <iostream.h> #include <stdio.h> #include <string.h>

struct TFECHA_ {int dia; int mes; int anio; }; struct TCD_ { char nom_album[100]; char interprete[50]; struct TFECHA_ fecha; char genre[15]; }; struct TCD_ MisCds[30]; void main() {

strcpy (MisCds[1].nom_album," La oreja de Ban Goh"); strcpy (MisCds[1].interprete, "NO TE RINDAS");

MisCds[1].fecha.dia=23; MisCds[1].fecha.mes=03; MisCds[1].fecha.anio=2012; strcpy (MisCds[1].genre,"POP"); printf("\nombre de album:\t%s",MisCds[1].nom_album); printf("\nInterprete:\t \t %s",MisCds[1].interprete); printf("\nFecha:\t\t\t%d/%d/%d",MisCds[1].fecha.dia,MisCds[1].fecha.mes,MisCds[1].fe cha.anio); printf("\nGenero:\t \t \t %s",MisCds[1].genre); getch(); }

Figura:

Impresin de los datos del lbum

TAREA #5:

Punteros usando estructuras


Un puntero es un tipo de variable que permite almacenar y manipular las direcciones de memoria donde se encuentran almacenados los datos, en lugar de los datos mismos. El manejo de punteros en el lenguaje C es muy poderoso y eficiente, aunque demanda extremo cuidado en su utilizacin. Bien utilizado hace que el cdigo sea ms compacto y eficiente; por el contrario, su uso descuidado lleva a tener poca claridad y frecuentemente conduce a la prdida del control de la CPU, ocasionando un comportamiento indeseable del proceso (vulgarmente se dice que el programa" revent"). Un puntero puede apuntar a una estructura y acceder a sus campos: struct Dato { int campo1, campo2; char campo3 [30]; }; struct Dato x; struct Dato *ptr; ... ptr = &x; (*ptr).campo1 = 33; strcpy ( (*ptr).campo3, "hola" ); El uso de punteros nos permite acceder al valor de una variable en forma indirecta. Para esto se utilizan dos operadores: & El operador "direccin de memoria de" que permite obtener la direccin de memoria donde se aloja la variable a la cual precede (&x es la direccin de memoria de x).

El operador "contenido de lo apuntado por" que permite acceder al valor almacenado en la direccin de memoria que indica el puntero al cual precede *px es el contenido de lo apuntado por px)

Direccin de memoria. Operador &


Para almacenar una referencia a un objeto en un puntero se puede aplicar al objeto el operador prefijo &, que lo que hace es devolver la direccin que en memoria ocupa el objeto sobre el que se aplica. Un ejemplo de su uso para inicializar un puntero es: int x =10; int * px = &x; Este operador no es aplicable a expresiones constantes, pues stas no se almacenan en ninguna direccin de memoria especfica sino que se incrustan en las instrucciones. Por ello, no es vlido hacer directamente: int px = &10; // Error 10 no es una variable con direccin propia

Tampoco es vlido aplicar & a campos readonly, pues si estos pudiesen ser apuntados por punteros se correra el riesgo de poderlos modificar ya que a travs de un puntero se accede a memoria directamente, sin tenerse en cuenta si en la posicin accedida hay algn objeto, por lo que mucho menos se considerar si ste es de slo lectura. Lo que es s vlido es almacenar en un puntero es la direccin de memoria apuntada por otro puntero. En ese caso ambos punteros apuntaran al mismo objeto y las modificaciones a ste realizadas a travs de un puntero tambin afectaran al objeto visto por el otro, de forma similar a como ocurre con las variables normales de tipos referencia. Es ms, los operadores relacionales tpicos (==, !=, <,>, <= y >=) se han redefinido para que cuando se apliquen entre dos punteros de cualesquiera dos tipos lo que se compare sean las direcciones de memoria que estos almacenan. Por ejemplo: int x = 10; int px = &x;

int px2 = px; // px y px2 apuntan al objeto almacenado en x Console.WriteLine( px == px2); // Imprime por pantalla True En realidad las variables sobre las que se aplique & no tienen porqu estar inicializadas. Por ejemplo, es vlido hacer: private void f() { int x; unsafe { int px = &x;} }

Esto se debe a que uno de los principales usos de los punteros en C# es poderlos pasar como parmetros de funciones no gestionadas que esperen recibir punteros. Como muchas de esas funciones han sido programadas para inicializar los contenidos de los punteros que se les pasan, pasarles punteros inicializados implicara perder tiempo innecesariamente en inicializarlos.

Puntero. Operador *
Un puntero no almacena directamente un objeto sino que suele almacenar la direccin de memoria de un objeto (o sea, apunta a un objeto) Para obtener a partir de un puntero el objeto al que apunta hay que aplicarle al mismo el operador prefijo *, que devuelve el objeto apuntado. Por ejemplo, el siguiente cdigo imprime en pantalla un 10: int x = 10; int * px= &x; Console.WriteLine(*px); Es posible en un puntero almacenar null para indicar que no apunta a ninguna direccin vlida. Sin embargo, si luego se intenta acceder al contenido del mismo a travs del operador * se producir generalmente una excepcin de tipo NullReferenceException (aunque realmente esto depende de la implementacin del lenguaje) Por ejemplo:

int * px = null; Console.WriteLine(*px); // Produce una NullReferenceException No tiene sentido aplicar * a un puntero de tipo void * ya que estos punteros no almacenan informacin sobre el tipo de objetos a los que apuntan y por tanto no es posible recuperarlos a travs de los mismos ya que no se sabe cuanto espacio en memoria a partir de la direccin almacenada en el puntero ocupa el objeto apuntado y, por tanto, no se sabe cuanta memoria hay que leer para obtenerlo.

Puntero. Operador ->


Si un puntero apunta a un objeto estructura que tiene un mtodo F() sera posible llamarlo a travs del puntero con: (*objeto). F(); Sin embargo, como llamar a objetos apuntados por punteros es algo bastante habitual, para facilitar la sintaxis con la que hacer esto se ha incluido en C# el operador ->, con el que la instruccin anterior se escribira as: objeto->f(); Es decir, del mismo modo que el operador. permite acceder a los miembros de un objeto referenciado por una variable normal, ->permite acceder a los miembros de un objeto referenciado por un puntero. En general, un acceso de la forma O -> M es equivalente a hacer (*O).M. Por tanto, al igual que es incorrecto aplicar * sobre punteros de tipo void *, tambin lo es aplicar ->

Ejercicio analizado en clase sobre puntero estructurado.


#include<conio.h> #include<stdio.h> #include<string.h> typedef struct agenda { char nombre[25]; char apellido[25]; char fono[18]; char correo[40]; int edad ; }_agenda; void ingresar (_agenda *p, char nom[], char ape[], char fon[], char cor[],int e); void mostrar (_agenda a); void main() { clrscr(); _agenda amigo1,amigo2,*u ; u=&amigo1; ingresar(u,"segundo","c","121345678","ised2c@utm.edu.ec",27); u=&amigo2; ingresar(u,"carlos","macias","052777665","cmacias@utm.edu.ec",30); mostrar(amigo1); mostrar(amigo2); getch(); } void ingresar (_agenda *a, char nom[],char ape[],char fon[], char cor[],int e) { strcpy (a->nombre,nom); strcpy (a->apellido, ape); strcpy (a->fono,fon); strcpy (a->correo,cor); a->edad=e ; }

void mostrar (_agenda a) { _agenda *q=&a; printf("\nNombre: %s\n Apellido: %s\n fono: %s\n Correo: %s\n edad: %d",q>nombre,q->apellido,q->fono,q->correo,q->edad); getch(); }

Figura 1.

Figura 2.

Tarea #6: #include<conio.h> #include<stdio.h> void main () { clrscr(); int a,b; char c[50]="ANA CEDENO"; int d[10]={10,20,30,40,50,60,70,80,90,100}; b=7; a=10; printf("\n la informacion de las variables es:"); printf("a=%d ,b=%d ,c=%s",a,b,c); for(int f=0;f<10;f++) printf("\nd[%d]=%d",f+1,d[f]); printf("\n\n la dereccion de las variables es:"); printf("a=%p ,b=%p ,c=%p",&a,&b,&c); for(int i=0;i<10;i++) printf("\nd[%d]=%p",i+1,&d[i]); int *p; //puntero a enteros p=&a; //enlazamiento al puntero a la la direccion de la variable"a" *p=800; // modificando el contenido existente en la direccion enlazada printf("\n\n variable 'a' modificada con un puntero \n\n"); printf("a=%d ,b=%d ,c=%s",a,b,c); printf("\n la direccion de puntero es:%p", p); p=&b; printf("\n\n el contenido de la direccion del puntero es:%d",*p);

printf("\n\n contenido del array 'd'leido desde el puntero\n"); p=d; // el puntero toma la direccion del indice '0' del array for(int j=0;j<10;j++) { printf("\nd[%d]=%d",j+1,*p); p++; //ingrementa 2byte, debido a q el puntero es un entero } getch(); }

TAREA #8:

Insertar un elemento en la ltima posicin de una lista


Este es otro caso especial. Para este caso partiremos de una lista no vaca:

Insertar al final

El proceso en este caso tampoco es excesivamente

complicado:

1. Necesitamos un puntero que seale al ltimo elemento de la lista. La manera de conseguirlo es empezar por el primero y avanzar hasta que el nodo que tenga como siguiente el valor NULL. 2. Hacer que nodo->siguiente sea NULL. 3. Hacer que ultimo->siguiente sea nodo.

Insertado al final

Insertar un elemento a continuacin de un nodo cualquiera de una lista


De nuevo podemos considerar el caso anterior como un caso particular de este. Ahora el nodo "anterior" ser aquel a continuacin del cual insertaremos el nuevo nodo:

Insertar dentro

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

El proceso a seguir ser: 1. Hacer que nodo->siguiente seale a anterior->siguiente. 2. Hacer que anterior->siguiente seale a nodo.

Insertado dentro

TAREA #11:

COLAS
Las colas no son ms que listas lineales de informacin a las cuales se accede de un modo determinado siendo el de tipo (FIFO) lo que quiere decir que el primer dato en entrar es tambin el primer dato en salir, en las colas no se permite el acceso aleatorio a ningn elemento concreto (como ejemplo podemos imaginar la cola de un supermercado, la de un cine,.....), las inserciones para las colas se hacen al final de la lista.

Hay que tener en cuenta que las operaciones de recuperacin es destructiva (elimina el elemento) de la cola, si no es almacenado en otro lugar se destruye. Las colas se utilizan principalmente en las simulaciones, planificacin de sucesos, y los procesos de entrada salida con buffer.

Las colas circulares: No son mas que una variante de las anteriores y su diferencia es que mientras que en las colas lineales es necesario parar el programa cuando se alcanza el limite del array en las circulares, la cola est llena solo cuando el ndice de almacenamiento y el ndice de recuperacin son iguales, en otro caso la cola aun tiene

espacio para almacenar ms datos. Su utilizacin ms comn es en los sistemas operativos en los que la cola circular mantiene la informacin que se lee de archivo y que se escribe en archivo, aplicaciones de tiempo real, etc...

ESPECIFICACIN SEMANTICA Y SINTACTICA.

cola crear () Argumentos: Ninguno. Efecto: Devuelve una cola vaca preparada para ser usada. void destruir (cola C) Argumentos: Una cola C. Efecto: Destruye el objeto C liberando los recursos que mantiene que empleaba. Para volver a usarlo habr que crearlo de nuevo. tElemento frente (cola C) Argumentos: Recibe una cola C no vaca. Efecto: Devuelve el valor del primer elemento de la cola C. Se puede escribir en funcin de las operaciones primitivas de las listas como: ELEMENTO (PRIMERO(C),C). void poner_en_cola (tElemento x, cola C) Argumentos: x: Elemento que queremos insertar en la cola. C: Cola en la que insertamos el elemento x. Efecto: Inserta el elemento x al final de la cola C. En funcin de las operaciones de las listas seria: INSERTA(x,FIN(C),C).

void quitar_de_cola (cola C) Argumentos: Una cola C que debe ser no vaca. Efecto: Suprime el primer elemento de la cola C. En funcin de las operaciones de listas seria: BORRA (PRIMERO(C),C).

int vaca (cola C) Argumentos: Una cola C. Efecto: Devuelve si la cola C es una cola vaca.

Operaciones Bsicas

Crear: se crea la cola vaca. Encolar (aadir, entrar, insertar): se aade un elemento a la cola. Se aade al final de esta. Desencolar (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el primer elemento que entr. Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer elemento que entr.

SINTAXIS
int ContarElementos (Cola & que) { int num_ele; Cola q_aux; Valor x; num_ele = 0; while (!que.ColaVacia () ) { b_aux = que.Desencolar (x); b_aux = q_aux.Encolar (x); num_ele++; } while (!q_aux.ColaVacia () ) { b_aux = q_aux.Desencolar (x); b_aux = que.Encolar (x); } return num_ele; }

PILAS
Una pila es lo contrario de una cola, ya que su acceso es de tipo LIFO, el ltimo que entra es el primero que sale, imaginar un montn de libros unos encima de otros y que para acceder al segundo por arriba primero es necesario coger el primero, su utilizacin principal es para el software de sistemas, compiladores, interpretes. Las dos operaciones bsicas, son las de almacenamiento y la de recuperacin, que se llaman push (la de almacenamiento) y pop (la de recuperacin), para implementar una pila se necesitan las dos operaciones mencionadas con anterioridad y una zona de memoria para utilizarla como pila, se puede utilizar un array, o una zona asignada mediante asignacin dinmica de memoria. Al igual que en las colas, la funcin de recuperacin elimina el valor de la lista, y si este no se almacena en algn lugar, este se destruye. La variable top es el ndice de la siguiente posicin libre de la pila. Cuando se implementan estas funciones, lo ms importante es evitar el desbordamiento de la pila por los dos extremos, si top =0 la pila esta vaca y si top >que la ultima posicin de almacenamiento la pila est llena.

OPERACIONES BSICAS.
Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen aadir ms de uso habitual.

Crear: se crea la pila vaca. (constructor) Tamao: regresa el numero de elementos de la pila. (size) Apilar: se aade un elemento a la pila.(push) Desapilar: se elimina el elemento frontal de la pila.(pop) Cima: devuelve el elemento que esta en la cima de la pila. (top o peek) Vaca: devuelve cierto si la pila est vaca o falso en caso contrario (empty).

CODIFICACIN

#include <stdio.h> #include <stdlib.h>

/* declaracin */ struct tpila{ int clave; struct tpila *sig; }; /* prototipos e implementacin */

void crear(struct tpila **pila); int vacia(struct tpila *pila); void apilar(struct tpila *pila, int elem);void desapilar(struct tpila *pila, int *elem);

void crear(struct tpila **pila) { *pila = (struct tpila *) malloc(sizeof(struct tpila)); (*pila)->sig = NULL; }

int vacia(struct tpila *pila){

return (pila->sig == NULL); }

void apilar(struct tpila *pila, int elem){ struct tpila *nuevo;

nuevo = (struct tpila *) malloc(sizeof(struct tpila)); nuevo->clave = elem; nuevo->sig = pila->sig; pila->sig = nuevo; }

void desapilar(struct tpila *pila, int *elem){ struct tpila *aux;

aux = pila->sig; *elem = aux->clave; pila->sig = aux->sig; free(aux); }

/* programa de prueba */ int main(void) { struct tpila *pila; int elem; crear(&pila);

if (vacia(pila)) printf("nPila vacia!"); apilar(pila, 1); desapilar(pila, &elem); return 0; }

DIFERENCIA ENTRE PILAS Y COLAS.

Una pila se define como una lista o secuencia de elementos que se alarga mediante la colocacin de elementos nuevos "por encima" de los elementos existentes y se acorta a la eliminacin de elementos de la parte superior de los elementos existentes. Se trata de un ADT [Tipo de datos Abstract] con las operaciones matemticas de "push" y "pop".

Una cola es una secuencia de elementos, que se aade a al colocar el nuevo elemento en la parte trasera de existir y acortado por la eliminacin de elementos en frente de la cola. Se trata de un ADT [Tipo de datos Abstract]. No hay ms que estos trminos entendidos en la programacin de Java, C + +, Python y as sucesivamente.

CDIGO DE LISTAS SIMPLES EN C++


#include <iostream> using namespace std; class Nodo { friend class Lista; public: Nodo(int dato, Nodo *siguientePtr) : dato(0), siguientePtr(NULL) { this->dato = dato;

this->siguientePtr = siguientePtr; } int getDato() { return dato; } private: int dato; Nodo *siguientePtr; }; class Lista { typedef Nodo *ptrNodo; public: Lista() : primeroPtr(NULL), ultimoPtr(NULL) { // cuerpo vacio } ~Lista() { if(!estaVacia()) { ptrNodo actualPtr; ptrNodo tempPtr; cout << "Destruyendo nodos..." << endl; actualPtr = primeroPtr; while(actualPtr != NULL) { tempPtr = actualPtr; cout << "-" << tempPtr->dato << endl; actualPtr = actualPtr->siguientePtr; delete tempPtr; } } cout << "Se destruyeron todos los nodos." << endl; } void insertarAlFrente(const int valor) { ptrNodo nuevoPtr; nuevoPtr = getNuevoNodo(valor); if(estaVacia()) { primeroPtr = ultimoPtr = nuevoPtr; } else { nuevoPtr->siguientePtr = primeroPtr; primeroPtr = nuevoPtr;

} } void insertarAlFinal(const int valor) { ptrNodo nuevoPtr; nuevoPtr = getNuevoNodo(valor); if(estaVacia()) { primeroPtr = ultimoPtr = nuevoPtr; } else { ultimoPtr->siguientePtr = nuevoPtr; ultimoPtr = nuevoPtr; } } bool eliminarDelFrente(int valor) { if(estaVacia()) { return false; } else { ptrNodo tempPtr; tempPtr = primeroPtr; if(primeroPtr == ultimoPtr) { primeroPtr = ultimoPtr = NULL; } else { primeroPtr = primeroPtr->siguientePtr; } valor = tempPtr->dato; delete tempPtr; return true; } } bool eliminarDelFinal(int valor) { if(estaVacia()) { return false; } else { ptrNodo tempPtr; tempPtr = ultimoPtr; if(primeroPtr == ultimoPtr) { primeroPtr = ultimoPtr = NULL; } else { ptrNodo actualPtr; actualPtr = primeroPtr; while(actualPtr->siguientePtr != ultimoPtr) { actualPtr = actualPtr->siguientePtr; }

ultimoPtr = actualPtr; actualPtr->siguientePtr = NULL; } valor = tempPtr->dato; delete tempPtr; return true; } } bool estaVacia() { return primeroPtr == NULL; } void imprimir() { if(estaVacia()) { cout << "La lista esta vacia." << endl; } else { ptrNodo actualPtr; actualPtr = primeroPtr; while(actualPtr != NULL) { cout << actualPtr->dato << "-> "; actualPtr = actualPtr->siguientePtr; } cout << endl; } } private: ptrNodo primeroPtr; ptrNodo ultimoPtr; // funcion utilitaria para asignar un nuevo nodo. Nodo *getNuevoNodo(int valor) { ptrNodo siguientePtr; return new Nodo(valor, siguientePtr = NULL); } }; int main() { Lista lista; lista.imprimir(); cout << endl; cout << "Insertando elementos." << endl; for(int i = 1; i <= 5; i++) { lista.insertarAlFinal(i);

lista.imprimir(); } cout << endl; lista.insertarAlFrente(8); cout << "Insertando el 8 al frente" << endl; lista.imprimir(); cout << endl; lista.eliminarDelFinal(5); cout << "Eliminando 5 del final" << endl; lista.imprimir(); cout << endl; lista.insertarAlFinal(9); cout << "Insertando el 9 al final" << endl; lista.imprimir(); cout << endl; lista.eliminarDelFrente(8); cout << "Eliminando 8 del frente" << endl; lista.imprimir(); cout << endl; cin.get(); return 0; }

La lista esta vacia. Insertando elementos. 1-> 1-> 2-> 1-> 2-> 3-> 1-> 2-> 3-> 4-> 1-> 2-> 3-> 4-> 5-> Insertando el 8 al frente 8-> 1-> 2-> 3-> 4-> 5->

Eliminando 5 del final 8-> 1-> 2-> 3-> 4-> Insertando el 9 al final 8-> 1-> 2-> 3-> 4-> 9-> Eliminando 8 del frente 1-> 2-> 3-> 4-> 9->

TAREA #13

CDIGO DEL DEBER


#include<conio.h> #include<stdlib.h> #include<stdio.h> typedef struct _cola{ char cedula[50]; char nombre[60]; char apellido[50]; struct _cola *sig; }tipocola; typedef tipocola *cola; typedef tipocola *pnodo; void encolar (cola *p, cola *u,char ci[], char nom[], char ape[]); char desencolar (cola *p, cola *u); void main () { cola cop=NULL, cou=NULL; char ca;

int op; do { clrscr(); printf("\n**********///////// MENU DE COLA....//////////************* "); printf("\n1. encolar alumno.... "); printf("\n2. desencolar alumno.... "); printf("\n3. salir"); printf("\n DIGITE SU OPCION .... "); scanf("%d",&op); if (op==1) { printf("ingrese el caracter "); fflush(stdin); scanf("%c",ca); encolar(&cop, &cou, ca); getch(); } if (op==2) { printf("Elemento desencolado:%c", desencolar(&cop, &cou)); getch(); } } while(op!=3); } void encolar (cola *p, cola *u,char ci[], char nom[],char ape[]) { pnodo nuevo; nuevo=(pnodo) malloc (sizeof(tipocola)) nuevo-> cedula= ci; nuevo-> nombre= nom;

nuevo-> apellido= ape; nuevo->sig=NULL; if (! *p) { *p=nuevo; } if(*u) { (*u)->sig=nuevo; } *u=nuevo; } char desencolar (cola *p, cola *u) { char r=' '; char s=' '; char t=' '; pnodo aux; if (!*p) { printf ("\n cola vacia"); getch(); } else { aux=*p; r=aux->sig; s=aux->cedula; t=aux->nombre; *p=aux->apellido; if(!*p) {

*u = NULL; } free(aux); } return (r); };

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

SECCIN ABIERTA (TRABAJOS INTRA Y EXTRA CLASES)

REFLEXIN:
Trabajando en los deberes de la materia de estructura de datos ya q para su acreditacin se necesita practicar y realizar todas las tareas y trabajos enviados por el docente.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

ARTCULOS DE REVISTAS

REFEXION:
Esta asignatura es de carcter terico prctico. Se encuentra dentro del rea de Formacin Profesional especializada, Sub rea de Informtica. Tiene como propsito que el alumno domine las tcnicas y algoritmos ms eficientes para la solucin de mltiples problemas del mundo real, a travs de tcnicas como: diagramas de flujo, ejercicios estructurados. Los tpicos a tratar son: repetitivos, bsqueda y ordenacin en una estructura y tipos abstractos de datos.

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

Anexos

CDIGO DEL EXAMEN


#include<conio.h> #include<stdio.h> #include<stdlib.h> typedef struct cuenta{ long int n_cuenta; char cliente[100]; long int cedula; char telfono[30]; char domicilio[60]; char estadocivil[50]; struct cuenta *sig; }_cuenta; typedef struct transacciones{ char fecha[20]; char tipotransaccion[100]; int monto; struct transacciones *sig; }_transaccion; typedef _cuenta pnodo; // inicializacion del nodo typedef _cuenta colas; // inicializacion de la cola //typedef _transaccion colas; int encolar(colas *p, colas *u,long int n_cta,char cli[],long int ced,char tel[], char dom[], char estcil[],int mon, char titras[], char fec[]); void desencolar(colas *p, colas *u); void main() { //colas elemento; int op,mon; long int n_cta, ced; char cli,tel,dom,estcil,tiptrans,fec; do { printf("**************************************"); printf("\n*********MENU BANCARIO**************"); printf("**************************************"); printf("\n1.- APERTURA DE CUENTA"); printf("\n2.- TIPO DE TRANSACCION"); printf("\n3.- CONSULTAS DE SALDO");

printf("\n4.- INACTIVAR CUENTA"); printf("\n5.- REACTIVAR CUENTA"); printf("\n6.- SALIR"); scanf("%d",&op); } if (op==1) { printf("\n*****APERTURA DE CUENTA BANCARIA******\n"); printf("\n ingrese nombre "); fflush(stdin); scanf("%c",&cli); printf("\n ingrese cedula "); fflush(stdin); scanf("%ld",&ced); printf("\n ingrese domicilio "); fflush(stdin); scanf("%c",&dom); printf("\n ingrese telefono "); fflush(stdin); scanf("%c",&tel); printf("\n ingrese cuanta"); fflush(stdin); scanf("%d",&mon); getch(); printf("\n ingrese un monto para poder abrir su cuenta\n"); scanf("%d",&mon); while(mon=>150) { printf("\nSE ABRIO CON EXITO SU CUENTA"); } printf("\n su monto no es el indicado para abrir su cuenta"); } else if (op==2) { int opc; printf("\n*******ESCOJA UNOS DE LOS TIPO DE TRANSACCION*******"); printf("\n1.- DEPOSITO"); printf("\n2.- RETIROS "); scanf("%d",&opc); if(opc==1) { printf("\n******DEPOSITOS BANCARIOS**********") ; printf("\n ingrese el numero de cuenta ");fflush(stdin); scanf("%ld",&n_cta); printf("\n ingrese el monto a depositar "); fflush(stdin); scanf("%d",&mon); printf("\n la fecha del deposito es: ") ; scanf("%c",&fec); } else if (opc==2) { printf("\n*******RETIROS BANCARIOS***********"); printf("\n ingrese numero de cuenta "); fflush(stdin); scanf("%ld",&n_cta);

printf("\n ingrese el monto a retirar "); fflush(stdin); scanf("%c",&mon); printf("\n la fecha del retiro es: ") ; scanf("%c",&fec); } else if (op==3) { printf("\n******CONSULTA DE SALDO BANCARIOS**********"); printf("\ningrese el numero de cuenta "); fflush(stdin); scanf("%ld",&n_cta); if(mon==0) { printf("\n su estado es inactivo"); } printf("su cuenta esta activa:"); printf("\n su saldo es de: "); scanf("%d",&mon); } else if (op==4) { printf("\n*******INACTIVAR CUENTA BANCARIAS***********"); } else if (op==5) { printf("\n*******REACTIVAR CUENTAS BANCARIAS**********"); if(mon=>20) printf("su cuenta esta reactiva"); } printf("su cuanta esta inactiva xq su valor de reactivacion es muy poco"); }while(op!=6); } int encolar(colas *p, colas *u,long int n_cta,char cli[],long int ced,char tel[], char dom[], char estcil[],int mon, char titras[], char fec[]) { pnodo nuevo; nuevo=(pnodo)malloc(sizeof(_cuenta)) nuevo->n_cuenta=n_cta nuevo->cliente=cli nuevo->cedula=ced nuevo->telefono=tel nuevo->domicilio=dom nuevo->estadocivil=estcil

nuevo=(pnodo)malloc(sizeof(_transaccion)); nuevo->monto=mon nuevo->tipotransaccion=titras nuevo->fecha=fec *p->sig=nuevo; *u=nuevo; } void desencolar(colas *p, colas *u) { pnodo aux; if(!*p) { printf("\n cola vacia....."); } }

UNIVERSIDAD TCNICA DE MANAB FACULTAD DE CIENCIAS INFORMTICAS CARRERA DE INGENIERA DE SISTEMAS INFORMTICOS

RESUMEN DE CIERRE
Durante el curso. Estructura de dato pude adquirir las destrezas de conocimiento, y aptitud de echarles muchas ganas a la programacin las cuales son importantes para mi desempeo como profesional. De los trabajos asignados en el curso, las presentaciones orales fueron de gran ayuda para mejorar en forma continua la comunicacin efectiva frente a los otros equipos.

You might also like