Portafolio estructura

PORTAFOLIO DE
ESTRUCTURA DE DATOS
UNIVERSIDAD TECNICA DE MANABI
FACULTAD DE CIENCIAS INFORMATICAS

UNIVERSIDAD TÉCNICA DE MANABÍ
FACULTAD DE CIENCIAS INFORMÁTICAS
Páginá 1
Contenido
Syllábus ___________________________________________________________________________________________________ 4
Cártá de Presentácion__________________________________________________________________________________ 13
Autoretráto______________________________________________________________________________________________ 15
Diário Metáconigtivo ___________________________________________________________________________________ 17
Articulos de Revistás Cientificás ______________________________________________________________________ 45
Trábájo en Ejecucion ___________________________________________________________________________________ 48
Máteriáles Relácionádos con lá Cláse _________________________________________________________________ 59
Seccion Abiertá _________________________________________________________________________________________ 63
Resumen de Cierre _____________________________________________________________________________________ 71
Investigácion____________________________________________________________________________________________ 72
Vinculácion______________________________________________________________________________________________ 73
Gestion __________________________________________________________________________________________________ 75

Páginá 2

CARRERA DE INGENIERÍA EN SISTEMAS INFORMÁTICOS
SYLLABUS
I.- INFORMACIÓN GENERAL
FACULTAD/DEPARTAMENTO: FACULTAD DE CIENCIAS INFORMÁTICAS
CARRERA: INGENIERÍA EN SISTEMAS INFORMÁTICOS
ASIGNATURA/MÓDULO: ESTRUCTURA DE DATOS CÓDIGO: OF-0201
Nivel / Semestre: 2 N° de Créditos:5 Modalidad : Presencial
Paralelo: 2do. “B” Período Académico: Sept. 25/2012 – Feb 14/2013 Área Académica: SOFTWARE
PRERREQUISITO (S): CORREQUISITO (S):
CONTENIDOS DISCIPLINARES QUE
DEBEN SER APROBADAS ANTES DE
CURSAR ESTE CONTENIDO
DISCIPLINAR
CÓDIGO
CONTENIDOS DISCIPLINARES
QUE DEBEN SER CURSADOS AL
MISMO TIEMPO QUE ESTE
CONTENIDO DISCIPLINAR
CÓDIGO
PROGRAMACIÓN I OC-0100
DOCENTE: Ing. CHRISTIAN RONALD TORRES MORÁN
Título: MAGITER EN GERENCIA EDUCATIVA E-mail: crtorres@utm.edu.ec
Datos personales: Profesor contratado a tiempo completo de la asignatura Estructura de Datos, y Herramientas Web
Director de Tesis de Ingeniería en Sistemas Informáticos, miembro de los equipos de Vinculación con la sociedad, Docente
Tutor de pasantías pre profesionales, coautor del manual de Estructura de Datos junto a la Ing. Esthela San Andrés Láz,
coautor del folleto de flujogramas para NBU.
II.- RUTA FORMATIVA
a.- DEL PERFIL DE EGRESO: Competencia/Resultado de Aprendizaje:
Competencia:
3. Construye soluciones informáticas de calidad que mejoren la eficiencia y eficacia de una organización
haciendo uso correcto de la tecnología.
Resultado de Aprendizaje:
a. Capacidad de planificar, diseñar, conducir e interpretar resultados de experimentos orientados a la
informática.
b.- OBJETIVO GENERAL DE LA ASIGNATURA:
Capacitar al estudiante con los conocimientos significativos en administración de memoria dinámica y herramientas útiles en
los diseños, construcciones y usos principales de algoritmos en la estructuración de datos lineales y no lineales
c.- DESCRIPCIÓN DE LA ASIGNATURA:
La materia introduce al estudiante a los conceptos y aplicación en la administración de memoria, aplicando programación
estructurada y orientada a objetos, permite conocer la estructura básica operacional de la memoria RAM y de los grandes
diseños de software, aplicando C++ el estudiante desarrollará proyectos científicos tanto con interfaces en modo gráfico y en
modo texto, tomando como referencia aplicaciones en el campo general de otras carreras.

III.- RESULTADOS DE APRENDIZAJE DE LA ASIGNATURA
Resultados del Aprendizaje
(Objetivos Específicos)
Formas de
Evidenciarlos
(Apreciación)
Niveles del resultado de
aprendizaje
Ponderación
1.- Identificar los tipos estructurados
de datos estáticos y dinámicos
empleados en la creación de
aplicaciones, considerando los
lenguajes de programación. (Nivel
Taxonómico: Conocimiento)
1.- Pruebas escritas,
orales (fotos), talleres,
informes de ensayo,
investigación y
Prácticas en el
Lenguaje de
programación C++.
Describirá la definición de la estructura de datos,
los tipos de datos simples, básicos y compuestos
en un ensayo técnico con: descripción general del
tema clara; ideas que tienen relación, claridad y
objetividad con el tema; y una conclusión clara con
aporte personal.
tema confusa; pocas ideas que tienen relación,
claridad y objetividad con el tema; y una
conclusión confusa con aporte personal.
tema confusa; poca o ninguna idea que tienen
relación, claridad y objetividad con el tema; y una
conclusión confusa sin aporte personal.
NIVEL ALTO:
86-100
NIVEL MEDIO
71-85
NIVEL BÁSICO
70
2.- Elaborar aplicaciones dinámicas
de estructura lineal, almacenamiento
y recuperación de los mismos en
unidades de almacenamiento,
aplicarán soluciones de
administración de memoria
mediante el desarrollo de
aplicaciones científicas y
comerciales. (Nivel Taxonómico:
Aplicación)
informes de ensayo,
investigación y
Prácticas en el
Lenguaje de
programación C++.
Comparará con la utilización de un cuadro
comparativo tres semejanzas y tres diferencias
entre los tipos de datos que permiten almacenar
más de un dato; reflejando las relaciones de las
comparaciones con ideas claras.
comparativo tres semejanzas y tres diferencias
comparaciones con ideas pocos claras.
comparativo dos semejanzas y dos diferencias
comparaciones con ideas confusas.
NIVEL ALTO:
86-100
NIVEL MEDIO
71-85
NIVEL BÁSICO
70

