portafolio de estructura de datos

|

Universidad Técnica de Manabí

Facultad de Ciencias Informáticas

Escuela de Ingeniería en Sistemas Informáticos

Portafolio de Estructura de datos

Segundo “B”

Docente: Ing. Christian Torres.

Periodo: Mayo – Septiembre 2013

Bravo Cedeño Vicente

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.

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 MANABÍ

FACULTAD DE CIENCIAS INFORMÁTICAS ESCUELA DE

INGENIERÍA EN SISTEMAS INFORMÁTICOS

TABLA DE CONTENIDOS

Etapa 1. Prontuario del curso.

Etapa 2. Carta de presentación.

Etapa 3. Autorretrato.

Etapa 4. Diario Metacognitivo.

Etapa 5. Deberes

Etapa 6. Artículos de revistas profesionales. Etapa 7. Materiales relacionados con la clase.

Etapa 8. Sección abierta.

Etapa 9. Anexos.

Etapa 10. Investigación.

Etapa 11. Resumen de cierre.

Etapa 12. Evaluación del portafolio.

Etapa 1.

Prontuario del

curso

Etapa 2. Carta de

presentación




CARTA DE PRESENTACIÓN

Este portafolio presenta mi trayectoria en el curso de:

ESTRUCTURA DE DATOS, este curso tuvo como objetivos desarrollar las

destrezas de: agilidad mental, lógica y el intelecto. D urante este semestre de

estructura de datos pude conocer sobre: la clasificación de los datos,

estructuras, estructuras anidadas (externas e internas), pasos de

parámetros en funciones (por valor o por referencia), punteros, listas

abiertas, manejo de las listas abiertas, etc.

Las técnicas e implementos presentados por el docente me ayudaron a mejorar

como futuro profesional de la Informática.

Etapa 3.

Autorretrato




AUTORRETRATO

Mi nombre es Vicente Bravo Cedeño soy estudiante de la asignatura de

ESTRUCTURA DE DATOS, actualmente curso el segundo semestre en la Facultad de

Ciencias Informáticas de la Universidad Técnica de Manabí. Soy una persona

responsable, honesta, respetuosa, organizada, me gusta trabajar en equipo y demostrar

mis conocimientos.

Mis metas son convertirme en profesional como Ingeniero en Sistemas Informáticos, un

profesional de calidad en aspectos de conocimientos y valores.

NOMBRES: José Vicente

APELLIDOS: Bravo Cedeño

LUGAR DE NACIMIENTO: Buena fé - Los Ríos

FECHA DE NACIMIENTO: 10 de Febrero de 1992

CÉDULA DE IDENTIDAD: 131219275-8

ESTADO CIVIL: Soltero

DIRECCIÓN DE DOMICILIO: Final de la Av. Guayaquil “El Puño”

TELÉFONO: 2 638-088 CELULAR: 0985378246

CORREO: [email protected] - [email protected]

ESTUDIOS REALIZADOS:

ESTUDIOS PRIMARIOS:

-Escuela Fiscal Mixta Vespertina “República Federal de Alemania”

-Escuela Católica Mixta Particular “Santa María”

-Centro Escolar “Francisco pacheco”

ESTUDIOS SECUNDARIOS:

-Colegio Fiscal Mixto “Pedro Zambrano Barcia”

-Colegio Particular Mixto “Manabí Tecnológico”

ESTUDIOS SUPERIORES:

-Realicé el pre universitario en la Universidad Península de Santa Elena

-Cursando el segundo nivel en la Universidad Técnica de Manabí

EXPERIENCIA LABORAL:

Pasantías: C.N.T y El Diario

ACTIVIDADES:

- Jugar futbol

- Escuchar música - Ver TV

- Jugar Videojuegos

CURRICULUM-VITAE

DATOS PERSONALES:

Etapa 4. Diario

metacognitivo




CLASE # 1

Matriz identidad con designación

Código:

#include<stdio.h>

#include<conio.h>

main()

{

int ma[3][3];

ma[0][0]=1;

ma[0][1]=0;

ma[0][2]=0;

ma[1][0]=0;

ma[1][1]=1;

ma[1][2]=0;

ma[2][0]=0;

ma[2][1]=0;

ma[2][2]=1;

for(int x=0;x<3;x++)

{

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

{

printf("%d ",ma[x][y]);

}

printf("\n");

}

getch();

return 0;

}

Periodo: Del 6 de Mayo del 2013 – 14 de Septiembre del 2013

Tiempo: 3 horas

Fecha: Lunes 6 de Mayo del 2013

Docente Guía: Ing. Christian Torres

Matriz identidad con inicialización

Código:

#include<stdio.h>

#include<conio.h>

main()

{

int ma[3][3]={1,0,0,0,1,0,0,0,1};


{


{


}

printf("\n");

}

getch();

return 0;

}

Matriz identidad con proceso

Código:

#include<stdio.h>

#include<conio.h>

main()

{

int ma[3][3];

for(int j=0;j<3;j++)

{

for(int k=0;k<3;k++)

{

if(j==k)

ma[j][k]=1;

else

ma[j][k]=0;

}

}


{


{


}

printf("\n");

}

getch();

return 0;}




CLASE # 3

Matriz y estructura (y sus direcciones de memoria).

Diseñe una estructura que permita almacenar: cédula, nombre, apellido, ciudad,

suledo y departamento de empleados de una fábrica.

Código:

#include<conio.h>

#include<stdio.h>

#include<iostream.h>

#include<string.h>

struct empleo {

char nombre[20];

char apellido[30];

long int cedula;

char ciudad[18];

float sueldo;

char departamento[20];

};

