portafolio de estructura

UNIVERSIDAD TÉCNICA DE MANABÍ

FACULTAD DE CIENCIAS INFORMÁTICAS

CARRERA DE INGENIERÍA EN SISTEMAS INFORMÁTIVOS

POTAFOLIO DE ESTRUCTURA DE DATO SEGUNDO SEMESTRE DE CARRERA

2DO”C”

AUTOR:

PAREDES BRAVO JONATHAN ANDRÉS

DOCENTE:

ING. CHRISTIAN TORRES.

PORTOVIEJO, NOVIEMBRE DEL 20012

PERÍODO ACADÉMICO:

SEPTIEMBRE 2012-FEBRERO 2013

FACULTAD DE CIENCIAS INFORMATICAS

Misión:

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

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

actividades, protagonistas del progreso regional y nacional.

Visión:

Formar profesionales eficientes e innovadores en el campo

de las ciencias informáticas, que con honestidad, equidad y

solidaridad, den respuestas a las necesidades de la sociedad

elevando su nivel de vida.

UNIVERSIDAD TÉCNICA DE MANABI

Misión:

Formar académicos, científicos y profesionales responsables, humanistas, éticos y solidarios, comprometidos con los objetivos del desarrollo nacional, que contribuyan a la solución de los problemas del país como universidad de docencia con investigación, capaces de generar y aplicar nuevos conocimientos, fomentando la promoción y difusión de los saberes y las culturas, previstos en la Constitución de la República del Ecuador.

Visión:

Ser institución universitaria, líder y referente de la educación superior en el Ecuador, promoviendo la creación, desarrollo, transmisión y difusión de la ciencia, la técnica y la cultura, con reconocimiento social y proyección regional y mundial.

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

CARRERA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS

ÍNDICE DE CONTENIDOS

Syllabus

Prontuario del curso

Carta de presentación

Autorretrato

Diario meta cognitivo

Artículos de revistas profesionales

Trabajo de ejecución

Tereas

Materiales relacionados con la clase.

Anexos

Resumen de cierre


SYLLABUS

Asignatura: Estructura de Datos. 1.- Datos Generales: Unidad Académica: Facultad de Ciencias Informáticas. Carrera: Ingeniería en Sistemas Informáticos. Ciclo Académico: septiembre 2012- febrero 2013. Nivel o Semestre: Segundo Nivel. Área de Competencia: Software. Tipo de Asignatura: Obligatoria de Carrera. Código: OC-0201. Requisito para: OC-0301. Pre-requisitos: OC-0100. Co-requisitos: N° de Créditos: 5 N° de Horas: 80 Docente Responsable: Ing. Christian Ronald Torres Morán. Correo Electrónico del Docente Responsable: [email protected] 2.- Descripción de la Asignatura La materia introduce al estudiante a los conceptos y aplicación en la administración de memoria, aplicando programación estructurada y orientada a objetos, permite conocer la estructura básica operacional de la memoria RAM y de los grandes diseños de software, aplicando C++ el estudiante desarrollará proyectos científicos tanto con interfaces en modo gráfico y en modo texto, tomando como referencia aplicaciones en el campo general de otras carreras. 3.- Objetivo General de la Asignatura Capacitar al estudiante con los conocimientos significativos en administración de memoria dinámica y herramientas útiles en los diseños, construcciones y usos principales de algoritmos en la estructuración de datos lineales y no lineales.

4.- Competencias Específicas del Perfil del Graduado Objetivos Educacionales de la Facultad de Ciencias Informáticas

Carrera de Ingeniería de Sistemas Informáticos

1. Aplica las ciencias básicas y las matemáticas en la solución de problemas del entorno. 2. Toma decisiones que ayudan a desarrollar organizaciones proactivas que contribuyen al buen vivir. 3. Construye soluciones informáticas de calidad que mejoren la eficiencia y eficacia de una organización haciendo uso correcto de la tecnología. 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 tecnológicos en el desempeño de su profesión.

1 2 3 4 5 6

x x

5.- Resultados del Aprendizaje

Resultados del Aprendizaje

METODOLOGÍA DE EVALUACIÓN DE LOS RESULTADOS DE APRENDIZAJE

Nivel de aprendizaje

Método de Evaluación

Criterios

Niveles del Resultado de Aprendizaje

Ponderación

Identificar los Tipos estructurados de datos estáticos y dinámicos empleados en la creación de aplicaciones, considerando los lenguajes de programación

Conocimiento.

Un Ejercicio Práctico problema del medio.

Descripción de la

definición de la Estructura de datos.

Descripción de las tres capas de la estructura de datos.

Descripción de la introducción de forma clara.