3.- Implementar aplicaciones
dinámicas de estructura Lineal,
almacenamiento y recuperación
de los mismos en unidades de
almacenamiento, aplicarán
soluciones de administración de
memoria mediante el desarrollo
de aplicaciones científicas y
comerciales (Nivel Taxonómico:
Aplicación)
informes de ensayo,
investigación y
Prácticas en el
Lenguaje de
programación C++.
Implementará aplicaciones dinámicas de
estructura Lineal, almacenamiento y recuperación
de los mismos en unidades de almacenamiento,
aplicarán soluciones de administración de
memoria mediante el desarrollo de aplicaciones
científicas y comerciales.
estructura Lineal, almacenamiento y recuperación
de los mismos en unidades de almacenamiento,
aplicarán soluciones de administración de
memoria mediante el desarrollo de aplicaciones
comerciales.
estructura No Lineal, almacenamiento y
recuperación de los mismos en unidades de
almacenamiento.
NIVEL ALTO:
86-100
NIVELMEDIO
71-85
NIVEL BÁSICO
70
4.- Implementar aplicaciones
dinámicas de estructura no Lineal,
almacenamiento y recuperación de
los mismos en unidades de
almacenamiento, aplicarán
soluciones de administración de
memoria mediante el desarrollo de
aplicaciones científicas y comerciales
(Nivel Taxonómico: Aplicación)
informes de ensayo,
investigación y
Prácticas en el
Lenguaje de
programación C++.
Elaborará un programa con estructuras dinámicas
no lineales bien detallado.
no lineales con poca claridad.
no lineales de forma confusa.
NIVEL ALTO:
86-100
NIVEL MEDIO
71-85
NIVEL BÁSICO
70
5.- Organizar la información en
algoritmos y estructuras AVL y su
relación con los gestores de Base de
Datos (Nivel Taxonómico: Aplicación)
informes de ensayo,
investigación y
Prácticas en el
Lenguaje de
programación C++.
Elaborará un programa que emplee estructuras
arborescentes de forma AVL uso de forma clara.
arborescentes de forma AVL de forma poco clara.
arborescentes de forma AVL de forma confusa.
NIVEL ALTO:
86-100
NIVEL MEDIO
71-85
NIVEL BÁSICO
70

IV.- PROGRAMACIÓN
N°
PROGRAMA DEL CONTENIDO
DISCIPLINAR (ASIGNATURA, UNIDAD,
CURSO, TALLER, OTRO) POR TEMAS
N°
TOT
AL
HOR
AS
P-A
HORAS PRESENCIALES
HORAS
AUTÓNOMAS
ESTRATEGIAS PARA EL
TRABAJO AUTÓNOMO
1. UNIDAD I: GENERALIDADES Y
DEFINICIONES DE ESTRUCTURA DE
DATOS
 Definición
 Variables, Tipos de datos.
 Representación Gráfica de las
estructura de datos
 Acceso a las estructura de
Datos (Estáticas)
 Tipos de Estructuras de Datos
 Diferencia entre gestión
Estática y Dinámica
 Operaciones con varios
punteros
 Asignación dinámica de
memoria
 Liberación dinámica de
memoria
 La constante NULL
 Ventajas y desventajas de
punteros
46 23
Experiencia:
Aplicando lluvia de ideas
concretar conocimientos
relativo a la memoria y sus
diferentes importancias en el
funcionamiento del
computador
Reflexión:
En equipos de trabajo, analizar
el funcionamiento general del
computador y de los
programas, considerando las
siguientes aplicaciones:
Procesadores de texto, Hojas
de cálculo, Reproductores,
Tareas del sistema operativo
como Impresión, etc.
Conceptualización:
Elaboración de mapas
conceptuales, cuadros de
funcionamiento y estructurales
de la memoria.
Aplicación:
Resolución de ejercicios
demostrativos y de
planteamiento de problemas.
23
Tareas extra-
clases.
Investigación del
tema de la unidad
Tareas en el
lenguaje de
programación
C++.
CD. interactivo
libros PDF. Apoyo
para el
estudiante,
Espacio virtual de
la Universidad
Técnica de
Manabí, Internet.
Guardar la
evidencia en el
Portafolio Digital.
-Formarán equipos de 2
estudiantes
-Del taller o tarea respectivas
se escogerán ejercicios
representativos de acuerdo al
resultado de aprendizaje
-Se aplicará la técnica de
procesos.
-Al final de la tarea se
interrogarán, así:
¿Qué cosas fueron difíciles?
¿Qué cosas fueron fáciles?
¿Qué aprendí hoy día?
¿Qué aporte a mi equipo?
-Aplicarán un ASAT. (Aporte
Significativo de Aprendizaje de
la Tarea o Taller).
-Para el ensayo del tema
respetivo se Tomarán lo
lineamientos más importantes
de la introducción llamativa,
fundamentación y conclusión
crítica.
2. UNIDAD II: ESTRUCTURAS SIMPLES
Y COMPUESTAS
Listas Abiertas
60 30
Experiencia:
Aplicando lluvia de ideas
concretar conocimientos
relativo a problemas
30
Tareas extra-
clases.
Investigación del
tema de la unidad
Tareas en el
lenguaje de
estudiantes
procesos.

 Definición de listas abiertas
 Declaración e implementación
de una lista
Operaciones con Listas
 Inserción de un nodo
 Búsqueda de un nodo
 Recorridos de una lista
 Eliminación de un nodo
 Listas y Archivos
 Variaciones de listas
 Pilas y Colas
Listas circulares o cerradas
de una lista circular
Listas doblemente enlazadas abiertas
y cerradas
de una lista doblemente
enlazada
informáticos planteados
Reflexión:
En grupos de trabajo, analizar
el funcionamiento general de
los diferentes algoritmos
considerando las diferentes
aplicaciones.
Conceptualización:
Elaboración de conclusiones
conceptuales, cuadros de
funcionamiento y alternativas
estructurales de solución.
Aplicación:
demostrativos y de
programación
C++.
CD. interactivo
libros PDF. Apoyo
para el
estudiante,
Espacio virtual de
la Universidad
Técnica de
Manabí, Internet.
Guardar la
evidencia en el
Portafolio Digital.
la Tarea o Taller).
crítica.
3. UNIDAD III: ESTRUCTURAS
ARBORESCENTES
 Definición, implementación
26 13
Experiencia:
• Aplicando debates
definir la importancia de
aplicar algoritmos generales de
13
Tareas extra-
clases.
Investigación del
tema de la unidad
Tareas en el
estudiantes
procesos.

 Tipos de recorridos:
PreOrden
InOrden
PostOrden
Operaciones con Árboles Binarios de
Búsqueda
 Búsqueda de elementos.
Inserción de elementos.
Borrado de elementos.
* Nodo hoja.
 *Nodo rama.
 Movimiento a través del árbol.
Comprobación de árboles
vacíos.
 Comprobación del nodo hoja.