char matriz[1][6][35]={"andres","quintana

macias","1726055070","quito","1000.75","ventas"};

main( )

{

struct empleo A={"vicente","cedeno

bravo",1359786459,"portohueoo",2000.75,"limpieza"};

cout<<"Informacion de la variable estructurada"<<"\n";

cout<<A.nombre<<"\t";

cout<<A.apellido<<"\t";

cout<<A.cedula<<"\t";

cout<<A.ciudad<<"\t";


Tiempo: 3 horas



cout<<A.sueldo<<"\t";

cout<<A.departamento<<"\t"<<"\n";

cout<<"\n"<<"Informacion de la matriz"<<"\n";

for(int c=0;c<6;c++)

cout<<matriz[0][c]<<"\t";

//***************************************************************

cout<<"\n\n"<<"*******"<<"\n";

cout<<"\nMatriz="<<matriz<<"\n";

cout<<"\nV. estructurada="<<&A<<"\n";

cout<<"\n\***Direcciones de memoria de la matriz"<<"\n";

for(int c=0;c<6;c++)

cout<<&matriz[0][c]<<"\t";

cout<<"\n\n***Direcciones de memoria de la variable estructurada"<<"\n";

cout<<&A.nombre<<"\t";

cout<<&A.apellido<<"\t";

cout<<&A.cedula<<"\t";

cout<<&A.ciudad<<"\t";

cout<<&A.sueldo<<"\t";

cout<<&A.departamento<<"\t"<<"\n";

getch();

return 0;

}




CLASE # 4

Estructura

Un programa que nos permita almacenar nombres, sueldo junto con el valor de

venta.

Código:

#include<conio.h>

#include<stdio.h>


struct empleados {

char nombres[20];

float sueldo;

float val_vent;

};

main()

{

struct empleados datos;

textcolor(10);

cprintf("\nIngrese los nombres del empleado: ");

gets(datos.nombres);

cprintf("Ingrese el sueldo: ");

cin>>datos.sueldo;

cprintf("Ingrese el valor de venta: ");

cin>>datos.val_vent;

printf("\nEl nombre del empleado es: %s\n",datos.nombres);

cout<<"El sueldo del empleado es: "<<datos.sueldo<<"\n";

cout<<"El valor de venta del empleado es: "<<datos.val_vent;

getch();

return 0;

}


Tiempo: 2 horas

Fecha: Miércoles 15 de Mayo del 2013


El mismo ejercicio pero con arrays de estructuras.

Código:

#include<conio.h>

#include<stdio.h>


struct empleados {

char nombres[20];

float sueldo;

float val_vent;

};

main()

{

struct empleados datos[2];

textcolor(10);


{

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: %s\n",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(); }




CLASE # 5

Estructuras y funciones.

Código:

#include<stdio.h>

#include<conio.h>


struct empresa{

char nombre[30];

float sueldo;

float ventas;

};

void ingreso(struct empresa &dato);

void mostrar(struct empresa dato);

void bono(float sue);

void main()

{

struct empresa A ;

ingreso(A);

mostrar(A);

bono(A.ventas);

getch();

}

void ingreso(struct empresa &dato)

{

printf("\n*****DATOS DEL EMPLEADO*****\n");

printf("\n Nombre: ");fflush(stdin);cin>>dato.nombre;

printf("\n Sueldo: ");fflush(stdin);cin>>dato.sueldo;

printf("\n Ventas: ");fflush(stdin);cin>>dato.ventas;

}


Tiempo: 3 horas



void mostrar(struct empresa dato)

{

clrscr();

printf("\n Cliente: %s \n Sueldo: %.2f\n Ventas:%.2f",dato.nombre, dato.sueldo,

dato.ventas);

}

void bono(float sue)

{

if (sue>800)

printf("\n Recibe Bono \n");

else

printf("\n Continue trabajando de mejor forma");

}

El mismo ejercicio anterior pero con arrays de estructuras.

Código:


#include<stdio.h>

#include<conio.h>

struct empresa {

char nombre[50];

float sueldo;

float ventas;

};

void ingreso(struct empresa dato[]);

void mostrar(struct empresa dato[]);

void bono(float sue);

void main()

{

struct empresa A[2];

ingreso(A);

mostrar(A);

//bono(A.ventas);

getch();

}

void ingreso(struct empresa dato[])

{

for(int i=0;i<2;i++)

{

printf("\n****DATOS DEL EMPLEADO****\n");

printf("\n Nombre[%i]: ",i+1); fflush(stdin);cin>>dato[i].nombre;

printf("\n Sueldo[%i]: ",i+1); fflush(stdin);cin>>dato[i].sueldo;

printf("\n Ventas[%i]: ",i+1); fflush(stdin);cin>>dato[i].ventas;

}

}

void mostrar(struct empresa dato[])

{

printf("\n\nId Cliente Sueldo Ventas\n");

for(int i=0;i<2;i++)

{

printf("%i %s %.2f %.2f\n",i,dato[i].nombre,dato[i].sueldo,dato[i].ventas

);

bono(dato[i].ventas);

}

}

void bono(float sue)

{

if (sue>800)

printf("Recibe Bono\n\n\n");

else

printf("Continue trabajando de mejor forma\n\n\n");

}

Estructura anidada (externa).

Código:


#include<stdio.h>

#include<conio.h>

struct notas{ float lecciones;

float tareas;

float consultas;

float tgrupal;

float evaluacion;

};

struct SISTEMA {

char nombre[50];

char nivel[30];

struct notas NMC_MAT,NMC_PRO,NMC_ESD;

};

void main()

{

struct SISTEMA A;

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

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

printf("\nNotas de Matematicas\n");

printf("\nLecciones: "); fflush(stdin);

do{

cin>>A.NMC_MAT.lecciones;

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

printf("\nTareas: "); fflush(stdin);

do{

cin>>A.NMC_MAT.tareas;

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

printf("\nConsultas: "); fflush(stdin);

do{

cin>>A.NMC_MAT.consultas;

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

printf("\nTrabajos Grupales: "); fflush(stdin);

do{

cin>>A.NMC_MAT.tgrupal;

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

printf("\nEvaluacion: "); fflush(stdin);

do{

cin>>A.NMC_MAT.evaluacion;

}while(A.NMC_MAT.evaluacion<1 || A.NMC_MAT.evaluacion>15);

getch();

}




CLASE # 7

Estructura (fechas)

Código:


#include<stdio.h>

#include<conio.h>

#include<iomanip.h>

struct fecha {int dia;

int mes;

int anio;

};

void pide_fecha(struct fecha &f);

void ver_fecha(struct fecha f);

void suma(int d);

void pide_fecha(struct fecha &f)

{

char ch;

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

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

}

void ver_fecha(struct fecha f)

{

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

<<setw(4) <<f.anio;

}

main()

{


Tiempo: 3 horas



struct fecha datos;

pide_fecha(datos);

ver_fecha(datos);

getch();

return 0;

}

Direcciones - contenido - punteros


#include<stdio.h>

#include<conio.h>

main()

{

clrscr();

int mat[5]={20,3,8,90,10};

int i, *punt;

for(i=0;i<5;i++)

{

cout<<"Direccion: "<<&mat[i]<<" -----> Contenido de esta direccion de memoria:

"<<mat[i]<<"\n";

}

cout<<"\n";

for(i=0;i<5;i++)

{

cout<<"Direccion: "<<(mat+i)<<" -----> Contenido de esta direccion de memoria:

"<<*(mat+i)<<"\n";

}

punt=mat; //punt=&mat[0]

cout<<"\n";

for(i=0;i<5;i++)

{

cout<<"Direccion: "<<punt<<" -----> Contenido de esta direccion de memoria:

"<<*(punt)<<"\n";

punt++;

}

getch();

return 0;

}




CLASE # 8

Cree una estructura que permita manejar número de horas trabajadas, valor de la

hora, valor de la hora extra, nombre del empleado y salario.

Código:

#include<stdio.h>

#include<conio.h>


struct empleado {

char nombre[30];

int n_h_tra;

float v_hora, v_h_extra, salario;

};

main()

{

struct empleado datos;

struct empleado *punt;

punt=&datos;

int extras;

cout<<"\n Ingrese el nombre del empleado: "; cin>>datos.nombre;

cout<<"\n Ingrese las horas trabajadas: "; cin>>datos.n_h_tra;

cout<<"\n Ingrese el valor de la hora: "; cin>>datos.v_hora;

cout<<"\n Ingrese el valor de la hora extra: "; cin>>datos.v_h_extra;

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;


Tiempo: 2 horas

Fecha: Miércoles 29 de Mayo del 2013


cout<<"\n\n El nombre del empleado es: "<<punt->nombre;

cout<<"\n El salario es: "<<punt->salario;

getch();

}

El mismo ejercicio anterior pero con funciones y array de estructuras.

Código:

#include<stdio.h>

#include<conio.h>


struct empleado {

char nombre[30];

int n_h_tra;

float v_hora, v_h_extra, salario;

};

void ingreso(struct empleado &f);

void calcular(struct empleado &f);

void mostrar(struct empleado f);

main()

{

struct empleado datos[5];


ingreso(datos[x]);


calcular(datos[x]);


mostrar(datos[x]);

getch();

}

void ingreso(struct empleado &f)

{

cout<<"\n\n Ingrese el nombre del empleado: "; cin>>f.nombre;

cout<<"\n Ingrese las horas trabajadas: "; cin>>f.n_h_tra;

cout<<"\n Ingrese el valor de la hora: "; cin>>f.v_hora;

cout<<"\n Ingrese el valor de la hora extra: "; cin>>f.v_h_extra;

}

void calcular(struct empleado &f)

{

struct empleado *punt;

punt=&f;

int extras;

if(punt->n_h_tra>40)

{

extras=punt->n_h_tra-40;

punt->salario=extras*punt->v_h_extra;

punt->salario+=40*punt->v_hora;

}

else

punt->salario+=punt->n_h_tra*punt->v_hora;

}

void mostrar(struct empleado f)

{

cout<<"\n\n El nombre del empleado es: "<<f.nombre;

cout<<"\n El salario es: "<<f.salario;

}




CLASE # 9

Código:

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

void imprimir(control_asis c);

void registrar(control_asis *c)

{

clrscr();

cout<<"Ingreso de Informacion\n";

cout<<"\nIngrese el nombre del estudiante: "; cin>>c->estudiante;

cout<<"\nIngrese el nivel: "; cin>>c->nivel;

cout<<"\nIngrese el paralelo: "; cin>>c->paralelo;

cout<<"\nIngrese el codigo del aula: "; cin>>c->aula;

cout<<"\nIngrese la hora de inicio: "; cin>>c->h_inicio;

cout<<"\nIngrese la hora final: "; cin>>c->h_final;

char ch;

cout<<"\nIngrese la fecha en formato dd/mm/yyyy: "; cin>>c->dia>>ch>>c-

>mes>>ch>>c->anio;


Tiempo: 3 horas

Fecha: Lunes 03 de Junio del 2013


cout<<"\nIngreso finalizado";

}

void imprimir(control_asis c)

{

cout<<"\n\nDatos Ingresados";

gotoxy(0,20);cout<<"\nEstudiante";gotoxy(15,20);cout<<"Nivel";gotoxy(25,20);cout<<

"Paralelo";gotoxy(40,20);cout<<"Aula";gotoxy(50,20);cout<<"Hora

Inicio";gotoxy(65,20);cout<<"Hora Fin";gotoxy(80,20);cout<<"Fecha";

cout<<"\n";

gotoxy(0,21);cout<<c.estudiante;gotoxy(15,21);cout<<c.nivel;gotoxy(25,21);cout<<c.p

aralelo;gotoxy(40,21);cout<<c.aula;gotoxy(50,21);cout<<c.h_inicio;gotoxy(65,21);cout

<<c.h_final;gotoxy(80,21);cout<<setw(2)<<c.dia<<"/"<<setw(2)<<c.mes<<"/"<<setw(

4)<<c.anio<<endl;

}

main()

{

struct control_asis dato;

registrar(&dato);

imprimir(dato);

getch();

return 0;

}

Código:

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

void registrar(control_asis c[], int n)

{

clrscr();

for(int i=0;i<n;i++)

{

cout<<"\n\n\n\nIngreso de Informacion\n";

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<<"\n\nDatos Ingresados";

gotoxy(1,20);cout<<"Estudiante";gotoxy(10,20);cout<<"Nivel";gotoxy(15,20);cout<<"

Paralelo";gotoxy(30,20);cout<<"Aula";gotoxy(40,20);cout<<"Hora

Inicio";gotoxy(55,20);cout<<"Hora Fin";gotoxy(70,20);cout<<"Fecha";

cout<<"\n";

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

gotoxy(0,y);cout<<c[i].estudiante;gotoxy(10,y);cout<<c[i].nivel;gotoxy(15,y);cout<<c[i

].paralelo;gotoxy(30,y);cout<<c[i].aula;gotoxy(40,y);cout<<c[i].h_inicio;gotoxy(55,y);c

out<<c[i].h_final;gotoxy(70,y);cout<<setw(2)<<c[i].dia<<"/"<<setw(2)<<c[i].mes<<"/"

<<setw(4)<<c[i].anio<<endl;

y++;}

}

main()

{

struct control_asis dato[2];

registrar(dato,2);

imprimir(dato,2);

getch();

return 0;

}




CLASE # 11

Listas abiertas inserción al inicio

Código:

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

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

void ver_lista(Lista l);

void main()

{

Lista L1=NULL;

int op;

char nom[30];

do{

clrscr();

cout<<"\n 1. Registrar Nombre";

cout<<"\n 2. Mostrar Linea";

cout<<"\n 3. Salir\n\n ";

do{


Tiempo: 3 horas



cin>>op;

switch(op)

{

case 1:

cout<<"\n Ingrese los nombres: "; gets(nom);

almacenar(&L1,nom);

break;

case 2:

ver_lista(L1);

getch();

}

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

}while(op!=3);

}

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

nodo->sig=*l;

*l=nodo;

}

void ver_lista(Lista l)

{

pnodo n=l;

while(n)

{

cout<<"\n "<<n->nombres;

n=n->sig;

}

}




CLASE # 12

Listas abiertas inserción al inicio y al final

Código:

#include<conio.h>

#include<stdio.h>


#include<string.h>



char nombres[25];


}tipoAlumno;



//Funciones prototipos


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


do{


Tiempo: 2 horas

Fecha: Miércoles 12 de Junio del 2013


cin>>op;

switch(op)

{

case 1:

cout<<"\nREGISTRO DE NUEVO CLIENTE AL INICIO\n";

cout<<"\n Ingrese los nombres: "; fflush(stdin); gets(nom);

almacenar(&L1,nom);

break;

case 2:

cout<<"\nREGISTRO DE NUEVO CLIENTE AL FINAL\n";


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;

}

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;

}

}

void ver_lista(Lista l) {

pnodo n=l;

while(n!=NULL) //n

{


n=n->sig;

}}




CLASE # 13

Listas abiertas inserción al inicio, al final y ordenadamente

Código:

#include<conio.h>

#include<stdio.h>


#include<string.h>



char nombres[25];


}tipoAlumno;






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


main()

{

Lista L1=NULL;

int op;

char nom[30];

do{

clrscr();



Tiempo: 3 horas





cout<<"\n 4. Registrar ordenadamente";


do{

cin>>op;

switch(op)

{

case 1:



almacenar(&L1,nom);

break;

case 2:




break;

case 3:

ver_lista(L1);

getch();

case 4:

cout<<"\nREGISTRO DE NUEVO CLIENTE ORDENADAMENTE\n";


almacenar_ord(&L1,nom);

break;

}

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

}while(op!=5);

}

//*********************************************************************

*********


{

pnodo nodo;


if (nodo==NULL)

{


return;

}




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;

}

}

//*********************************************************************

**********


{

pnodo n=l;

while(n!=NULL) //n

{


n=n->sig;

}

}

//*********************************************************************

*************

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

{

pnodo nodo;


if (nodo==NULL)

{


return;

}




if(!*l) // 1.- A

{

nodo->sig=*l;

*l=nodo;

}

else

{

pnodo aux=*l;

if(strcmp(aux->nombres,c)>0) // 2.- A

{

nodo->sig=*l;

*l=nodo;

}

else // 2.- B

{

while(aux->sig!=NULL&&strcmp(aux->sig->nombres,c)<0)

{

aux=aux->sig;

}

nodo->sig=aux->sig;

aux->sig=nodo;

}

}

}




CLASE # 14

Listas abiertas eliminar duplicados

Código:

#include<conio.h>

#include<stdio.h>


#include<string.h>



char nombres[25];


}tipoAlumno;




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




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

void eliminar_toda_la_lista(Lista *l);

void eli_duplicados(Lista *l);

//*********************************************************************

***********

main()

{


Tiempo: 2 horas

Fecha: Miércoles 19 de Junio del 2013


Lista L1=NULL;

int op;

char nom[30];

do{

clrscr();





cout<<"\n 5. Eliminar un registro cualquiera de la lista";

cout<<"\n 6. Eliminar toda la lista";

cout<<"\n 7. Eliminar duplicados";


do{

cin>>op;

switch(op)

{

case 1:



almacenar_ini(&L1,nom);

break;

case 2:




break;

case 3:

ver_lista(L1);

getch();

break;

case 4:




break;

case 5:

cout<<"\nELIMINAR REGISTRO\n";

cout<<"\n Ingrese el nombre que desea eliminar: "; fflush(stdin); gets(nom);

eliminar_registro_lista(&L1,nom);

break;

case 6:

eliminar_toda_la_lista(&L1);

break;

case 7:

eli_duplicados(&L1);

}

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

}while(op!=8);

}

//*********************************************************************

*********

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

{

pnodo nodo;


if (nodo==NULL)

{


return;

}




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;

}

}

//*********************************************************************

**********


{

if(!l)

{

cout<<"\nLA LISTA ESTA VACIA";

}

else

{

pnodo n=l;

while(n!=NULL) //n

{


n=n->sig;

}

}

}

//*********************************************************************

*************


{

pnodo nodo;


if (nodo==NULL)

{


return;

}




if(!*l) // 1.- A

{

nodo->sig=*l;

*l=nodo;

}

else

{

pnodo aux=*l;


{

nodo->sig=*l;

*l=nodo;

}

else // 2.- B

{


{

aux=aux->sig;

}

nodo->sig=aux->sig;

aux->sig=nodo;

}

}

}

//*********************************************************************

**********

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

{

pnodo nodo,aux;

if(!*l)

{

printf("\nERROR..! Lista vacia\nImposible eliminar registros");

getch();

}

else

{

if(strcmp((*l)->nombres,c)==0)

{

aux=*l;

*l=aux->sig;

free(aux);

printf("\nSe elimino elemento %s con exito",c);

getch();

}

else

{

aux=*l;

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


getch();

}

}

}

}

//*********************************************************************

**********

void eliminar_toda_la_lista(Lista *l)

{

pnodo aux;

if(!*l)

{


getch();

}

else

{

while(*l)

{

aux=*l;

*l=aux->sig;

free(aux);

}

cout<<"\nLISTA ELIMINADA";

getch();

}

}

//*********************************************************************

**********

void eli_duplicados(Lista *l)

{

pnodo aux, aux2, nodo;

aux=*l;

while(aux->sig)

{

aux2=aux;

while(aux2->sig)

{

if(strcmp(aux->nombres,aux2->sig->nombres)==0)

{

nodo=aux2->sig;

aux2->sig=nodo->sig;

free(nodo);

}

else

aux2=aux2->sig;

}

aux=aux->sig;

if(aux==NULL)

break;

}

Etapa 5. DEBERES

Martes, 7 de Mayo del 2013

Sopa de letra de 10 x 10 con 5 palabras ocultas en ella y elaborado con el

compilador Borland C++ utilizando el mecanismo de inicialización.

Código:

#include<stdio.h>

#include<conio.h>

char

sopa_l[10][10]={'R','D','Z','I','G','A','W','Ñ','Y','S','f','E','U','N','I','B','M','N','X','O','S','f','D

','T','T','P','C','R','L','F','A','X','Y','E','W','Ñ','Q','X','A','T','Q','T','Y','R','S','J','J','K','L','W','

Ñ','P','S','N','E','T','A','H','B','A','D','X','A','E','Ñ','G','W','Q','S','R','P','O','R','T','A','T','I','L'

,'F','E','U','O','V','N','W','L','F','W','P','K','E','Q','J','P','Ñ','T','I','S','R','I'};

main( )

{

printf("\n SOPA DE LETRAS.\n");

printf("\n Palabras a buscar: REDES, INTERNET, WIFI, SOFTWARE y

PORTATIL.\n\n\n");


{

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

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

printf("\n\n");

}

getch();

return 0;

}

Ejecución:

Miércoles, 8 de Mayo del 2013

Pasos de parámetros en C++ empleando array como argumentos.

Parámetros y argumentos

Las palabras parámetro y argumento, aunque de significado similar, tiene distintas

connotaciones semánticas: Se denominan parámetros los tipos declarados en el

prototipo (que deben corresponder con los declarados en la definición). Cuando se

realiza una llamada a la función, los "valores" pasados se denominan argumentos. A

veces se utilizan también las expresiones argumentos formales para los parámetros

y argumentos actuales para los valores pasados.

Parámetros (en prototipo o definición) argumentos formales

Valores pasados (en tiempo de ejecución) argumentos actuales

Nota: recuerde que cuando coloquialmente se dice que se pasa una matriz como

argumento de una función, en realidad se está pasando un puntero a su primer

elemento.

Paso de parámetros por valor. - Cuando se llama a la función, se pasa solo el valor de la variable.

- Este método también se llama paso por copia.

- El compilador hace una copia de los parámetros. Esto implica que cualquier

modificación en el valor de los parámetros no se

mantiene cuando termina la función.

- Utilizaremos éste método cuando no necesitemos que se modifiquen

los parámetros con los que se llama.

Paso de parámetros por referencia.

- También se llama paso por dirección.

- Cuando se llama a la función, se pasa la dirección de memoria donde se

encuentra almacenada la variable parámetro.

- El compilador no hace copia, no reserva memoria para los parámetros.

- Usaremos éste método cuando necesitamos que la función modifique el valor de

los parámetros y que devuelva el valor modificado.

Para pasar un parámetro por referencia, hay que poner el operador de

dirección & detrás del tipo del parámetro.

Los arrays como parámetros: No hace falta añadir el operador de dirección & cuando el parámetro

que se pasa es un array.

Los arrays se pasan siempre por referencia aunque no lleven &.

No es necesario indicar el tamaño del array en la declaración.

Ejercicio:

Llenado de un vector de 10 elementos numéricos, ordenándolo de menor a

mayor y mostrándolo con funciones

Bibliografía:

- http://www.zator.com/Cpp/E4_4_5.htm

- Ayudado de un PDF que contiene información acerca del tema.

- Ejercicio que hice en primer nivel.

http://www.zator.com/Cpp/E4_4_5.htm

Miércoles, 22 de Mayo del 2013 Con el último ejercicio realizado en la clase del día 20 de mayo del 2013 y apoyándose en la investigación de la Tarea 3. Elija un tipo de estructura anidada para aplicar y completar el ejercicio, realizar el PDF con la captura de las pantallas y el código empleado. Código:


#include<stdio.h>

#include<conio.h>

struct notas{ float lecciones;

float tareas;

float consultas;

float tgrupal;

float evaluacion;

};

struct SISTEMA { char nombre[50];

char nivel[30];

struct notas NMC_MAT,NMC_PRO,NMC_ESD;

};

/***************PROTOTIPOS DE LAS FUNCIONES PARA INGRESAR LOS

DATOS******************/

void ingresar_datos_matematicas(struct SISTEMA &inf);

void ingresar_datos_programacion(struct SISTEMA &inf);

void ingresar_datos_Estructura_de_Datos(struct SISTEMA &inf);

/************PROTOTIPOS PARA LAS FUNCIONES QUE VAN A MOSTRAR

RESULTADOS**************/

void Mostrar_datos_matematicas(struct SISTEMA inf);

void Mostrar_datos_programacion(struct SISTEMA inf);

void Mostrar_datos_Estructura_de_Datos(struct SISTEMA inf);

/**************************MAIN PRINCIPAL********************/

void main()

{

struct SISTEMA A;

printf("\nIngrese el nombre del estudiante: "); fflush(stdin); cin>>A.nombre;

printf("\nIngrese el nivel: "); fflush(stdin); cin>>A.nivel;

ingresar_datos_matematicas(A);

ingresar_datos_programacion(A);

ingresar_datos_Estructura_de_Datos(A);

printf("\nLas notas de matematicas son las siguientes:\n\n");

Mostrar_datos_matematicas(A);

printf("\nLas notas de programacion son las siguientes:\n\n");

Mostrar_datos_programacion(A);

printf("\nLas notas de estructura de datos son las siguientes:\n\n");

Mostrar_datos_Estructura_de_Datos(A);

getch();

}

/******************************CARGAR DATOS AL

SISTEMA*******************************/

void ingresar_datos_matematicas(struct SISTEMA &inf)

{

printf("\n Notas de Matematicas\n");


do{

cin>>inf.NMC_MAT.lecciones;

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

printf("Tareas: "); fflush(stdin);

do{

cin>>inf.NMC_MAT.tareas;

}while(inf.NMC_MAT.tareas<1 || inf.NMC_MAT.tareas>8);

printf("Consultas: "); fflush(stdin);

do{

cin>>inf.NMC_MAT.consultas;

}while(inf.NMC_MAT.consultas<1 || inf.NMC_MAT.consultas>5);

printf("Trabajos Grupales: "); fflush(stdin);

do{

cin>>inf.NMC_MAT.tgrupal;

}while(inf.NMC_MAT.tgrupal<1 || inf.NMC_MAT.tgrupal>12);

printf("Evaluacion: "); fflush(stdin);

do{

cin>>inf.NMC_MAT.evaluacion;

}while(inf.NMC_MAT.evaluacion<1 || inf.NMC_MAT.evaluacion>15);

}

/**********************************************************************

**************/

void ingresar_datos_programacion(struct SISTEMA &inf)

{

printf("\n Notas de Programacion\n");


do{

cin>>inf.NMC_PRO.lecciones;

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


do{

cin>>inf.NMC_PRO.tareas;

}while(inf.NMC_PRO.tareas<1 || inf.NMC_PRO.tareas>8);


do{

cin>>inf.NMC_PRO.consultas;

}while(inf.NMC_PRO.consultas<1 || inf.NMC_PRO.consultas>5);


do{

cin>>inf.NMC_PRO.tgrupal;

}while(inf.NMC_PRO.tgrupal<1 || inf.NMC_PRO.tgrupal>12);


do{

cin>>inf.NMC_PRO.evaluacion;

}while(inf.NMC_PRO.evaluacion<1 || inf.NMC_PRO.evaluacion>15);

}

/**********************************************************************

**************/

void ingresar_datos_Estructura_de_Datos(struct SISTEMA &inf)

{

printf("\n Notas de Estructura de datos\n");


do{

cin>>inf.NMC_ESD.lecciones;

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


do{

cin>>inf.NMC_ESD.tareas;

}while(inf.NMC_ESD.tareas<1 || inf.NMC_ESD.tareas>8);


do{

cin>>inf.NMC_ESD.consultas;

}while(inf.NMC_ESD.consultas<1 || inf.NMC_ESD.consultas>5);


do{

cin>>inf.NMC_ESD.tgrupal;

}while(inf.NMC_ESD.tgrupal<1 || inf.NMC_ESD.tgrupal>12);


do{

cin>>inf.NMC_ESD.evaluacion;

}while(inf.NMC_ESD.evaluacion<1 || inf.NMC_ESD.evaluacion>15);

}

/*************************************MOSTRAR

DATOS**********************************/

void Mostrar_datos_matematicas(struct SISTEMA inf)

{

cout << "Nombre: " << inf.nombre << endl;

cout << "Nivel: " << inf.nivel << endl;

cout << "Lecciones: " << inf.NMC_MAT.lecciones << endl;

cout << "Tareas: " << inf.NMC_MAT.tareas << endl;

cout << "Consulta: " << inf.NMC_MAT.consultas << endl;

cout << "Trabajo grupal: " << inf.NMC_MAT.tgrupal << endl;

cout << "Evaluacion: " << inf.NMC_MAT.evaluacion << endl;

}

/**********************************************************************

**************/

void Mostrar_datos_programacion(struct SISTEMA inf)

{



cout << "Lecciones: " << inf.NMC_PRO.lecciones << endl;

cout << "Tareas: " << inf.NMC_PRO.tareas << endl;

cout << "Consulta: " << inf.NMC_PRO.consultas << endl;

cout << "Trabajo grupal: " << inf.NMC_PRO.tgrupal << endl;

cout << "Evaluacion: " << inf.NMC_PRO.evaluacion << endl;

}

/**********************************************************************

**************/

void Mostrar_datos_Estructura_de_Datos(struct SISTEMA inf)

{



cout << "Lecciones: " << inf.NMC_ESD.lecciones << endl;

cout << "Tareas: " << inf.NMC_ESD.tareas << endl;

cout << "Consulta: " << inf.NMC_ESD.consultas << endl;

cout << "Trabajo grupal: " << inf.NMC_ESD.tgrupal << endl;

cout << "Evaluacion: " << inf.NMC_ESD.evaluacion << endl;

}


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

Código:


#include<stdio.h>

#include<conio.h>

#include<iomanip.h>


int mes;

int anio;

};



void suma(int d,struct fecha &f);


{

cout<<"La nueva fecha es: "<<setfill('0') <<setw(2) <<f.dia <<'/' <<setw(2) <<f.mes

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

}

void pide_fecha(struct fecha &f)

{

char ch;

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

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

}

void suma(int d,struct fecha &f)

{

int conta=0;

f.dia+=d;

while(f.dia>30)

{

f.dia-=30;

conta++;

}

f.mes+=conta;

}

main()

{

int dias;

struct fecha datos;

pide_fecha(datos);

cout<<"Ingrese los dias a sumar en la fecha ingresada: ";

cin>>dias;

suma(dias,datos);

ver_fecha(datos);

getch();

return 0;

}

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

Código:


#include<conio.h>

#include<dos.h>


int mes;

int anio;

};

void pide_fecha_nac(int d, int m, int a, struct fecha &f);


void pide_fecha_nac(int d, int m, int a, struct fecha &f)

{

f.dia-=d;

f.mes-=m;

f.anio-=a;

}


{

cout<<"\n La persona tiene "<<f.anio<<" anios, "<<f.mes<<" mes(es) y "<<f.dia<<"

dia(s)";

}

main()

{

int dias,d,m,a;

struct fecha datos;

struct date dat;

getdate(&dat);

datos.dia=dat.da_day;

datos.mes=dat.da_mon;

datos.anio=dat.da_year;

char ch;

cout<<"\n Escriba la fecha de nacimiento de la persona (forma dd/mm/aa): ";

cin>>d>>ch>>m>>ch>>a;

pide_fecha_nac(d, m, a, datos);

ver_fecha(datos);

getch();

return 0;

}


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

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

obtener la nueva fecha.

Código:


#include<stdio.h>

#include<conio.h>

#include<iomanip.h>


int mes;

int anio;

};



void suma(int d,struct fecha &f);


{

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

<<setw(4) <<f.anio;

}

void pide_fecha(struct fecha *f)

{

char ch;

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

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

}

void suma(int d,struct fecha *f)

{

int conta=0;

f->dia+=d;

while(f->dia>30)

{

f->dia-=30;

conta++;

}

f->mes+=conta;

}

main()

{

int dias;

struct fecha datos;

struct fecha *p;

p=&datos;

pide_fecha(&datos);

cout<<"Ingrese los dias a sumar en la fecha ingresada: ";

cin>>dias;

suma(dias,&datos);

ver_fecha(datos);

getch();

return 0;

}

Lunes, 17 de Junio del 2013

CREAR UNA FUNCIÓN QUE PERMITA ORDENAR LA LISTA DE NOMBRES

INGRESADOS POR EL TECLADO DE FORMA ALFABÉTICA.

Código:

#include<conio.h>

#include<stdio.h>


#include<string.h>


// Recorrer y añadir al comienzo de la lista


char nombres[25];


}tipoAlumno;








main()

{

Lista L1=NULL;

int op;

char nom[30];

do{

clrscr();






do{

cin>>op;

switch(op)

{

case 1:



almacenar(&L1,nom);

break;

case 2:




break;

case 3:

ver_lista(L1);

getch();

case 4:




break;

}

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

}while(op!=5);

}

//*********************************************************************

*********


{

pnodo nodo;


if (nodo==NULL)

{


return;

}


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;

}

}

//*********************************************************************

**********


{

pnodo n=l;

while(n!=NULL) //n

{


n=n->sig;

}

}

//*********************************************************************

*************


{

pnodo nodo;


if (nodo==NULL)

{


return;

}




if(!*l) // 1.- A

{

nodo->sig=*l;

*l=nodo;

}

else

{

pnodo aux=*l;


{

nodo->sig=*l;

*l=nodo;

}

else // 2.- B

{


{

aux=aux->sig;

}

nodo->sig=aux->sig;

aux->sig=nodo;

}

}

}

Miércoles, 19 de Junio del 2013

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

en clase.

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

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

Código:

#include<conio.h>

#include<stdio.h>


#include<string.h>



char nombres[25];


}tipoAlumno;




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




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

void eliminar_toda_la_lista(Lista *l);

//*********************************************************************

***********

main()

{

Lista L1=NULL;

int op;

char nom[30];

do{

clrscr();





cout<<"\n 5. Eliminar un registro cualquiera de la lista";

cout<<"\n 6. Eliminar toda la lista";


do{

cin>>op;

switch(op)

{

case 1:



almacenar_ini(&L1,nom);

break;

case 2:




break;

case 3:

ver_lista(L1);

getch();

break;

case 4:




break;

case 5:

cout<<"\nELIMINAR REGISTRO\n";

cout<<"\n Ingrese el nombre que desea eliminar: "; fflush(stdin); gets(nom);

eliminar_registro_lista(&L1,nom);

break;

case 6:

eliminar_toda_la_lista(&L1);

}

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

}while(op!=7);

}

//*********************************************************************

*********

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

{

pnodo nodo;


if (nodo==NULL)

{


return;

}




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;

}

}

//*********************************************************************

**********


{

if(!l)

{

cout<<"\nLA LISTA ESTA VACIA";

}

else

{

pnodo n=l;

while(n!=NULL) //n

{


n=n->sig;

}

}

}

//*********************************************************************

*************


{

pnodo nodo;


if (nodo==NULL)

{


return;

}




if(!*l) // 1.- A

{

nodo->sig=*l;

*l=nodo;

}

else

{

pnodo aux=*l;


{

nodo->sig=*l;

*l=nodo;

}

else // 2.- B

{


{

aux=aux->sig;

}

nodo->sig=aux->sig;

aux->sig=nodo;

}

}

}

//*********************************************************************

**********

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

{

pnodo nodo,aux;

if(!*l)

{


getch();

}

else

{

if(strcmp((*l)->nombres,c)==0)

{

aux=*l;

*l=aux->sig;

free(aux);


getch();

}

else

{

aux=*l;

while((aux->sig)&&(strcmp(aux->sig->nombres,c))!= 0)

aux=aux->sig;

if(aux->sig)

{

nodo=aux->sig;

aux->sig=nodo->sig;

free(nodo);


getch();

}

}

}

}

//*********************************************************************

**********

void eliminar_toda_la_lista(Lista *l)

{

pnodo aux;

if(!*l)

{


getch();

}

else

{

while(*l)

{

aux=*l;

*l=aux->sig;

free(aux);

}

cout<<"\nLISTA ELIMINADA";

getch();

}

}

Miércoles, 26 de Junio del 2013

El Ministerio del Interior ha elaborado para el segundo semestre del año 2013 una lista

de delincuentes de más buscados por la justicia ecuatoriana, los datos que contiene esta

lista son: apellidos, nombres, lugar de procesamiento, delito, valor de recompensa y

número de años de sentencia.

Se necesita que el listado esté en función de los más peligrosos. Esto está determinado

por el valor de recompensa. Elabore un programa que permita contar con un menú para

registrar a los más buscados, otra opción para capturar y en dicho proceso debe ser

retirado de la lista de más buscados y llevarlo a la lista de capturados, otra opción

mostrar la lista de más buscados, otra opción mostrar la lista de capturados, otra opción

para conocer el monto que el Gobierno debe invertir en la lista de más buscados y

última opción salir del programa.

Código:

#include<stdio.h>


#include<stdlib.h>

#include<conio.h>

#include<string.h>

typedef struct nodo{

char nombres[30];

char apellidos[30];

char lugar_procesamiento[30];

char delito[30];

int valor_recompensa;

int anios_sentencia;

struct nodo *sig;

}tiponodo;

typedef tiponodo *Lista;

typedef tiponodo *pnodo;

Lista Lmb=NULL;

Lista Lcap=NULL;

void registrar(Lista *l, char no[], char ap[], char lu_pro[], char de[], int v_rec, int

an_sen);

void capturar(Lista *l, Lista *m, char no[], char ap[], char lu_pro[], char de[], int v_rec,

int an_sen);

void mostrar(Lista l);

void eliminar(Lista *l, char no[], char ap[], char lu_pro[], char de[], int v_rec, int

an_sen);

float monto_invertir_en_lmb(Lista l);

main()

{

int op, v_rec, an_sen;

char nom[30], ape[30], lu_pro[30], de[30];

do{

clrscr();

cout<<"\n MINISTERIO DEL INTERIOR\n";

cout<<"\n LISTADO DE LOS DELINCUENTES MAS BUSCADOS POR LA

JUSTICIA ECUATORIANA";

cout<<"\n EN EL ANIO 2013\n";

cout<<"\n 1. Registrar mas buscado";

cout<<"\n 2. Capturar mas buscado";

cout<<"\n 3. Mostrar lista de mas buscados";

cout<<"\n 4. Mostrar lista de capturados";

cout<<"\n 5. Mostrar el monto a invertir por el Gobierno en los mas buscados";


do{

cin>>op;

switch(op)

{

case 1:

cout<<"\nREGISTRO DE MAS BUSCADOS\n";


cout<<"\n Ingrese los apellidos: "; fflush(stdin); gets(ape);

cout<<"\n Ingrese el lugar de procesamiento: "; fflush(stdin); gets(lu_pro);

cout<<"\n Ingrese el delito: "; fflush(stdin); gets(de);

cout<<"\n Ingrese el valor de recompensa: "; fflush(stdin); cin>>v_rec;

cout<<"\n Ingrese el numero de anios de sentencia: "; fflush(stdin); cin>>an_sen;

registrar(&Lmb,nom,ape,lu_pro,de,v_rec,an_sen);

break;

case 2 :

if(!Lmb)

{

cout<<"\n LA LISTA DE MAS BUSCADOS ESTA VACIA\n IMPOSIBLE

CAPTURAR";

getch();

}

else

{

cout<<"\nCAPTURA DE MAS BUSCADOS\n";


cout<<"\n Ingrese los apellidos: "; fflush(stdin); gets(ape);

cout<<"\n Ingrese el lugar de procesamiento: "; fflush(stdin); gets(lu_pro);

cout<<"\n Ingrese el delito: "; fflush(stdin); gets(de);

cout<<"\n Ingrese el valor de recompensa: "; fflush(stdin); cin>>v_rec;

cout<<"\n Ingrese el numero de anios de sentencia: "; fflush(stdin);

cin>>an_sen;

capturar(&Lmb, &Lcap, nom,ape,lu_pro,de,v_rec,an_sen);

}

break;

case 3:

mostrar(Lmb);

getch();

break;

case 4:

mostrar(Lcap);

getch();

break;

case 5:

cout<<"\n El monto a invertir por el Gobierno en la lista de los MB es:

"<<monto_invertir_en_lmb(Lmb)<<" dolares";

getch();

}

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

}while(op!=6);

return 0;

getch();

}

//*********************************************************************

**********************************************************************

**********************************

void registrar(Lista *l, char no[], char ap[], char lu_pro[], char de[], int v_rec, int

an_sen)

{

pnodo nodo;

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

if(nodo==NULL)

{


return;

}

strcpy(nodo->nombres,no);

strcpy(nodo->apellidos,ap);

strcpy(nodo->lugar_procesamiento,lu_pro);

strcpy(nodo->delito,de);

nodo->valor_recompensa=v_rec;

nodo->anios_sentencia=an_sen;


if(!*l) // 1.- A

{

nodo->sig=*l;

*l=nodo;

}

else

{

pnodo aux=*l;

if(aux->valor_recompensa<v_rec) // 2.- A

{

nodo->sig=*l;

*l=nodo;

}

else // 2.- B

{

while((aux->sig!=NULL)&&(aux->sig->valor_recompensa>v_rec))

{

aux=aux->sig;

}

nodo->sig=aux->sig;

aux->sig=nodo;

}

}

}

//*********************************************************************

**********************************************************************

********************************

void capturar(Lista *l, Lista *m, char no[], char ap[], char lu_pro[], char de[], int v_rec,

int an_sen)

{

pnodo aux=*l;

do{

if((strcmp(aux->nombres,no)==0)&&(strcmp(aux-

>apellidos,ap)==0)&&(strcmp(aux->lugar_procesamiento,lu_pro)==0)&&(strcmp(aux-

>delito,de)==0)&&(aux->valor_recompensa==v_rec)&&(aux-

>anios_sentencia==an_sen))

{

registrar(&Lcap, aux->nombres, aux->apellidos, aux->lugar_procesamiento, aux-

>delito, aux->valor_recompensa, aux->anios_sentencia);

eliminar(&Lmb, aux->nombres, aux->apellidos, aux->lugar_procesamiento, aux-

>delito, aux->valor_recompensa, aux->anios_sentencia);

cout<<"\n REO CAPTURADO";

getch();

return;

}

aux=aux->sig;

}while(aux!=NULL);

cout<<"\n NO APARECE EN LA LISTA DE LOS MAS BUSCADOS\n

IMPOSIBLE CAPTURAR";

getch();

}

//*********************************************************************

**********************************************************************

*********************************

void eliminar(Lista *l, char no[], char ap[], char lu_pro[], char de[], int v_rec, int

an_sen)

{

pnodo nodo,aux;

if((strcmp((*l)->nombres,no)==0)&&(strcmp((*l)-

>apellidos,ap)==0)&&(strcmp((*l)->lugar_procesamiento,lu_pro)==0)&&(strcmp((*l)-

>delito,de)==0)&&((*l)->valor_recompensa==v_rec)&&((*l)-

>anios_sentencia==an_sen))

{

aux=*l;

*l=aux->sig;

free(aux);

}

else

{

aux=*l;

while((aux->sig!=NULL)&&(strcmp(aux->sig->nombres,no)!=0)&&(strcmp(aux-

>sig->apellidos,ap)!=0)&&(strcmp(aux->sig-

>lugar_procesamiento,lu_pro)!=0)&&(strcmp(aux->sig->delito,de)!=0)&&(aux->sig-

>valor_recompensa!=v_rec)&&(aux->sig->anios_sentencia!=an_sen))

aux=aux->sig;

if(aux->sig!=NULL)

{

nodo=aux->sig;

aux->sig=nodo->sig;

free(nodo);

}

}

}

//*********************************************************************

**********************************************************************

***********************************

void mostrar(Lista l)

{

if(!l)

{

cout<<"\n LA LISTA ESTA VACIA";

}

else

{

pnodo n=l;

while(n!=NULL) //n

{

cout<<"\n Nombres: "<<n->nombres;

cout<<"\n Apellidos: "<<n->apellidos;

cout<<"\n Lugar de procesamiento: "<<n->lugar_procesamiento;

cout<<"\n Delito: "<<n->delito;

cout<<"\n Valor de recompensa: "<<n->valor_recompensa;

cout<<"\n Anios de sentencia: "<<n->anios_sentencia;

n=n->sig;

cout<<"\n";

}

}

}

//*********************************************************************

**********************************************************************

*************************************

float monto_invertir_en_lmb(Lista l)

{

float monto=0;

if(!l)

{

return monto;

}

else

{

pnodo aux=l;

while(aux!=NULL)

{

monto=monto+aux->valor_recompensa;

aux=aux->sig;

}

return monto;

}

}

Etapa 6. Artículos

de revistas

profesionales

Etapa 7. Materiales

relacionados con la

clase

Etapa 8. Sección

abierta

Etapa 9. ANEXOS

Etapa 10.

INVESTIGACIÓN

portafolio de estructura de datos

Education