Descripción del contenido con ideas que tengan relación, claridad y objetividad con el tema.

Descripción de la conclusión en forma clara y con aporte personal.

Identificación de 4 tipos de datos estructurados. Implementación de código de extensión .cpp Diferenciación del uso de tipos de datos estructurados estáticos frente a los tipos de datos estructurados dinámicos.

Describirá la definición

de la estructura de datos, los tipos de datos imples, básicos y compuestos en un ensayo técnico con: descripción general del tema clara; ideas que tienen relación, claridad y objetividad con el tema; y una conclusión clara con aporte personal.

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

Describirá la definición de la estructura de datos, los tipos de datos simples, básicos y compuestos en un ensayo técnico con: descripción general del tema confusa; poca o ninguna idea que tienen relación, claridad y objetividad con el tema; y una conclusión confusa sin aporte personal.

Alto (100 puntos)

Medio (70 puntos)

Básico (50 punto)

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

Aplicación

Cuadro comparativo. Trabajo en equipo.

Comparación de

3 semejanzas entre los tipos de datos que permiten almacenar más de un dato: Array de una dimensión, array de 2 dimensiones, array de múltiples dimensiones.

Relaciones de las comparaciones con ideas claras.

Comparará con la

utilización de un cuadro comparativo 3 semejanzas y 3 diferencias entre los tipos de datos que permiten almacenar más de un dato; reflejando las relaciones de las comparaciones con ideas claras.

Comparará con la utilización de un cuadro comparativo 3 semejanzas y 3 diferencias entre los tipos de datos que permiten almacenar más de un dato; reflejando las relaciones de las comparaciones con ideas pocos claras.

Comparará con la utilización de un cuadro comparativo 2 semejanzas y 2 diferencias entre los tipos de datos que permiten almacenar más de un dato; reflejando las relaciones de las comparaciones con ideas confusas.

Alto

(100 puntos)

Medio (70 puntos)

Básico (50 punto)

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

Aplicación

Trabajo en Equipo dentro de laboratorio.

Aplicación dinámica empleando estructuras lineales para manejo de información

Descripción de las estructuras enlazadas doblemente.

Descripción general.

Descripción de Abiertas y Cerradas

Implementará

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

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

Implementará aplicaciones dinámicas de estructura No Lineal, almacenamiento y recuperación de los mismos en unidades de almacenamiento

Alto (100 puntos)

Medio (70 puntos)

Básico (50 punto)

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

Aplicación

Informe. Trabajo en equipo.

Aplicación

dinámica empleando estructuras no lineales para manejo de información

con estructuras dinámicas no lineales bien detallado.

con estructuras dinámicas no lineales con poca claridad.

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

Alto

(100 puntos)

Medio (70 puntos)

Básico (50 punto)

Organizar la información en algoritmos y estructuras AVL y su relación con los gestores de Base de Datos

Aplicación .

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)

Básico (50 punto)

1.1 Resultados de aprendizaje de la carrera específicos a los que apunta la materia (ABET).

Resultados de aprendizaje de la carrera de Ingeniería de Sistemas Informáticos a. Capacidad de realizar análisis, síntesis y aplicación de las matemáticas y ciencias básicas en la solución de problemas de ingeniería en sistemas informáticos. b. Capacidad de planificar, diseñar, conducir e interpretar resultados de experimentos orientados a la informática. c. La capacidad de diseñar sistemas, procesos, modelos y componentes informáticos que cumplan los estándares nacionales o internacionales, tomando en cuenta las limitaciones económicas, ambientales, sociales, políticas, de salud y seguridad del entorno, y cumpliendo satisfactoriamente con las especificaciones y restricciones existentes o indicadas por los interesados o por los criterios de sostenibilidad. d. Capacidad para funcionar como parte de un equipo de profesionales de distintas áreas del conocimiento, demostrando una efectiva cooperación, comunicación, con habilidades para resolver conflictos y contribuyendo proactivamente en la propuesta de líneas estratégicas desde el punto de vista informático, para la solución de problemas. e. Capacidad para identificar, formular, evaluar y resolver técnicamente problemas de ingeniería planteados de acuerdo a las necesidades del medio. f. Capacidad para comprender, reconocer y aplicar valores y códigos de ética profesional, que le permitan desenvolverse sin perjudicar a sus clientes y contribuyendo al desarrollo de la sociedad. g. Habilidad para presentar efectivamente, ideas, proyectos, informes de investigaciones, documentos de trabajo de manera escrita, oral y digital, utilizando las herramientas de las nuevas tecnologías de la información. h. Habilidad y capacidad para comprender el impacto de las soluciones informáticas a la realidad local, nacional e internacional en un contexto económico global, ambiental y social. i. Habilidad y aptitud para ser un profesional con el compromiso del aprendizaje continuo, con capacidad para reconocer las oportunidades para mejorar en su campo profesional j. Habilidad para identificar temas y problemas de actualidad con respecto al entorno local, regional y global, con el fin de relacionarlos con propuestas de soluciones creativas y eficientes.