Cálculo de:
 Número de nodos.
 Altura del árbol.
 Altura de un nodo.
 Árboles degenerados.
árboles binarios y su
importancia en la agilidad y
seguridad de los datos en el
campo empresarial en general.
Reflexión:
• En grupos de
trabajo, analizar el
funcionamiento general de los
principales sistemas
informáticos, considerando el
avance tecnológico del
software en la base de datos
Conceptualización:
• Elaboración de
propuestas algorítmicas,
prácticas y de alternativas de
resolución.
Aplicación:
• Resolución de
ejercicios demostrativos y de
lenguaje de
programación
C++.
CD. interactivo
libros PDF. Apoyo
para el
estudiante,
Espacio virtual de
la Universidad
Técnica de
Manabí, Internet.
Guardar la
evidencia en el
Portafolio Digital.
la Tarea o Taller).
crítica.
4. UNIDAD IV: TIPOS DE ÁRBOLES
ESPECIALES
 Árboles equilibrados.
 Definición.
 Operaciones en AVL.
 Factor de equilibrio.
 Rotación simple de nodos.
 Rotación simple a la derecha.
 Rotación simple a la izquierda.
 Rotación doble de nodos a la
derecha.
 Rotación doble de nodos s la
izquierda.
 Reequilibrados de árboles
AVL.
 Reequilibrados en árboles
AVL por inserción de un nodo.
28 14
Experiencia:
Aplicando el planteamiento de
problemas, identificar
dificultades y generar la
necesidad de encontrar
soluciones algorítmicas.
Reflexión:
En grupos de trabajo, analizar
el funcionamiento de los
diferentes algoritmos
propuestos.
Conceptualización:
Elaboración de propuestas de
funcionamiento y alternativas
estructurales de solución.
Aplicación:
14
Tareas extra-
clases.
Investigación del
tema de la unidad
Tareas en el
lenguaje de
programación
C++.
CD. interactivo
libros PDF. Apoyo
para el
estudiante,
Espacio virtual de
la Universidad
Técnica de
Manabí, Internet.
Guardar la
evidencia en el
Portafolio Digital.
estudiantes
procesos.
la Tarea o Taller).
crítica.

 Reequilibrados en árboles
AVL por borrado de un nodo.
demostrativos y de
V.- METODOLOGÍA Y RECURSOS
 Se aplicará un PEA, Dinámica de integración y socialización, documentación, presentación de los temas de clase y objetivos, lectura de motivación
y video del tema, técnica lluvia de ideas, para interactuar entre los receptores, aplicando el ciclo del aprendizaje.
 Se aplicaran talleres con ASAT (aporte significativos de los aprendizajes de tareas o talleres)
 Revisión de la clase programada antes del día señalado para la sesión correspondiente (blog-docente)
 Consultas, tareas y talleres se entregarán en archivo escrito al docente y en archivo lógico al área de contacto del curso.
 Los recursos disponibles para el curso serán: pizarra tiza líquida(4), proyector, internet inalámbrico, dispensador de agua, aire acondicionado,
mesas de trabajo en equipo, proyector para equipos de trabajos en su lugar respectivo, sistema de audio, impresora de última generación,
computadores(2) del aula,1 portátiles por equipo del estudiante, libros-CD-interactivo- pdf., blog. del estudiante y del docente para interactividad
y fortalecimiento continúo.
VI.- PLANEACIÓN DE LA EVALUACIÓN
Las evaluaciones estarán orientadas a los procesos, lo que conlleva a que ninguna evaluación tenga una ponderación
determinante para la acreditación.
Durante el periodo académico, el estudiante de la Universidad Técnica de Manabí, se someterá obligatoriamente a los
siguientes parámetros de evaluación de los aprendizajes: evaluación de medio ciclo, evaluación de final de ciclo, evaluación de
actividades varias y evaluaciones de investigaciones.
ACREDITACIÓN
MEDIO CICLO FINAL DE CICLO EXAMEN DE
RECUPERACIÓN
ASISTENCIA
EXÁMENES (30%) 15 15
ACT. EN EL AULA (40%)
Tareas 5 5
Ejercicios de aplicación 2.5 2.5
Lecciones orales 2.5 2.5
Pruebas escritas 5 5
Participación 2.5 2.5
Exposiciones 2.5 2.5
ACTIVIDADES DE INVESTIGACIÓN
PORTAFOLIO
PROYECTO
INFORME FINAL
(30%)
5
10
5
10
TOTAL 50% 50% 100%

VI.- BIBLIOGRAFÍA
a.- Bibliografía Básica:
AUTOR TÍTULO DE LIBRO EDICIÓN AÑO PUBLICACIÓN EDITORIAL
MARTÍNEZ, Román Estructura de Datos, Referencia
practica con objetos orientados
a objetos
7° 2008 Elda Quiroga
TORRES, Christian Manuales de estructura de
Datos en C++
1° 2010 Estudiantil-FCI-UTM.
Ecuador
b.- Bibliografía Recomendada:
AUTOR TÍTULO DE LIBRO EDICIÓN AÑO PUBLICACIÓN EDITORIAL
Garrido Antonio Abstracción y Estructura
de Datos en C++
1° 2006 Delta Publicaciones S. L.
c.- Lecturas complementarias:
 http://c.conclase.net/edd/.
 http//www.utm.edu.ec
 http://evirtual.utm.edu.ec/course/view.php?id=25
 robotica.uv.es/pub/Libro/PDFs/CAPI5.pdf
 www.dc.uba.ar › ... › Algoritmos y Estructuras de Datos II
 http://www.programacion.com/articulo/estructuras_de_datos_y_algoritmos_en_java_309/2
 http://www.youtube.com/watch?v=tOOEff1r-tk
VII.- COMPROMISO ÉTICO
 Escuchar y respetar democráticamente el criterio de los demás.
 Hacer silencio cuando alguien esté haciendo uso de la palabra.
 Mantener el aula limpia, evitando botar basura en el piso
 No deteriorar ni rayar, las paredes, mesas y sillas.
 Procurar en todo momento la correcta manipulación y utilización de los equipos informáticos.
 La asistencia es obligatoria a todas las actividades programadas en esta asignatura.
 El estudiante ingresará a clase a la hora establecida y solo por una ocasión se aceptará el retraso de 10 minutos.
 El estudiante por ningún concepto utilizará celulares en el aula, igual comportamiento tendrá el docente.
 El intento de copia de cualquier estudiante será sancionado con la calificación de cero y no habrá oportunidad de
recuperación, independiente de las sanciones establecidas por la universidad.
 Los trabajos se entregarán en la fecha establecida y no se recibirá en otra oportunidad.
 El estudiante ingresará al aula sin gorra y no consumirá alimentos dentro del aula.
 El trabajo escrito será realizado con las propias palabras e ideas del estudiante. Si se descubre la copia textual de un
párrafo o un texto se calificará con cero.
Lugar y fecha: Portoviejo, 6 de Mayo del 2013
Ing. Christian Ronald Torres Morán
(f) Docente (f) Coordinador
ANEXO. N° 1

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

Páginá 13
Ó

Páginá 14
Mi nombre es QUINTANA MACÍAS ANDRÉS DAVID soy estudiante de la asignatura de
ESTRUCTURA DE DATOS, vivo en Portoviejo y actualmente estudio en el segundo semestre
de Ciencias Informáticas de la Universidad Técnica de Manabí. Soy una persona
responsable, organizada, humilde y me gusta trabajar en equipo.
Mis metas son convertirme en profesional como ingeniero en Sistemas Informáticos

Páginá 15

Páginá 16
AUTORETRATO:
Soy alto, delgado, alto y educado. Siempre he sido de complexión
delgada por lo que puedo comer mucho y no engordar. Mis ojos son
cafés claros, tengo orejas pequeñas, mi nariz esta algo desviada por lo
que tendré que someterme a una operación por problemas
respiratorios.
Mi cabello es oscuro algo rizado y se me dificulta peinarme como
quiero mis manos son grandes y delgadas me gusta usar reloj. Me
gusta vestirme siempre con jeans y una camiseta con cuello en V, de preferencia que sean
de color azul o negras combinado con zapatos converse
Soy diferente como todos tengo mi propia manera de ver la vida, me gusta escuchar a los
demás aunque no soy muy bueno dando consejos, me gusta molestar a mis amigos.
Las reglas son la base de la disciplina porque si no se tiene disciplina uno sería un mediocre
sin rumbo para hacer lo que se desea.
Me encanta la música rock, hardcore, electrónica y por ahí una que otra romántica porque la
música es relajante me transporta a otro mundo y me libera del estrés y problemas.
No me gusta criticar a los demás porque como dije todos somos diferentes y no hay razón
para criticar y discriminar a los demás.
Soy de Quito pero me gusta estar aquí en Portoviejo aun no sé realmente el por qué?... me
gusta las películas el chocolate el yogurt el queso. No practico ningún deporte pero estoy
pensando entrar a un GYM y soy un amante de los videojuegos.

Páginá 17

Páginá 18
CLASE NO. 1
ELEMENTOS ESTRATÉGICOS DESTACADOS
Periodo: Del 06 de mayo del 2013 – 14 Septiembre del 2013
Tiempo: 2 Horas
Fecha: 9 de Mayo del 2013
Docente Guía: Ing. Christian Torres
1. Ingreso de los Estudiantes
2. Contenido de la Clase:
2.1. Sistema de Información
PROGRAMACIÓN EN C++
Sistema de Información
Introducción. - Un sistema de información es un conjunto de elementos que interactúan entre sí
con el fin de apoyar las actividades de una empresa o negocio.
El equipo computacional: el hardware necesario para que el sistema de información pueda operar.
El recurso humano que interactúa con el Sistema de Información, el cual está formado por las
personas que utilizan el sistema.
Un sistema de información realiza cuatro actividades básicas: entrada, almacenamiento,
procesamiento ysalida de información.

Páginá 19
CLASE NO. 2
Tiempo: 3 Horas
4.1. Estructura de datos c++
Estructura de datos
En programación, una estructura de datos es una forma de organizar un conjunto de datos
elementales con el objetivo de facilitar su manipulación. Un dato elemental es la mínima información
que se tiene en un sistema.
Una estructura de datos define la organización e interrelación de estos y un conjunto de operaciones
que se pueden realizar sobre ellos. Las operaciones básicas son:
 Alta, adicionar un nuevo valor a la estructura.
 Baja, borrar un valor de la estructura.
 Búsqueda, encontrar un determinado valor en la estructura para realizar una operación con
este valor, en forma secuencial o binario (siempre y cuando los datos estén ordenados).
Otras operaciones que se pueden realizar son:
 Ordenamiento, de los elementos pertenecientes a la estructura.
 Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a las apareadas.
Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y eficiencia para la
realización de cada operación. De esta forma, la elección de la estructura de datos apropiada para
cada problema depende de factores como la frecuencia y el orden en que se realiza cada operación
sobre los datos.

Páginá 20

Páginá 21
CLASE NO. 3
Tiempo: 2 Horas
2.1. Arrays de Estructuras
2.2. Inicialización de Estructuras
ARRAYS DE ESTRUCTURAS
Supongamos ahora que queremos guardar la información de varios amigos. Con una variable de
estructura sólo podemos guardar los datos de uno. Para manejar los datos de más gente (al conjunto
de todos los datos de cada persona se les llama REGISTRO) necesitamos declarar arrays de
estructuras.
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
struct empleados {
char nombres[20];
float sueldo;
float val_vent;
};
main()
{

Páginá 22
struct empleados datos[5];
textcolor(10);
for(int x=0;x<5;x++)
{
cprintf("nIngrese los nombres del empleado #: %d: ",x+1);
gets(datos[x].nombres);
cprintf("Ingrese el sueldo #: %d: ",x+1);
cin>>datos[x].sueldo;
cprintf("Ingrese el valor de venta #: %d",x+1);
cin>>datos[x].val_vent;
}
{
printf("nEl nombre del empleado es: %sn",datos[x].nombres);
cout<<"El sueldo del empleado es: "<<datos[x].sueldo<<"n";
cout<<"El valor de venta del empleado es: "<<datos[x].val_vent<<"n";
}
getch();
return 0;
}

Páginá 23
CLASE NO. 4
Tiempo: 3 Horas
2.1. Estructuras Anidadas
ESTRUCTURAS ANIDADAS
Una estructura puede estar dentro de otra estructura a esto se le conoce como anidamiento o
estructuras anidadas. Ya que se trabajan con datos en estructuras si definimos un tipo de dato en
una estructura y necesitamos definir ese dato dentro de otra estructura solamente se llama el dato
de la estructura anterior.
EJEMPLO:
struct inventario {
char titulo[30];
char autor[40];
int existencias_discos;
int existencias_cintas;
int existencias_cd;
char nombre_proveedor[40];
char telefono_proveedor[10];
char direccion_proveedor[100];
};
Sin embargo utilizando estructuras anidadas se podría hacer de esta otra forma más ordenada:

Páginá 24
struct estruc_existencias {
int discos;
int cintas;
int cd;
};
struct estruc_proveedor {
char nombre[40];
char telefono[10];
char direccion[100];
};
struct estruc_inventario {
char titulo[30];
char autor[40];
struct estruc_existencias existencias;
struct estruc_proveedor proveedor;
} inventario;
Ahora para acceder al número de cd de cierto título usaríamos lo siguiente:
inventario.existencias.cd
y para acceder al nombre del proveedor:
inventario.proveedor.nombre

Páginá 25
CLASE NO. 5
Tiempo: 3 Horas
2.1. Evaluación
CLASE NO. 6
Tiempo: 2 Horas
3. Punteros
4. Arrays y Punteros

Páginá 26
PUNTEROS Y ARRAYS
Sea el array de una dimensión:
int mat [ ] = { 2, 16, - 4, 29, 234, 12, 0, 3} ;
En el que cada elemento, por ser tipo int , ocupa dos byt es de memoria.
Suponemos que la dirección de memoria del primer elemento, es 1500:
&mat [ 0] es 1500
&mat [ 1] ser á 1502
&mat [ 7] ser á 1514
int mat [ ] = { 2, 16, - 4, 29, 234, 12, 0, 3} ;
En total los 8 elementos ocupan 16 bytes.
Podemos representar las direcciones de memoria que ocupan los elementos del array , los datos
que contiene y las posiciones del array.
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<iomanip.h>
struct fecha{int dia;
int mes;
int anio;
};
void Pidefecha(struct fecha &f);
void Verfecha(struct fecha f);
//void Suma(int d);
void Verfecha(struct fecha f)
{ cout << setfill('0') << setw(2) << f.dia << '/'
<< setw(2) << f.mes << '/' << setw(4) << f.anio;
}
void Pidefecha(struct fecha &f)
{ char ch;

Páginá 27
cout << "Escriba la Fecha de la forma dd/mm/aa:";
cin >> f.dia >> ch >> f.mes >> ch >> f.anio;
}
//crear el main
void main()
{clrscr();
struct fecha f1;
Pidefecha(f1);
cout << "nFecha ingresada: ";
Verfecha(f1);
cout << " nHe terminado..";
getch();
}

Páginá 28
CLASE NO. 7
Tiempo: 2 Horas
2.1. Punteros a estructura:
PUNTEROS A ESTRUCTURAS
Cómo no, también se pueden usar punteros con estructuras. Vamos a ver como funciona esto de
lospunteros con estructuras. Primero de todo hay que definir la estructura de igual forma que
hacíamos antes.
La diferencia está en que al declara la variable de tipo estructura debemos ponerle el operador '*'
paraindicarle que es un puntero.
Creo que es importante recordar que un puntero no debe apuntar a un lugar cualquiera, debemos
darle una dirección válida donde apuntar. No podemos por ejemplo crear un puntero a estructura y
meter losdatos directamente mediante ese puntero, no sabemos dónde apunta el puntero y los
datos se almacenarían en un lugar cualquiera.
EJERCICIO:
#include<stdio.h>
#include<conio.h>
struct empleado {
char nombre[30];
int n_h_tra;

Páginá 29
float v_hora, v_h_extra, salario;
};
void ingreso(struct empleado &f);
void calcular(struct empleado &f);
void mostrar(struct empleado f);
main()
{
struct empleado datos[5];
ingreso(datos[x]);
calcular(datos[x]);
mostrar(datos[x]);
getch();
}
void ingreso(struct empleado &f)
{
cout<<"nn Ingrese el nombre del empleado: "; cin>>f.nombre;
cout<<"n Ingrese las horas trabajadas: "; cin>>f.n_h_tra;
cout<<"n Ingrese el valor de la hora: "; cin>>f.v_hora;
cout<<"n Ingrese el valor de la hora extra: "; cin>>f.v_h_extra;
}
void calcular(struct empleado &f)
{
struct empleado *punt;

Páginá 30
punt=&f;
int extras;
if(punt->n_h_tra>40)
{
extras=punt->n_h_tra-40;
punt->salario=extras*punt->v_h_extra;
punt->salario+=40*punt->v_hora;
}
else
punt->salario+=punt->n_h_tra*punt->v_hora;
}
void mostrar(struct empleado f)
{
cout<<"nn El nombre del empleado es: "<<f.nombre;
cout<<"n El salario es: "<<f.salario;
}

Páginá 31
CLASE NO. 8
Tiempo: 2 Horas
Fecha: 3 de Junio del 2013
2.1. Ejercicio con puntero:
#include<stdio.h>
#include<conio.h>
#include<iomanip.h>
struct control_asis{
char estudiante[20];
char nivel[20];
char paralelo;
char aula[7];
char h_inicio[6];
char h_final[6];
int dia,mes,anio;
};
void registrar(control_asis c[], int n);
void imprimir(control_asis c[], int n);
//Implementacion
void registrar(control_asis c[], int n)

Páginá 32
{
clrscr();
for(int i=0;i<n;i++)
{
cout<<"nnnnIngreso de Informacionn";
cout<<"nIngrese el nombre del estudiante: "; cin>>c[i].estudiante;
cout<<"nIngrese el nivel: "; cin>>c[i].nivel;
cout<<"nIngrese el paralelo: "; cin>>c[i].paralelo;
cout<<"nIngrese el codigo del aula: "; cin>>c[i].aula;
cout<<"nIngrese la hora de inicio: "; cin>>c[i].h_inicio;
cout<<"nIngrese la hora final: "; cin>>c[i].h_final;
char ch;
cout<<"nIngrese la fecha en formato dd/mm/yyyy: "; cin>>c[i].dia>>ch>>c[i].mes>>ch>>c[i].anio;
cout<<"nIngreso finalizado";
getch();
}
}
void imprimir(control_asis c[], int n)
{
int y=21;
clrscr();
cout<<"nnDatos Ingresados";
gotoxy(1,20);cout<<"Estudiante";gotoxy(15,20);cout<<"Nivel";gotoxy(25,20);cout<<"Paralelo";got
oxy(40,20);cout<<"Aula";gotoxy(50,20);cout<<"Hora Inicio";gotoxy(65,20);cout<<"Hora
Fin";gotoxy(80,20);cout<<"Fecha";
cout<<"n";
for(int i=0;i<n;i++){
gotoxy(0,y);cout<<c[i].estudiante;gotoxy(15,y);cout<<c[i].nivel;gotoxy(25,y);cout<<c[i].paralelo;go
toxy(40,y);cout<<c[i].aula;gotoxy(50,y);cout<<c[i].h_inicio;gotoxy(65,y);cout<<c[i].h_final;gotoxy(
80,y);cout<<setw(2)<<c[i].dia<<"/"<<setw(2)<<c[i].mes<<"/"<<setw(4)<<c[i].anio<<endl;
y++;}
}