k. Capacidad y destreza para utilizar técnicas, habilidades y herramientas en el desarrollo de software y hardware para implementar soluciones a problemas de su profesión. Contribución de la materia a los resultados de aprendizaje de la carrera:

A: Alta M: Medio B: Baja

A B C D E F G H I J k

M M B B B B B

6.- Programación

1. Resultado del Aprendizaje: Identificar los tipos estructurados de datos estáticos y dinámicos empleados

en la creación de aplicaciones, considerando los lenguajes de programación

Fechas

No. de

Horas

Temas

Estrategias

metodológicas

Recursos

Bibliografía

18/04/2012 18/04/2012 21/04/2012 21/04/2012 25/04/2012 28/04/2012 28/04/2012 02/05/2012 05/05/2012 05/05/2012 09/05/2012 09/05/2012 12/05/2012 12/05/2012 16/05/2012 16/05/2012 19/05/2012

TOTAL 23

1 2 2 3 2 3 3 2 2 1 2

Generalidades y definiciones de Estructura de Datos

datos.

datos.

de Datos (Estáticas)

ras de Datos

Estática y Dinámica

punteros

memoria

memoria

de punteros

Experiencia:

Aplicando lluvia de ideas concretar conocimientos relativo a la memoria y sus diferentes importancias en el funcionamiento del computador Reflexión:

En equipos de trabajo, analizar el funcionamiento general del computador y de los programas, considerando las siguientes aplicaciones: Procesadores de texto, Hojas de cálculo, Reproductores, Tareas del sistema operativo como Impresión, etc. Conceptualización:

conceptuales, cuadros de funcionamiento y estructurales de la memoria. Aplicación:

solución de ejercicios demostrativos y de planteamiento de problemas.

Computador Proyector Dispositivos de Almacenamiento rápido. Pizarra de tiza Liquida Marcadores Bibliografía recomendada y referencias en el Internet

Estructura de Programación en C. PrisHard. www.prishard.com » Folleto elaborado por el docente, páginas iníciales

2. Resultado del Aprendizaje: Elaborar aplicaciones dinámicas de estructura lineal, almacenamiento y

recuperación de los mismos en unidades de almacenamiento, aplicarán soluciones de administración de memoria mediante el desarrollo de aplicaciones científicas y comerciales. 19/05/2012 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 09/06/2012 13/06/2012 16/06/2012 16/06/2012 16/06/2012 20/06/2012 20/06/2012 23/06/2012

TOTAL

30

1

2

1 1 2 2 1 5

2

2

1 1 2

2

Estructuras simples y Compuestas

Listas Abiertas Definición de listas abiertas Declaración e implementación de una lista Operaciones con Listas Inserción de un nodo Búsqueda de un nodo Recorridos de una lista Eliminación de un nodo Listas y Archivos Variaciones de listas Pilas y Colas Listas circulares o cerradas Declaración e implementación de una lista circular Operaciones con Listas Inserción de un nodo Búsqueda de un nodo Recorridos de una lista Eliminación de un nodo Listas doblemente enlazadas abiertas y cerradas Declaración e

Experiencia:

concretar conocimientos relativo a problemas informáticos planteados Reflexión:

En grupos de trabajo, analizar el funcionamiento general de los diferentes algoritmos considerando las diferentes aplicaciones. Conceptualización:

conclusiones conceptuales, cuadros de funcionamiento y alternativas estructurales de solución. Aplicación:

Resolución de ejercicios demostrativos y de planteamiento de problemas.

Computador Proyector Dispositivos de Almacenamiento rápido. Pizarra de tiza liquida Marcadores Bibliografía recomendada y referencias en el Internet

Estructura de Datos, Referencia practica con objetos orientados a objetos, Román Martínez Elda Quiroga, Pág. 56,57,58,81 Folleto elaborado por el docente

23/06/2012 04/07/2012 04/06/2012 07/07/2012

2 1 1 1

implementación de una lista doblemente enlazada Operaciones con Listas Inserción de un nodo Búsqueda de un nodo Recorridos de una lista Eliminación de un nodo