Páginá 33
main()
{
struct control_asis dato[3];
registrar(dato,3);
imprimir(dato,3);
getch();
return 0;
}

Páginá 34
CLASE NO. 9
Tiempo: 2 Horas
2.1. Ayuda para la Acreditación por parte de los estudiantes
CLASE NO. 10
Tiempo: 2 Horas
2.1. Estructuras Dinámicas
2.1.1. Listas Abiertas
2.1.2. Inserción al inicio de la lista
LISTAS
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.

Páginá 35
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.
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h> //malloc
// Recorrer y añadir al comienzo de la lista
typedef struct _alumnos{
char nombres[25];
struct _alumnos *sig;
}tipoAlumno;
typedef tipoAlumno *pnodo;
typedef tipoAlumno *Lista;
/*
struct _alumnos{
char nombres[25];
};
typedef struct _alumnos tipoAlumno;*/
//Funciones prototipos
void almacenar(Lista *l, char c[]);
void ver_lista(Lista l);

Páginá 36
void main()
{
Lista L1=NULL;
int op;
do{
cout<<"n 1. Registrar Nombre";
cout<<"n 2. Mostrar Linea";
cout<<"n 1. Salir";
do{ cin>>op;
while((op>3)||(op<1));
almacenar(&L1,"Corozo Quiniones");
almacenar(&L1,"Gaymilkar");
ver_lista(L1);
getch();
}
void almacenar(Lista *l, char c[])
{
pnodo nodo;
nodo=(pnodo)malloc(sizeof(tipoAlumno));
if (nodo==NULL)
{
cout<<"n Sin espacio de Memoria";
return;
}
//Lleno la informacion del nodo
strcpy(nodo->nombres,c);
//Procedemos a hacer los enlaces
if (!(*l)) // Si no existe es el primer nodo que va a ingresar a la lista
{
nodo->sig=NULL;
*l=nodo;
}
else // Si existen elementos en la lista
{

Páginá 37
nodo->sig=*l;
*l=nodo;
}
}
void ver_lista(Lista l)
{
pnodo n=l;
while(n)
{
cout<<"n"<<n->nombres;
n=n->sig;
}
}

Páginá 38
CLASE NO. 11
Tiempo: 2 Horas
2.1.2. Inserción al final de la lista
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<string.h>
char nombres[25];
}tipoAlumno;
/*
struct _alumnos{

Páginá 39
char nombres[25];
};
typedef struct _alumnos tipoAlumno;
*/
void almacenar_fin(Lista *l, char c[]);
main()
{
Lista L1=NULL;
int op;
char nom[30];
do{
clrscr();
cout<<"n 1. Registrar nombre al inicio";
cout<<"n 2. Registrar nombre al final";
cout<<"n 3. Mostrar Lista";
cout<<"n 4. Salirnn ";
do{
cin>>op;
switch(op)
{
case 1:
cout<<"nREGISTRO DE NUEVO CLIENTE AL INICIOn";
cout<<"n Ingrese los nombres: "; fflush(stdin); gets(nom);
almacenar(&L1,nom);
break;
case 2:
cout<<"nREGISTRO DE NUEVO CLIENTE AL FINALn";

Páginá 40
almacenar_fin(&L1,nom);
break;
case 3:
ver_lista(L1);
getch();
}
}while((op>4)||(op<1));
}while(op!=4);
}
{
pnodo nodo;
if (nodo==NULL)
{
return;
}
nodo->sig=*l;
*l=nodo;
/* if (!(*l)) // Si no existe es el primer nodo que va a ingresar a la lista
{
nodo->sig=NULL; // nodo->sig=*l;
*l=nodo;
}
{
nodo->sig=*l;
*l=nodo;
} */

Páginá 41
}
void almacenar_fin(Lista *l, char c[])
{
pnodo nodo;
if (nodo==NULL)
{
return;
}
if(!*l)
{
nodo->sig=*l;
*l=nodo;
}
else
{ pnodo aux=*l;
while(aux->sig!=NULL) // (aux->sig)
{
aux=aux->sig;
}
aux->sig=nodo;
nodo->sig=NULL;
}
}
{
pnodo n=l;
while(n)

Páginá 42
{
cout<<"n "<<n->nombres;
n=n->sig;
}
}

Páginá 43
CLASE NO. 12
Tiempo: 2 Horas
2.1.2. Inserción ordenada
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<string.h>
char nombres[25];
}tipoAlumno;
/*

Páginá 44
struct _alumnos{
char nombres[25];
};
*/
void almacenar_ord(Lista *l, char c[]);
main()
{
Lista L1=NULL;
int op;
char nom[30];
do{
clrscr();
cout<<"n 3. Registrar nombre ordenadamente";
do{
cin>>op;
switch(op)
{
case 1:
almacenar(&L1,nom);

Páginá 45
break;
case 2:
case 3:
cout<<"nREGISTRO DE NUEVO CLIENTE ORDENADAMENTEn";
almacenar_ord(&L1,nom);
break;
case 4:
ver_lista(L1);
getch();
}
}while((op>5)||(op<1));
}while(op!=5);
}
{
pnodo nodo;
if (nodo==NULL)
{
return;
}
nodo->sig=*l;
*l=nodo;
{

Páginá 46
*l=nodo;
}
{
nodo->sig=*l;
*l=nodo;
} */
}
{
pnodo nodo;
if (nodo==NULL)
{
return;
}
if(!*l)
{
nodo->sig=*l;
*l=nodo;
}
else
{ pnodo aux=*l;
{
aux=aux->sig;
}
aux->sig=nodo;
nodo->sig=NULL;
}

Páginá 47
}
void almacenar_ord(Lista *l, char c[])
{
pnodo nodo;
if (nodo==NULL)
{
return;
}
if(!*l)
{
nodo->sig=*l;
*l=nodo;
}
else{
pnodo aux=*l;
if(strcmp(aux->nombres,c)>0)
{
nodo->sig=*l;
*l=nodo;
}
else
{
while((aux->sig!=NULL)&&(strcmp(aux->sig->nombres,c)<0))
{
aux=aux->sig;
}
nodo->sig=aux->sig;
aux->sig=nodo;
}
}
}

Páginá 48
{
pnodo n=l;
while(n)
{
n=n->sig;
}
}

Páginá 49
CLASE NO. 13
Tiempo: 2 Horas
2.1.2. Eliminar duplicados
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<string.h>
char nombres[25];
}tipoAlumno;
/*

Páginá 50
struct _alumnos{
char nombres[25];
};
*/
void almacenar_ord(Lista *l, char c[]);
void borrar_nodo(Lista *l,char c[]);
void borrar_todo(Lista *l);
main()
{
Lista L1=NULL;
int op;
char nom[30];
do{
clrscr();
cout<<"n 3. Registrar nombre ordenadamente";
cout<<"n 4. Borrar un elemento de la lista";
cout<<"n 5. Borrar toda la lista";
do{
cin>>op;
switch(op)
{

Páginá 51
case 1:
almacenar(&L1,nom);
break;
case 2:
case 3:
cout<<"nREGISTRO DE NUEVO CLIENTE ORDENADAMENTEn";
almacenar_ord(&L1,nom);
break;
case 4:
cout<<"nREGISTRO DE CLIENTE A SER BORRADOn";
borrar_nodo(&L1,nom);
break;
case 5:
cout<<"nREGISTRO TOTAL BORRADOn";
borrar_todo(&L1);
getch();
break;
case 6:
ver_lista(L1);
getch();
}
}while((op>7)||(op<1));
}while(op!=7);
}
{
pnodo nodo;

Páginá 52
if (nodo==NULL)
{
return;
}
nodo->sig=*l;
*l=nodo;
{
*l=nodo;
}
{
nodo->sig=*l;
*l=nodo;
} */
}
{
pnodo nodo;
if (nodo==NULL)
{
return;
}

Páginá 53
if(!*l)
{
nodo->sig=*l;
*l=nodo;
}
else
{ pnodo aux=*l;
{
aux=aux->sig;
}
aux->sig=nodo;
nodo->sig=NULL;
}
}
void almacenar_ord(Lista *l, char c[])
{
pnodo nodo;
if (nodo==NULL)
{
return;
}
if(!*l)
{
nodo->sig=*l;
*l=nodo;
}
else{
pnodo aux=*l;
if(strcmp(aux->nombres,c)>0)
{

Páginá 54
nodo->sig=*l;
*l=nodo;
}
else
{
while((aux->sig!=NULL)&&(strcmp(aux->sig->nombres,c)<0))
{
aux=aux->sig;
}
nodo->sig=aux->sig;
aux->sig=nodo;
}
}
}
void borrar_nodo(Lista *l,char c[])
{
pnodo nodo, aux=*l;
if(!*l)
cout<<"n Lista sin elementos no se borro nada"<<endl;
else
{
if(strcmp((*l)->nombres,c)==0){
aux=*l;
free(aux);
}
else{
while((aux->sig!=NULL)&&(strcmp(aux->sig->nombres,c)!=0))
{
aux=aux->sig;
}
if(aux->sig!=NULL){
nodo=aux->sig;
aux->sig=nodo->sig;
free(nodo);

Páginá 55
cout<<" Eliminado "<<endl;
}
}
}
}
void borrar_todo(Lista *l)
{
pnodo aux;
while(*l)
{
aux=*l;
*l=aux->sig;
free(aux);
}
}
{
pnodo n=l;
if(l){
while(n)
{
n=n->sig;
}
}
else{
cout<<" Lista Vacia ";}
}

Páginá 56

Páginá 57
CLASE NO. 14
Tiempo: 2 Horas
2.1. Ejercicio de evaluación:
EJERCICIO:
#include<conio.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
/**********************************************************************************
PROBLEMA:
El ministerio del interior ha elaborado para el segundo semestre del año 2013 una lista de
delincuentes buscados por la justicia ecuatoriana los datos que contienen esta lista son:
apellidos
nombres
lugar de procesamiento
delito
valor de recompensa
numero de año de centencia

Páginá 58
Se necesita que el listado este en funcion de los mas peligrosos esto esta determinado por el valor
de recompensa.
Elabore un programa que permita contar el numero con un menu para:
registrar a los mas buscados
capturar y en dicho proceso debe ser retirado de la lista de mas buscados y llevarlo
a la listade capturados
mostrar la lista de mas buscados
mostrar la lista de capturados
monto que invierte el estado en la captura de los mas buscados
salir del programa*/
//*********************************************************************************
typedef struct delincuentes{
char nombre[30];
char apellido[30];
char lugar_proc[50];
char delito[50];
int valor_recomp;
int anio_sentencia;
struct delincuentes *sig;
}TipoDelincuente;
typedef TipoDelincuente *pnodo;
typedef TipoDelincuente *Lista;
//Funcines Prototipo******************************************************************
void registrar(Lista *l, char nom[], char ape[], char lugar[], char del[], int valor, int anio);
void capturar(Lista *l, char nom[], char ape[], char lugar[]);
void mostrar_mb(Lista l);
void mostrar_cap(Lista l);
void eliminar(Lista *l, char nom[], char ape[], char lugar[]);
float monto(Lista l);