3. Resultado del Aprendizaje: Elaborar aplicaciones dinámicas de estructura no lineal, almacenamiento y recuperación de los mismos en unidades de almacenamiento, aplicarán soluciones de administración de memoria mediante el desarrollo de aplicaciones científicas y comerciales. 07/07/2012 11/07/2012 14/07/2012 14/07/2012 13/07/2012 18/07/2012 18/07/2012 21/07/2012 21/07/2012

TOTAL

13

2

3

1 1 1

1

1

1

Estructuras arborescentes

Definición, implementación Tipos de recorridos: PreOrden InOrden PostOrden Operaciones con Árboles Binarios de Búsqueda Búsqueda de elementos. Inserción de elementos. Borrado de elementos. * Nodo hoja. *Nodo rama.

Movimiento a través del árbol. Comprobación de árboles vacíos. Comprobación del nodo hoja.

Experiencia:

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. Reflexión:

analizar el funcionamiento general de los principales sistemas informáticos, considerando el avance tecnológico del software en la base de datos Conceptualización:

propuestas algorítmicas, prácticas y de alternativas de resolución.

Computador

Proyector

Pizarra de tiza Liquida

Marcadores

Texto de

apoyo y/o

diapositivas

Estructura de

Datos, Referencia

practica con objetos

orientados a objetos, Román

Martínez Elda Quiroga, Pág.

115-131

Folleto proporcionado por el profesor

21/07/2012 25/07/2012

1

1

Cálculo de: *Número de nodos. *Altura del árbol. *Altura de un nodo. Árboles degenerados.

Aplicación:

demostrativos y de planteamiento de problemas.

4. Resultado del Aprendizaje: Organizar la información en algoritmos y estructuras AVL y su relación con los gestores de Base de Datos

25/07/2012 28/07/2012 28/07/2012 28/07/2012 01/08/2012 01/08/2012 04/08/2012 04/08/2012 04/08/2012 08/08/2012 08/08/2012 11/08/2012 11/08/2012

TOTAL

14

2

1 1

1 1

1

1

1

1

2

2

Tipos de árboles especiales Árboles equilibrados. Definición Operaciones en AVL. Factor de equilibrio. Rotación simple de nodos. Rotación simple a la derecha. Rotación simple a la izquierda. Rotación doble de nodos a la derecha. Rotación doble de nodos s la izquierda. Requilibrados de árboles AVL. Reequilibrados en árboles AVL por inserción de un nodo. Reequilibrados en árboles AVL por borrado de un nodo.

Experiencia:

planteamiento de problemas, identificar dificultades y generar la necesidad de encontrar soluciones algorítmicas. Reflexión:

analizar el funcionamiento de los diferentes algoritmos propuestos. Conceptualización:

laboración de propuestas de funcionamiento y alternativas estructurales de solución. Aplicación:

demostrativos y de planteamiento de problemas.

Computador

Proyector

Pizarra de tiza liquida

Marcadores

Texto de apoyo

y/o diapositivas

Estructura de

Datos, Referencia

practica con objetos

orientados a objetos, Román

Martínez Elda Quiroga, Pàg.

137-161

Folleto proporcionado por el profesor

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 ocasión se aceptará el

retraso de 10 minutos. El docente asistirá igualmente con toda puntualidad a las actividades establecidas y los

estudiantes esperaran 10 minutos después 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 obligación de recuperar estas horas.

El estudiante deberá justificar al docente sus inasistencias o atraso, independiente de la justificación reglamentaria.

El estudiante por ningún 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 calificación de cero y no habrá oportunidad de recuperación 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 aceptarán 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 párrafo de un texto se calificará con 0.

8.- Parámetros para la Evaluación de los Aprendizajes.

Primera Evaluación

Segunda Evaluación

N.. Evaluación

Exámenes 15% 15% 30%

Lecciones 5% 5% 10%

Tareas 2.5% 2.5% 5%

Proyectos 10% 10% 20%

Informes de investigación

15% 15% 30%

Participación en clase 2.5% 2.5% 5%

TOTAL 50% 50% 100%

9.- Bibliografía Básica: Autor: Román Martínez Libro: Estructura de Datos, Referencia practica con objetos orientados a objetos Edición: Séptima. Editorial: Elda Quiroga, 2008.

Complementaria: Autor: Docente Estructura de Datos Página 8 Libro: Manuales e instructivos preparado para los estudiantes. Edición: Primera. Editorial: Libre.

10.- Revisión y Aprobación

DOCENTE RESPONSABLE DIRECTOR (A) DE CARRERA

PRESIDENTE (A) COMISIÓN ACADÉMICA

Firma: Ing. Christian Ronald Torres Morán

Firma:

Firma:

Fecha: Fecha: Fecha:



PRONTUARIO

I. INFORMACIÓN GENERAL