Páginá 59
//*********************************************************************************
main()
{
Lista LMB=NULL;
Lista LCAP=NULL;
char nom[30], ape[30], lugar[50], del[50];
int val, an, opc;
do
{
system("cls");
cout<<"n MINISTERIO DEL INTERIOR"<<endl;
cout<<"n 1. Registrar";
cout<<"n 2. Capturar";
cout<<"n 3. Mostrar lista de los mas buscados";
cout<<"n 4. Mostrar lista de los capturados";
cout<<"n 5. Mostrar monto de inversion del estado";
do
{
cin>>opc;
switch(opc)
{
case 1: system("cls");
cout<<"nREGISTRO DE MAS BUSCADOSn";
cout<<"Ingrese nombre:
";fflush(stdin);gets(nom);
cout<<"Ingrese el apellido:
";fflush(stdin);gets(ape);
cout<<"Ingrese el lugar de preocesamiento:
";fflush(stdin);gets(lugar);
cout<<"Ingrese el delito:
";fflush(stdin);gets(del);
cout<<"Ingrese el valor de recompensa:
";fflush(stdin);cin>>val;

Páginá 60
cout<<"Ingrese anios de sentencia:
";fflush(stdin);cin>>an;
registrar(&LMB,nom,ape,lugar,del,val,an) ;
break;
cout<<"nREGISTRO DE CAPTURASn";
cout<<"Ingrese nombre:
";fflush(stdin);gets(nom);
cout<<"Ingrese el apellido:
";fflush(stdin);gets(ape);
cout<<"Ingrese el lugar de preocesamiento:
";fflush(stdin);gets(lugar);
capturar(&LCAP,nom,ape,lugar);
eliminar(&LMB,nom , ape,lugar);
break;
cout<<"nLOS MAS BUSCADOSnn";
mostrar_mb(LMB);
getch();
break;
cout<<"nCAPTURADOSnn";
mostrar_cap(LCAP);
getch();
break;
cout<<"nEL MONTO DE INVERSION DEL ESTADO ES DE:
"<<monto(LMB)<<" DOALRES. ";
getch();

Páginá 61
}
}while((opc>6)||(opc<1));
}while(opc!=6);
return 0;
getch();
}
//*********************************************************************************
void registrar(Lista *l, char nom[], char ape[], char lugar[], char del[], int valor, int anio)
{
pnodo nodo;
nodo=(pnodo)malloc(sizeof(TipoDelincuente));
strcpy(nodo->nombre,nom);
strcpy(nodo->apellido,ape);
strcpy(nodo->lugar_proc,lugar);
strcpy(nodo->delito,del);
nodo->valor_recomp=valor;
nodo->anio_sentencia=anio;
if(!*l)
{
nodo->sig=*l;
*l=nodo;
}
else
{
pnodo aux=*l;
if(aux->valor_recomp<valor)
{
nodo->sig=*l;
*l=nodo;
}
else

Páginá 62
{
while((aux->sig)&&(aux->sig->valor_recomp>valor))
{
aux=aux->sig;
}
nodo->sig=aux->sig;
aux->sig=nodo;
}
}
}
//*********************************************************************************
void capturar(Lista *l, char nom[], char ape[], char lugar[])
{
pnodo nodo;
nodo=(pnodo)malloc(sizeof(TipoDelincuente));
strcpy(nodo->nombre,nom);
strcpy(nodo->apellido,ape);
strcpy(nodo->lugar_proc,lugar);
nodo->sig=*l;
*l=nodo;
}
//*********************************************************************************
float monto(Lista l)
{
float monto=0;
if(!l)
{
return monto;
}

Páginá 63
else
{
pnodo aux=l;
while(aux!=NULL)
{
monto=monto+aux->valor_recomp;
aux=aux->sig;
}
return monto;
}
}
//*********************************************************************************
void mostrar_mb(Lista l)
{
if(!l)
{
cout<<"nLA LISTA ESTA VACIA";
}
else
{
pnodo n=l;
while(n!=NULL)
{
cout<<"n Nombres: "<<n->nombre;
cout<<"n Apellidos: "<<n->apellido;
cout<<"n Lugar de procesamiento: "<<n->lugar_proc;
cout<<"n Delito: "<<n->delito;
cout<<"n Valor de recompensa: "<<l->valor_recomp;
cout<<"n Anios de sentencia: "<<l->anio_sentencia;
n=n->sig;
cout<<"nn";
}
}

Páginá 64
}
//*********************************************************************************
void mostrar_cap(Lista l)
{
if(!l)
{
cout<<"nLA LISTA ESTA VACIA";
}
else
{
pnodo n=l;
while(n!=NULL)
{
cout<<"n Nombres: "<<n->nombre;
cout<<"n Apellidos: "<<n->apellido;
cout<<"n Lugar de procesamiento: "<<n->lugar_proc;
n=n->sig;
cout<<"nn";
}
}
}
//*********************************************************************************
void eliminar(Lista *l, char nom[], char ape[], char lugar[])
{
pnodo lista_mb=*l, aux;
if(strcmp(lista_mb->nombre,nom)==0&&strcmp(lista_mb->apellido,ape)==0&&strcmp(lista_mb-
>lugar_proc,lugar)==0)
{
aux=*l;
*l=aux->sig;

Páginá 65
free(aux);
}
else
{
aux=*l;
while((lista_mb->sig)&&(strcmp(lista_mb->nombre,nom)==0)&&(strcmp(lista_mb-
>apellido,ape)==0)&&(strcmp(lista_mb->lugar_proc,lugar)==0))
lista_mb=lista_mb->sig;
if(lista_mb->sig)
{
aux=lista_mb->sig;
lista_mb->sig=aux->sig;
free(aux);
}
}
}

Páginá 66

Páginá 67
PC WORLD EN ESPAÑOL
PC World en Español, la revista impresa, es publicada mensualmente por IDG Latin America. PC World
es una publicación de IDG,la compañía líder mundialde medios de informática,con oficinas asociadas
en todo el mundo.
En particular, este sitio de la web:
pcworldenespanol.com amplía y complementa el
contenido publicado en las revistas impresas, pero va
mucho más allá, ofreciendo evaluaciones de productos,
noticias originales de última hora, tablas comparativas,
enlaces a sitios sociales, etc.
IDG también publica en América Latina revistas como
CIO América Latina, Gamepro en Español,
Computerworld en ediciones locales de Venezuela,
Ecuador y Colombia, asi como ChannelWorld Latin
America. Digitalworld es un suplemento periódico de
PC World.
Todo el contenido de esta publicación tanto impresa
como en el sitio de la web está registrado y protegido
por las leyes internaciones de derecho de autor, y como
tal, se prohíbe su reproducción sin la autorización
escrita de IDG Latin America.

Páginá 68
Si usted desea conocer más sobre esta publicación, o aquellas aquí mencionadas, así como sobre
nuestra organización, por favor contacte nuestras oficinas regionales:
IDG Latin America
1200 Brickell Avenue, Suite 1950
Miami, FL 33131
Tel/Fax 786-5813933/786-2725917
Editorial: Elinet Medina - elinet_medina@idglat.com
Ventas y Mercadeo: Walter Mastrapa - walter_mastrapa@idglat.com
PAGINA WEB:
http://www.pcworldenespanol.com/

Páginá 69

Páginá 70

Páginá 71

Páginá 72

Páginá 73
BORLAND C++
Descripción:
Borland c++ 5.02C++ es un lenguaje de programación diseñado a mediados de los años 1980 por
Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación
C con mecanismos que permitan la manipulación de objetos.
El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por
primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En
C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

Páginá 74

Páginá 75

Páginá 76

Páginá 77

Páginá 78
DE ACUERDO CON EL REGLAMENTO
INTERNO DE LA UNIVERSIDAD TECNICA DE
MANBI AUN NO PUEDO REALIZAR LA
VINCULACION HASTA QUE HAYA LLEGADO
AL 6TO NIVEL DE LA CARRERA

Páginá 79

Páginá 80

Portafolio estructura

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (20)

Similaire à Portafolio estructura

Similaire à Portafolio estructura (20)

Portafolio estructura