Programa Codificación del curso: Título del curso: estructura de dato Número créditos: cinco (5) créditos Total de Horas del Curso: 80 horas

II. DESCRIPCIÓN DEL CURSO

La materia introduce al estudiante a los conceptos y aplicación en la administración de memoria, aplicando programación estructurada y orientada a objetos, permite conocer la estructura básica operacional de la memoria RAM y de los grandes diseños de software, aplicando C++ el estudiante desarrollará proyectos científicos tanto con interfaces en modo gráfico y en modo texto, tomando como Referencia aplicaciones en el campo general de otras carreras.



CARTA DE PRESENTACIÓN

Este portafolio presenta mi trayectoria en el curso de:

ESTRUCTURA DE DATO, este curso tuvo como objetivos desarrollar las destrezas de.

Las habilidades y agilidad. Durante este parcial pude conocer sobre. Las estructura

anidadas, funciones, punteros, listas simples, pilas, y colas.

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

profesional de la Informática.

Las áreas más dificultosas del curso fueron:

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




AUTORRETRATO

Mi nombre es Paredes Bravo Jonathan Andrés. Soy estudiante de la

asignatura de ESTRUCTURA DE DATO, actualmente curso el segundo

semestre en la Facultad de Ciencias Informáticas de la Universidad Técnica

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

en equipo.

Mis metas son convertirme en un profesional de la Ingeniería en Sistemas

Informáticos.




CLASE#1:

FECHA:26 de septiembre del 2012

TEMA: Aplicación de la programación básica

INTRODUCCION

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

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 AÑOS DE EDAD",curso3.nom,curso3.edad); getch(); }




CLASE #2:

FECHA: 27 de septiembre del 2012

TEMA: creación de una estructura básica

Sintaxis etiqueta, {} , ;

Creación 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 estático (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 información {

char nombre[50];

char dirección[50];

char ruc[13];

char teléfono[18];

}empre;

struct proveedor_ {

char ruc [13];

char nombre[40];


char teléfono[18];

char ciudad[20];

} proveedor;

struct cliente_ {

char nombre[50];

char cedula[10];


}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 ruc[15];

};

struct information {

struct dato dato;

char teléfono[18];

};

struct proveedor_ {

struct datos dato;

char teléfono[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);

}




CLASE #3:

FECHA: 03 de octubre del 2012

TEMA: inicialización de una variable estructurada

INICIALIZACIÓN 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 declaración. En el ejemplo de

la parte inferior se ve todo esto más claramente.

EJERCICIO DE INICIALIZACIÓN 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 AÑO 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.




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;


};

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:




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 función. La instrucción RETURN es quien regresa un y solo un dato a la parte del programa que la esté llamando o invocando, sin embargo es de considerar que return puede regresar un dato, una variable o una expresión algebraica(no ecuación o formula) como lo muestran los siguientes ejemplos; a) return 3.1416;

b) return area;

c) return x + 15/2; La lista de parametros formales es una lista de variables separadas por comas (,) que almacenaran los valores que reciba la funcion, estas variables actúan como locales dentro del cuerpo de la funcion.

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{


int nproveedores;

int nclientes;

int productos;


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


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


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("\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:




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


scanf("%d",&op);

if(op==1)

{

clrscr();


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



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



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:




CLASE#7:

FECHA: 24 de octubre del 2012 TEMA: listas simples

Definición

La forma más simple de estructura dinámica es la lista abierta. En esta forma los nodos se organizan de

modo que cada uno apunta al siguiente, y el último no apunta a nada, es decir, el puntero del nodo

siguiente vale NULL.

En las listas abiertas existe un nodo especial: el primero. Normalmente diremos que nuestra lista es un

puntero a ese primer nodo y llamaremos a ese nodo la cabeza de la lista. Eso es porque mediante ese

único puntero podemos acceder a toda la lista.

Cuando el puntero que usamos para acceder a la lista vale NULL, diremos que la lista está vacía.

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

struct nodo {

int dato;

struct nodo *siguiente;

};

Normalmente se definen varios tipos que facilitan el manejo de las listas, en C, la declaración de tipos puede tener una forma parecida a esta:

typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Lista;

tipoNodo es el tipo para declarar nodos, evidentemente.

pNodo es el tipo para declarar punteros a un nodo.

Lista es el tipo para declarar listas, como puede verse, un puntero a un nodo y una lista son la misma cosa. En realidad, cualquier puntero a un nodo es una lista, cuyo primer elemento es el nodo apuntado.

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("\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","[email protected]",27); ingresar(amigo2,"carlos","macias","052777665","[email protected]",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:




CLASE#8:


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","[email protected]",27);

ingresar(&la,"Carlos","Macias","052777665","[email protected]",30);

ingresar(&la,"Marcos","Macias","254346","[email protected],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>


char nombre[25];

char apellido[25];

char fono[18];

char correo[40];

int edad ;

struct agenda *sig;

}_agenda;



void ingresar (lista *l, char nom[], char ape[], char fon[], char cor[],int e);


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","[email protected]",27);

ingresar(&la,"Carlos","Macias","052777665","[email protected]",30);

ingresar(&la,"Marcos","Macias","254346","[email protected],ec",40);

mostrar(la); */

getch();

}

void ingresar (lista *l, char nom[],char ape[],char fon[], char cor[],int e)

{ pnodo nodo;






nodo->edad=e ;

//nodo->sig=NULL;

nodo->sig=*l; // paso 1

*l=nodo; // paso 2

}


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




CLASE#9:


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","[email protected]",20); ingresarINI(&La,"Martha","Vallejo","2639070","[email protected]",23); ingresarINI(&La,"Luis","Moreira","2639714","[email protected]",30); ingresarINI(&La,"Andrea","Romero","2315025","[email protected]",19); } else {ingresarFIN(&La,"Carlos","Navia","2451201","[email protected]",20); ingresarFIN(&La,"Martha","Vallejo","2639070","[email protected]",23); ingresarFIN(&La,"Luis","Moreira","2639714","[email protected]",30); ingresarFIN(&La,"Andrea","Romero","2315025","[email protected]",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:




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>


char nombre[25];

char apellido[25];

char fono[18];

char correo[40];

int edad ;

struct agenda *sig;

}_agenda;



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 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","[email protected]",20);

ingresarINI(&la,"Kerly","Velez","236523","[email protected]",18);

ingresarINI(&la,"Cristina","Alcivar","145658","[email protected]",19);

}

else

{

ingresarFIN(&la,"Mario","Mendoza","254125","[email protected]",20);

ingresarFIN(&la,"Kerly","Velez","236523","[email protected]",18);

ingresarFIN(&la,"Cristina","Alcivar","145658","[email protected]",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;


//ALMACENAR LA INFORMACION AL NODO





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;


//ALMACENAR LA INFORMACION AL NODO





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

}


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




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 información: Debemos pensar en una función buscar que localice a un nodos con una información que no se repita... pensando un poco podemos creer que la información puede contener nombre o apellidos de igual valor.. Pero el valor de cedula no es un dato que se repita. Si cambiamos la función

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 función solo generar 2 estados

1. Si existe =1

2. No existe =0

Al emplearlo podíamos emplear en las funciones de ingreso de la siguiente forma:

La función verificarxceula antes de crear el espacio de memoria con malloc

Observen que la funcion fue diseñada 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 desplazándola y poder tomar la dirección de ese primer nodo <<El que se va a eliminar>>

Teniendo la siguiente función:

void eliminar_all(Lista *l)

{pnodo aux;

while(*l)

{aux=*l;

*l=aux->sig;

free(aux);

}

}

ELIMINAR UN NODO ESPECÍFICO

Asumimos eliminar nodos de un empleado

Tendríamos 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);

} } } }




CLASE#12:

FECHA: 8 de noviembre del 2012 TEMA: ejercicio de eliminar

EJERCICIO

ELIMINAR TODOS LOS NODOS QUE COINCIDEN CON UN CRITERIO

Podríamos usar el código de la funcion de eliminar un nodo especifico, pero debemos procurar realizar nuestra operación 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);

}




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) Definición:

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:




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:




CLASE#15:

FECHA: 21 de noviembre del 2012 TEMA: colas

DEFINICIÓN

Una cola es un tipo especial de lista abierta en la que sólo se pueden insertar nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el otro. Además, como sucede con las pilas, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.

Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir.

El símil cotidiano es una cola para comprar, por ejemplo, las entradas del cine. Los nuevos compradores sólo pueden colocarse al final de la cola, y sólo el primero de la cola puede comprar la entrada.

El nodo típico para construir pilas es el mismo que vimos en los capítulos anteriores para la construcción de listas y pilas:

struct nodo {

int dato;


};

Declaraciones de tipos para manejar colas en C

^

Los tipos que definiremos normalmente para manejar colas serán casi los mismos que para manejar listas y pilas, tan sólo cambiaremos algunos nombres:

http://c.conclase.net/edd/index.php?cap=003#inicio

typedef struct _nodo {

int dato;

struct _nodo *siguiente;

} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *Cola;



Cola es el tipo para declarar colas.

Cola

Es evidente, a la vista del gráfico, 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. Además, debido al funcionamiento de las colas, también 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 más fácil será insertar nodos por el final, a continuación 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:




CLASE#16:

FECHA: 22 de noviembre del 2012 TEMA: lista simples cerradas

DEFINICIÓN

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 añade un nodo especial de cabecera, de ese modo se evita la única excepción posible, la de que la lista esté vacía.

El nodo típico es el mismo que para construir listas abiertas:

struct nodo {

int dato;


};

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;



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

Por ese motivo se suele resaltar un nodo en particular, que no tiene por qué ser siempre el mismo. Cualquier nodo puede cumplir ese propósito, y puede variar durante la ejecución del programa.

Otra alternativa que se usa a menudo, y que simplifica en cierto modo el uso de listas circulares es crear un nodo especial de hará la función de nodo cabecera. De este modo, la lista nunca estará vacía, y se eliminan casi todos los casos especiales.




TRABAJO DE EJECUCIÓN (EN CLASE, TAREAS INDIVIDUALES Y GRUPALES, INVESTIGACIÓN)




TAREAS

TAREA #1:

Supongamos que nos enfrentamos a un problema como este: Una empresa que cuenta con 150 empleados, desea establecer una estadística sobre los salarios de sus empleados, y quiere saber cual es el salario promedio, y también 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 categoría:

Categoría pago x hora (S/.)

A 35.60

B 33.40

C 28.45

Además si el empleado trabaja más de 115 horas mensuales tiene una bonificación del

2.5 % de sueldo. Usar estructuras

#include <conio.h>

#include <stdio.h> #include

<iostream.h>

struct sueldo {

float total;

float bono;

};

struct categoria_ {

char categor;

float a;

float b;

float c;

};

struct datos {

char nombre[50];

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 días 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

Ingresando

el nombre de

un empleado

FIGURA: 2

Ingresando las horas diarias de labor del trabajo

FIGURA: 3

Ingresando los días del mes laborados

FIGURA: 4

Ingresando la categoria del empleado

FIGURA: 5

Impresión de los datos del trabajador trabajador

SEGUNDO EJERCICIO

Definición de estructura y manipulación de varias estructura

Defina un tipo de datos llamado TFECHA, con los campos adecuados para almacenar el

día, mes y año 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 música (Pop, Rock, etc.).

Declare un arreglo MisCDsde tamaño 25 de tipo TCD.

Asigne en la primera posición 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:

Impresión 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 utilización.

Bien utilizado hace que el código sea más compacto y eficiente; por el contrario, su uso descuidado lleva a tener poca claridad y frecuentemente conduce a la pérdida 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 "dirección de memoria de" que permite obtener la dirección de memoria donde se aloja la variable a la cual precede (&x es la dirección de memoria de x).

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

Dirección 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 dirección 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 dirección de memoria específica sino que se incrustan en las instrucciones. Por ello, no es válido hacer directamente:

int px = &10; // Error 10 no es una variable con dirección propia

Tampoco es válido aplicar & a campos readonly, pues si estos pudiesen ser apuntados por punteros se correría el riesgo de poderlos modificar ya que a través de un puntero se accede a memoria directamente, sin tenerse en cuenta si en la posición accedida hay algún objeto, por lo que mucho menos se considerará si éste es de sólo lectura.

Lo que es sí válido es almacenar en un puntero es la dirección de memoria apuntada por otro puntero. En ese caso ambos punteros apuntarían al mismo objeto y las modificaciones a éste realizadas a través de un puntero también afectarían al objeto visto por el otro, de forma similar a como ocurre con las variables normales de tipos referencia. Es más, los operadores relacionales típicos (==, !=, <,>, <= 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 válido 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 parámetros 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 implicaría perder tiempo innecesariamente en inicializarlos.

Puntero. Operador *

Un puntero no almacena directamente un objeto sino que suele almacenar la dirección 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 código 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 dirección válida. Sin embargo, si luego se intenta acceder al contenido del mismo a través del operador * se producirá generalmente una excepción de tipo NullReferenceException (aunque realmente esto depende de la implementación 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 información sobre el tipo de objetos a los que apuntan y por tanto no es posible recuperarlos a través de los mismos ya que no se sabe cuanto espacio en memoria a partir de la dirección 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 método F() sería posible llamarlo a través 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 instrucción anterior se escribiría 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 *, también 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","[email protected]",27); u=&amigo2; ingresar(u,"carlos","macias","052777665","[email protected]",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:");


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("\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 posición de una lista

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

Insertar al final

El proceso en este caso tampoco es excesivamente complicado:

1. Necesitamos un puntero que señale al último elemento de la lista. La manera de conseguirlo es empezar por el primero y avanzar hasta que el nodo que tenga como siguiente el valor NULL.

2. Hacer que nodo->siguiente sea NULL.

3. Hacer que ultimo->siguiente sea nodo.

Insertado al final

Insertar un elemento a continuación de un nodo cualquiera de una lista

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

Insertar dentro

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

El proceso a seguir será:

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

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

Insertado dentro

TAREA #11:

COLAS

Las colas no son más que listas lineales de información 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 también el primer dato en salir, en las colas no se permite el acceso aleatorio a

ningún 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 recuperación 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, planificación 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 recuperación son iguales, en otro caso la cola aun tiene

espacio para almacenar más datos. Su utilización más común es en los sistemas

operativos en los que la cola circular mantiene la información que se lee de archivo y

que se escribe en archivo, aplicaciones de tiempo real, etc...

ESPECIFICACIÓN SEMANTICA Y SINTACTICA.

cola crear () Argumentos: Ninguno. Efecto: Devuelve una cola vacía 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 vacía. Efecto: Devuelve el valor del primer elemento de la cola C. Se puede escribir en función 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 función 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 vacía. Efecto: Suprime el primer elemento de la cola C. En función de las operaciones de listas seria: BORRA (PRIMERO(C),C).

int vacía (cola C) Argumentos: Una cola C. Efecto: Devuelve si la cola C es una cola vacía.

Operaciones Básicas

Crear: se crea la cola vacía.

Encolar (añadir, entrar, insertar): se añade un elemento a la cola. Se añade 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 montón de libros unos encima de otros y que

para acceder al segundo por arriba primero es necesario coger el primero, su utilización

principal es para el software de sistemas, compiladores, interpretes.

Las dos operaciones básicas, son las de almacenamiento y la de recuperación, que se

llaman push (la de almacenamiento) y pop (la de recuperación), 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 asignación dinámica de memoria. Al igual que en las colas, la función de

recuperación elimina el valor de la lista, y si este no se almacena en algún lugar, este se

destruye.

La variable top es el índice de la siguiente posición libre de la pila. Cuando se

implementan estas funciones, lo más importante es evitar el desbordamiento de la pila

por los dos extremos, si top =0 la pila esta vacía y si top >que la ultima posición de

almacenamiento la pila está llena.

OPERACIONES BÁSICAS.

Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.

Crear: se crea la pila vacía. (constructor)

Tamaño: regresa el numero de elementos de la pila. (size)

Apilar: se añade 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)

Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).

CODIFICACIÓN

#include <stdio.h>

#include <stdlib.h>

/* declaración */

struct tpila{

int clave;

struct tpila *sig;

};

/* prototipos e implementación */

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 colocación de elementos nuevos "por encima" de los elementos existentes y se acorta a la eliminación de elementos de la parte superior de los elementos existentes. Se trata de un ADT [Tipo de datos Abstract] con las operaciones matemáticas de "push" y "pop".

Una cola es una secuencia de elementos, que se añade a al colocar el nuevo elemento en la parte trasera de existir y acortado por la eliminación de elementos en frente de la cola. Se trata de un ADT [Tipo de datos Abstract]. No hay más que estos términos entendidos en la programación de Java, C + +, Python y así sucesivamente.

CÓDIGO 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;

http://www.opengroup.org/onlinepubs/009695399/functions/printf.html

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;


while(actualPtr->siguientePtr != ultimoPtr) {


}

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;


while(actualPtr != NULL) {

cout << actualPtr->dato << "-> ";


}

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

CÓDIGO 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);

} ;




SECCIÓN ABIERTA (TRABAJOS INTRA Y EXTRA CLASES)

REFLEXIÓN:

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




ARTÍCULOS DE REVISTAS

REFEXION:

Esta asignatura es de carácter teórico práctico. Se encuentra dentro del Área de Formación

Profesional especializada, Sub Área de Informática. Tiene como propósito que el alumno

domine las técnicas y algoritmos más eficientes para la solución de múltiples problemas del

mundo real, a través de técnicas como: diagramas de flujo, ejercicios estructurados. Los

tópicos a tratar son: repetitivos, búsqueda y ordenación en una estructura y tipos abstractos

de datos.




Anexos

CÓDIGO 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 teléfono[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....."); } }




RESUMEN DE CIERRE

Durante el curso. Estructura de dato pude adquirir las destrezas de conocimiento, y

aptitud de echarles muchas ganas a la programación las cuales son importantes para

mi desempeño como profesional. De los trabajos asignados en el curso, las

presentaciones orales fueron de gran ayuda para mejorar en forma continua la

comunicación efectiva frente a los otros equipos.

portafolio de estructura

Documents