PROGRAMACÍON C++ 3

GREIDY SIERRA CORTE 1 1

INTRODUCCIÓN.

Las computadoras fueron diseñadas o ideadas como una herramienta mediante la cual podemos realizar operaciones de cálculo

complicadas en un lapso de mínimo tiempo. Pero, la mayoría de las aplicaciones de este fantástico invento del hombre, son las de

almacenamiento y acceso de grandes cantidades de información.

La información que se procesa en la computadora es un conjunto de datos, que pueden ser simples o estructurados. Los datos simples

son aquellos que ocupan solo una localidad de memoria, mientras que los estructurados son un conjunto de casillas de memoria a las

cuales hacemos referencia mediante un identificador único.

Debido a que por lo general tenemos que tratar con conjuntos de datos y no con datos simples (enteros, reales, booleanos, etc.) que

por sí solos no nos dicen nada, ni nos sirven de mucho, es necesario tratar con estructuras de datos adecuadas a cada necesidad.

INTRODUCCIÓN.

Una estructura de datos es una colección de datos organizados de un modo particular, las estructuras de datos pueden ser de dos

tipos: estructuras de datos estáticas y estructura de datos dinámicas. Las estructuras de datos estáticas son aquellas en las que el

espacio en memoria se define en tiempo de compilación y no pueden ser modificados durante la ejecución del programa,

corresponden a este tipo los arrays (vectores y matrices). Las estructuras de datos dinámicas son aquellas en las que el espacio

ocupado en memoria puede ser modificada en tiempo de ejecución, corresponden a este tipo: las listas, árboles y grafos.

ESQUEMA.

TIPOS DE DATOS ABSTRACTOS (TDA).

Creación de tipos de datos definidos por el usuario.

Permite organizar de manera más eficiente los datos de un programa.

Permite al usuario no restringirse a los datos definidos por el lenguaje.

TAD [Tipos de Datos Abstractos]

Los TAD son definidos por el programador

TAD= Datos + Operaciones (Funciones).

Estructuras de Datos

Estáticas

Símples o Fundamentales

- Boolean.

- char.

- integer

- real.

Compuestas o Estructuradas

- String.

- Arreglos.

- Conjuntos.

- Registros.

- Archivos

Dinámicas

- pilas.

- colas.

- listas.

- Árboles.

- Gráfos.


EJEMPLO

#include<iostream> #include<string> using namespace std; class Empleados{ private: int horas; float valor, salario; string nombre; public : //Acceso a métodos setter Empleados(){} void LeerNombre(string No){ nombre=No; } void LeerHoras(int Ho){ horas=Ho; } void Leervalor (float va){ valor=va; } void CalcularSalario(){ salario=horas*valor; } //Acceso a métodos getter string EscribirNombre(){ return nombre; } int EscribirHorasO{

return horas; } float Escribirvalor(){ return valor; } float Salario(){ return salario; } }; int main(){ system("color 1FM"); //variables y objetos string Nombre; int horas; float valor; Empleados obj1; cout<<"Escriba el nombre, horas, valor"<<endl ; cin>>Nombre>>valor>>horas; obj1.LeerNombre(Nombre); obj1.LeerHoras(horas); obj1.Leervalor(valor); obj1.CalcularSalario(); //imprimir datos de obj1 cout<<"Su salario "<<obj1. EscribirNombre()<<" es "<<obj1.salario(); system("pause"); }

CREAR UN TDA.

Se utilizan las palabras reservadas:

Struct, para las estructuras.

Unión, para crear uniones.

Typedef, para crear un sinónimo o alias para un tipo de dato ya existente.

Enum, para las enumeraciones.

Para manipular un TDA se deben crear y manejar las funciones, no vienen en el lenguaje.

CARACTERISTICAS.

Las estructuras toman una parte de la memoria y se la reparte entre sus miembros.

Cada miembro tiene reservado un espacio para él solo.

El tamaño total que ocupa una estructura en memoria es la suma del tamaño que ocupa cada uno de sus miembros.

CREACION DE TDA EN MEMORIA.

TIPOS DE DATOS:

INT

STRING

DOUBLE

TDA(Tiempo)

VARIABLES:

INT NÚMERO;

STRING NOMBRE;

DOUBLE NOTA;

TIEMPO HORA;

La creación de un tipo de

dato abstracto no reserva

el espacio de memoria, sin

embargo las variables de

este nuevo tipo de dato, si

reservan espacio.


IMPLEMENTACION DE UN TDA.

struct tiempo{ int hora; //0-23 int minuto; //0-59 int segundo; //0-59 };

Los miembros de las estructuras pueden ser de cualquier tipo, excepto un miembro de un mismo tipo.

DECLARACIÓN DE OBJETOS. tiempo objtiempo; tiempo arregloObjestos[10];

Estructuras ej1. //Crea una estructura, establece sus miembros y la imprime. #include<iostream> #include<iomanip> using namespace std; //Definición de la estrctura struct Tiempo{ int hora; int minuto; int segundo; }; //Fin de la estructura tiempo //definición de prototipos de funciones void imprimirUniversal(const Tiempo); void imprimirEstandar(const Tiempo); int main() { system("color 1F"); Tiempo horaCena; cout<<"digite la hora"; cin>>horaCena.hora; while(horaCena.hora<0 || horaCena.hora>23){ cout<<"hora no valida digite nuevamente"; cin>>horaCena.hora; } cout<<"digite los minutos"; cin>>horaCena.minuto; while(horaCena.minuto<0 || horaCena.minuto>61){ cout<<"Minutos no validos digite nuevamente"; cin>>horaCena.minuto;

} cout<<"digite los segundos"; cin>>horaCena.segundo; while(horaCena.segundo<0 || horaCena.segundo>61){ cout<<"Segundos no validos digite nuevamente"; cin>>horaCena.segundo; } cout<<"La cena se servirá a las : "; imprimirUniversal (horaCena); cout<<"En hora universal "; imprimirEstandar(horaCena); system("pause"); } //imprimir la hora con el formatos universal void imprimirUniversal(const Tiempo t){ cout<<setfill(0)<<setw(2)<<t.hora<<" : "<<setw(2)<<t.minuto<<" : "<<setw(2)<<t.segundo<<endl; }// fin de la función impresión universal //imprimir la hora con el formato estandar void imprimirEstandar(const Tiempo t){ cout<<((t.hora==0 || t.hora==12) ? 12: t.hora%12)<<" : "<<setfill (0)<<setw(2)<<t.minuto<<" : "<<setw(2)<<t.segundo<<(t.hora<12 ? 'AM':'PM')<<endl; }


EJEMPLO 2: /*Supongamos que queremos hacer una agenda con los números de teléfono de nuestros amigos. Necesitaríamos un array de Cadenas para almacenar sus nombres, otro para sus apellidos y otro para sus números de teléfono. Esto puede hacer que el programa quede desordenado y difícil de seguir. Y aquí es donde vienen en nuestro auxilio las estructuras.*/ //declaración de estructura #include<stdio.h> #include<iostream> struct estructura_amigo { char nombre[30]; char apellido[40]; char teléfono[10]; char edad; }; //Declaración de una variable con esa estructura. struct estructura_amigo amigo; struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; } amigo; void main() { printf("Escribe el nombre del amigo:");

fflush(stdout); //Sirve para vaciar el buffer de escritura del archivo especificado. //Por lo general cuando damos un prinft o un cout no se imprime directamente en la pantalla. Se almacena en un buffer que se vacía en determinadas ocasiones scanf("%s", &amigo.nombre); printf("Escribe el apellido del amigo:"); fflush( stdout ); scanf("%s", &amigo.apellido); printf("Escribe el número de teléfono del amigo:"); fflush( stdout); scanf("%s",&amigo.telefono); printf("El amigo %s %s tiene el número: %s.\n", amigo.nombre, amigo.apellido, amigo.telefono); system("pause"); }

ARRAYS DE ESTRUCTURAS.

Supongamos ahora que tenemos que guardar la información de varios amigos. Con una variable de estructura solo 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. struct estructuta_amigo amigo[ELEMENTOS]; // La variable definida es amigo, por lo tanto para acceder al primer elemento usaremos amigo[0] y a su miembro nombre: amigo[0].nombre.

EJEMPLO 1:

#include<stdio.h> #include <iostream> #define ELEMENTOS 3 struct estructura_amigo{ char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo[ELEMENTOS]; void main(){ int num_amigo; for(num_amigo=0; num_amigo<ELEMENTOS; num_amigo++){ printf("\n datos del amigo numero %i \n", num_amigo+1); printf("nombre: "); fflush(stdout);

gets(amigo[num_amigo].nombre); //lee con espacios printf("apellido: "); fflush(stdout); gets(amigo[num_amigo].apellido); printf("telefono: "); fflush(stdout); gets(amigo[num_amigo].telefono); printf("edad: "); fflush(stdout); scanf("%i", &amigo[num_amigo].edad); while(getchar()!='\n'); } /* Ahora imprimimos sus datos */ for(num_amigo=0; num_amigo<ELEMENTOS; num_amigo++){ printf("el amigo %s ",amigo[num_amigo].nombre);


printf("%s tiene ", amigo[num_amigo].apellido); printf("%i años ", amigo[num_amigo].edad); printf("y su teléfono es el %s.\n ", amigo[num_amigo].telefono);

} system("pause"); }

INICIALIZAR UNA ESTRUCTURA. A las estructuras se les pueden dar valores iniciales de manera análoga como hacíamos con los arrays. Primero tenemos que definir la estructura y luego cuando declaramos una variable como estructura le damos el valor inicial que queremos. struct estructura_amigo amigo= { "juanjo", "lopez", "592 - 04830", 30 };

EJEMPLO 1: /*Cuando declaramos una variable como estructura le damos el valor inicial que queramos.*/ #include<stdio.h> #include<iostream> struct estructura_amigo{ char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo = { "Juanjo", "López",

"592-04873", 30 }; int main() { system("color 1F"); printf("%s tiene",amigo.apellido); printf("%i años", amigo.edad); printf("y su telefono es el %s.\n", amigo.telefono); system("pause"); }

EJEMPLO 2:#include<stdio.h> #include<iostream> struct estructura_amigo{ char nombre[30]; char apel1ido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo[] = { "Juanjo","López","592-0487B",30, "Marcos","Garmi ndez","405-4823",42,

"Ana","Marti nez","533-5694",20 }; int main(){ for(int i=0;i<3;i++){ printf("%s tiene",amigo[i].apel1ido); printf("%i años", amigo[i].edad); printf("y su telefono es el %s.\n",amigo[i].telefono); } system("pause"); }

PASO DE ESTRUCTURAS A FUNCIONES. int nombre_funcion(struct nombre_de_la_estructura nombre_de_la_variable_estructura)

EJEMPLO 1: #include<stdio.h> #include<iostream> struct estructura_amigo{ char nombre[30]; char apellido[40]; char telefono[10]; int edad; };

struct estructura_amigo amigo={ "juanjo", "López", "454565", 30 }; int suma (struct estructura_amigo arg_amigo) {


return arg_amigo.edad+20; } int main() { printf("%s tiene", amigo.apellido);

printf("%i años", amigo.edad); printf("y dentro de 20 a{os tendrá %i.\n",suma(amigo)); system("pause"); }

EJEMPLO 2:#include<stdio.h> #include<iostream> struct estructura_amigo{ char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo = { "Juanjo", "López", "454565",

30 }; int suma(struct estructura_amigo *arg_amigo) { return arg_amigo->edad+20; } int main(){ printf("%s tiene",amigo.apellido); printf("%i años", amigo.edad); printf("y dentó de 20 años tendrá %i./n",suma(&amigo)); system("pause") ; }

ESTRUCTURAS DENTRO DE ESTRUCTURAS (ANIDADAS).

Es posible crear estructuras como miembros de otras estructuras. Esto tiene diversas utilidades, por ejemplo, tener la estructura de datos más ordenada. /* Una tienda de música quiere hacer un programa para el inventario de los discos, cintas y cd’s que tienen. Para cada título quiere conocer las existencias en cada soporte (cinta, disco, cd), y los datos del proveedor (el que le vende el disco).*/ struct inventario{ char titulo[30]; char autor[40]; int existencias_diseos; int existencias_cintas; int existencias_cd; char nombre_proveedor[40]; char telefono_proveedor[10]; char direccion_proveedor[100]; }; struct estruc_exsitencias{

int discos; int cintas; int cd; }; struct estruc_proveedor{ char nombre_proveedor[40]; char telefono_proveedor[10]; char direccion_proveedor[100] ; }; struct inventario{ char titulo[30]; char autor[40]; struct estruc_existencias existencias; struct estruc_proveedor proveedor; }inventario;

UNIONES. Las unidades tienen un aspecto simular en cuanto a cómo se definen, pero tienen una diferencia fundamental con respecto a las estructuras: los miembros comparten el mismo trozo de memoria. #include<stdio.h> #include<iostream> union _persona{ char nombre[10]; char inicial; }pers; int main(){ printf("Escribir tu nombre : "); gets(pers.nombre); printf("\nTu nombre es : %s\n", pers.nombre); printf ("Tu inicial es : %c\n", pers.inicial); //Cambiamos la inicial pers.inicial='Z';


printf("\nAhora tu nombre es %s\n", pers.nombre); printf ("y tu inicial es %c\n", pers.inicial); system("pause") ; }

Al cambiar el valor de la inicial estamos cambiando también el nombre porque la inicial y la primera letra del nombre son la misma posición de la memoria.

ENUMERACIONES. #include <stdio.h> #include < iostream > #define primero 1 #define segundo 2 #define tercero 3 #define cuarto 4 #define quinto 5 int main(){ int posicion; posicion=segundo; printf("posicion = %i\n",posicion); system ("pause"); }

Existe otra forma de declarar estas constantes y es con las enumeraciones. Las enumeraciones se crean con enum: enum nombre_de_la_enumeración { nombres de las constantes }; enum { primero, segundo, tercero, cuarto, quinto };

Se definieron las constantes primero, segundo,... quinto. Si no especificamos nada la primera constante (primero) toma el valor 0, la segunda (segunda) vale 1, la tercera 2,... Podemos cambiar estos valores predeterminados por los valores que deseemos: enum { pnmero=l, segundo, tercero, cuarto, quinto };

Ahora primero vale 1, segundo vale 2, tercero vale 3,... Cada constante toma el valor de la anterior más uno.

EJEMPLO 1: #include<stdio.h> #include<iostream> enum { primero=1, segundo, tercero, cuarto, quinto } posicion; int main(){ posicion=segundo; printf("posicion = %i\n", posicion); system ("pause"); }


APUNTADORES. (*) <- Símbolo: El uso de apuntadores en c++ es muy importante debido a que permite hacer los programas más eficientes y más flexibles (*) Permiten manipular estructuras dinámicas (Arreglos, Listas, Pilas, Colas) de datos, es decir estructuras de datos que crecen y disminuyen y cualquier tipo de variable. (&) <- Símbolo: La referencia es la obtención de la dirección de una variable.

Una variable por lo general contiene un valor especifico en cambio un apuntador contiene la dirección de memoria de una

variable que tiene valor especifico.

Contador (7):

Contador hace referencia de manera directa a una variable que contiene el valor 7.

DECLARACIÓN.

int *ptrcontador; // Apuntador a una variable int

Los apuntadores se pueden declarar para apuntar a un objeto de cualquier tipo.

La declaración de un puntero no implica la reserva de memoria, salvo 2 bytes para almacenar una dirección en memoria,

por esa razón podría decirse que el puntero, cuando es inicializado por otro elemento, 'vive' de la memoria que le aporta el

objeto al que apunta.

La reserva de memoria dinámica requiere el uso obligado de un puntero, el cual apuntará al comienzo de la zona reservada.

PERADORES PARA APUNTADORES.

El operador direccion(&), es un operador que devuelve una dirección de memoria de su operando.

Los apuntadores se inicializan de la siguiente manera:

int y=5; i nt*ptry; ptry=&y; // Toma la referencia

USO DE APUNTADORES: cout<<*ptry<<endl //imprime el valor de la variable "y", es decir 5, tal como lo haría la instrucción <<cout<<y<<endl;

EJEMPLO 1: #include<iostream> #include<stdio.h> using namespace std; void main(){ int x; int *ptry=&x; cin>>*ptry; //Apuntador utilizado cout<<x; //también como entrada system("pause"); }

EJEMPLO 2: #include<iostream> using namespace std; void main(){ int a=4,z=5; int*ptra; ptra=&a; cout<<" La dirección en memoria de a es"<<ptra<<endl; cout<<" El valor de la variable a es "<<*ptra<<endl ; cout<<" La dirección con ampersam es "<<&a<<endl; system("pause"); }


LLAMADA A FUNCIONES POR REFERENCIA Un parámetro puede ser pasado a una función de dos modos diferentes: por valor y por referencia. Pasarlo por valor implica que la función receptora hace una copia del argumento y trabaja con ese doble del original, cualquier modificación realizada en la variable-copia no producirá ningún cambio en el parámetro enviado. En cambio al pasar un valor por referencia estamos pasando la dirección de memoria del mismo argumento, en este caso no hay otra 'copia‘ del mismo, el dato es uno y el mismo para las dos funciones, la que envía el dato y la que lo recibe.

Función paso por Valor: #include<iostream> using namespace std; int cuboPorValor(int); //prototipo void main(){ int numero=5; cout<<"El valor inicial del numero es "<<numero<<endl; numero=cuboPorValor(numero); cout<<"El valor del cubo de numero con función por valor es "<<numero<<endl; system("pause");

CONTENIDO. NUMERO cuboPorValor(int num) Cuando se llama la función se conectan las dos variables vía parámetros por valor, lo hace que el valor de número se le asigne a num, de ahí en adelante no tienen ninguna relación NUM NUMERO

NUM

EJEMPLO 1: Función paso por referencia #include<iostream> using namespace std; void cuboPorRefcrencia(int *); //Prototipo void main(){ int numero=5;

cout<<"El valor inicial del numero es "<<numero<<endl; cuboPorReferencia(&numero);//pasa la dirección de numero a cuboPorReferencia cout<<"El nuevo valor de numero es: "<<numero<<endl; system("pause"); } void cuboPorReferencia(int *ptrN){ *ptrN>>*ptrN**ptrN**ptrN; }

EXPRESIONES ARITMÉTICAS Un apuntador se puede: Incrementar (++). Disminuir(—). Se puede sumar un entero a un apuntador (+ o +=). Se puede restar un entero de un apuntador (- =). Se puede restar un apuntador de otro. int* ptr;

ptr apuntará a cierta dirección de memoria. La expresión ptr+k es un puntero que apunta a la dirección de ptr sumándole k veces el espacio ocupado por un elemento del tipo al que apunta (en este caso un int).

5

5

5

5


RELACIÓN ENTRE APUNTADORES Y ARREGLOS El nombre de un arreglo se puede considerar como un apuntador constante. Los apuntadores se pueden utilizar para realizar operaciones que involucren subíndices de arreglos, int b[5]; int *ptrB; ptrB = b; *(ptrB+3); //Avanza a la tercera posición del arreglo

EJEMPLO 1: #include<iostream> using namespace std; void main(){ int b[]={10,20,30,40}; //crea un arreglo b de 4 elementos int *bPtr = b; // establece bPtr para que apunte al arreglo b //imprime el arreglo b usando la notación de subíndice de arreglo cout<<"se imprime el arreglo b con: \n \n Notación de subíndice de arreglo \n"; for(int i=0; i<4 ; i++){ cout<<"b[" << i <<"]"<<b[i]<<endl; } //imprime el arreglo b usando el nombre del arreglo y la notacion apuntador/desplazamiento cout<<"\n Notacion apunbntador / desplazamiento en donde el"<<"apuntador es el nombre del arreglo \n" ; for (int desplazamiento = 0; desplazamiento <4 ; desplazamiento++){ cout<<"*(b * "<<desplazamiento << ")="<<*(b+desplazamiento )<< "\n"; } //imprime el arreglo b usando bPrt y la notacion de subíndice de arreglo cout<<"\n Notacion de subíndice de apuntador \n"; for(int j=0 ; j<4 ;j++){ cout<< "bPtr[" <<j<< "] = " <<bPtr[j]<<endl; //imprime el arreglo b usando bPtr y la notacion apuntador/desplazamiento cout<<"Notacion apuntador / desplazamiento \n"; for(int desplazamiento2=0 ; desplazamiento2<4 ; desplazamiento2++){ cout<<"*(bPtr + "<<desplazamiento2 <<") ="<<*( bPtr + desplazamiento2 )<<"\n"; system("pause"); }

ACCESO CON APUNTADORES A ARREGLO.

EJEMPLO 1: Punteros a estructuras. #include<iostream> #include<stdio.h> struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; // Este operador -> significa: da acceso al miembro... del puntero struct estructura_amigo amigo={ "Juanjo", "López", "592-0483",

30 }; struct estructura_amigo *p_amigo; int main(){ p_amigo = &amigo; printf( "%s tiene ", p_amigo->apellido); printf( "%i años ", p_amigo->edad); printf ("y su teléfono es el %s.\n" , p_amigo->telefono); system("pause");


EJEMPLO 2: #include <stdio.h> struct estructura_amigo { char nombre[30]; char apellidólo]; int edad; }; struct estructura_amigo amigo, *p_amigo; void mainO { p.amigo = &amigo; printf("Nombre: ");

fflush(stdout); gets(p_amigo->nombre); printf("Apellido: "); fflush(stdout); gets(p_amigo->apellido); printf("Edad: "); fflush(stdout); scanf( "%i", &p_amigo->edad); /* Mostramos los datos */ printf( "El amigo %s ", p_amigo-»nombre ); printf( "%s tiene ", p_amigo->apellido); printf( "%i años.\n", p_amigo->edad);

PUNTEROS A ARRAYS DE ESTRUCTURAS.

EJEMPLO 1: #include <stdio.h> #include<iostream> #define ELEMENTOS 3 struct estructura_amigo { char nombre[30]; char apellido[40]; char telefono[10]; int edad; }; struct estructura_amigo amigo[] ={ "Juanjo", "López", "504-4342", 30, "Marcos", "Gamindez", "405-4823", 42, "Ana", "Martínez", "533-5694",

20, }; struct estructura_amigo *p_amigo; void main(){ int num_amigo; p_amigo = amigo; // Apuntamos al primer elemento del array. // Ahora imprimimos sus datos for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ){ printf( "El amigo %s ", p_amigo->nombre); printf( "%s tiene ", p_amigo->apellido); printf( "%i años ", p_amigo->edad); printf( "y su teléfono es el %s.\n", p_amigo->telefono); /* y ahora saltamos al siguiente elemento */ p_amigo++; } system("pause");


EJEMPLO 2: #include <stdio.h> #include<iostream> #define ELEMENTOS 3 struct estructura_amigo { char nombre[30]; char apellido[40]; int edad; }; struct estructura_amigo amigo[ELEMENTOS], *p_amigo; void main(){ int num_amigo; // apuntamos al primer elemento p_amigo = amigo; // Introducimos los datos mediante punteros // for (num_amigo=0; num_amigo<ELEMENTOS; num_amigo++) { printf("Datos amigo %i\n",num_amigo); printf("Nombre: ");

fflush(stdout); gets(p_amigo->nombre); printf("apellido: "); fflush(stdout); gets(p_amigo->apellido); printf("Edad: "); fflush(stdout); scanf( "%i", &p_amigo->edad ); // vaciamos el buffer de entrada while(getchar()!='\n'); //saltamos al siguiente elemento p_amigo++; } //Ahora imprimimos sus datos p_amigo = amigo; for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf( "El amigo %s ", p_amigo->nombre); printf( "%s tiene ", p_amigo->apellido ); printf( "%i años.\n", p_amigo->edad); p_amigo++; } system("pause"); }

EJEMPLO 3: /*crea un vector en forma dinámica y encuentra el mayor y el menor, utilizando apuntadores*/ #include<iostream> using namespace std; int n,i; float *ptr,mayor,menor; int main(){ cout<<"DIGITE EL TAMAÑO DEL VECTOR:"; cin>>n; float* p = new float[n]; for(i=0; i<n; i++) { cout<<"p["<<i<<"j= "; cin>>p[i]; } ptr=&p[0];

mayor-p[0]; menor-p[0]; for(i=0; i<n; i++){ if(*(ptr+i)>mayor){ mayor=*(ptr+i); } else if(*(ptr+i)<menor){ menor=*(ptr+i); } } cout<<"EL MAYOR ES: "<<mayor<<endl; cout<<"EL MENOR ES: "<<menor<<endl; system(" pause");

}


Conceptos fundamentales de la

PROGRAMACION ORIENTADA A OBJETO Pensar en objetos es pensar como lo hacemos en la vida real. Si usted mira a su alrededor lo que ve son objetos, personas, animales, libros, computadores, muebles, edificios, etc. La Programación Orientada a Objetos (POO) es un estilo de programación que emplea los objetos como componentes fundamentales para la construcción de programas. Es decir, realiza un modelado de objetos reales, sus características y comportamientos.

CLASES.

Una clase se puede considerar como un patrón para construir objetos, es decir, son tipos de datos definidos por el programador, quien determinar las estructuras de datos y las operaciones asociadas con ese tipo. En C++, un objeto es sólo un tipo de variable de una clase determinada. Cada vez que se construye un objeto de una clase, se crea una instancia de esa clase. Por consiguiente, una clase define las propiedades y comportamiento de un tipo de objeto concreto. Es importante diferenciar entre objetos y clases, una clase es una colección de objetos similares y un objeto es una instancia de una definición de una clase. La clase es simplemente una declaración, no tiene asociado ningún objeto, de modo que no puede recibir mensajes ni procesarlos, esto únicamente lo hacen los objetos. //Sintaxis de La declaración de una clase class nombre_clase{ membro_dato1; miembro_dato2; ............ funcion_miembro1O; funcion_miembro20; };

class elemento{ char nom[20]; char marca [20]; int cantidad; void aumentar_cantidad(int numero); void disminuir_cantidad(int numero); };

EJEMPLO 1: #include<iostream> #include<string> using namespace std; class Empleados { private: int horas; float valor, salario; string nombre; public ://Acesso a métodos getteer Empleados(){} void LeerNombre (string No){ nombre=No; } void LeerHoras (int Ho){ horas=Ho; } void LeerValor (float Va){ valor=Va; } void CalcularSalario(){ salario=horas*valor;} //Acceso a métodos getter string EscribirNombre(){ return nombre; } int EscribirHoras(){ return horas;

} float EscrbirValor(){ return valor; } float salario(){ return salario; } }; int main(){ //Variables y Objetos string Nombre; int horas; float valor; Empleados obj1; cout<<"Escrbia en nombre, horas, valor"<<endl; cin>>Nombre>>valor>>horas; obj1.LeerNombre(Nombre); obj1.LeerHoras(horas); obj1.LeerValor(valor); obj1.CalcularSalario(); //Imprimirlos datos del objeto objl cout<<"Su salario "<<obj1.EscribirNombre()<<" es "<<obj1.CalcularSalario(); system("pause>null"); }


CONSTRUCTORES. EJEMPLO 1: #include<string> #include <iostream> #include <math.h> using namespace std; class Paciente{ private: string Nombre,criterio; float peso,talla,Imc; public: Paciente(string nombre2, float peso2, float talla2){ Nombre=nombre2; peso=peso2; talla=talla2;} void CalcularIMC(){ Imc=(float) (peso/pow(talla,2)); } string obtenerIMC(){ if(Imc<16){ criterio="lngreso al hospital"; } if(Imc>16 & Imc<17){ criterio="infrapeso"; } if(Imc>=17 & Imc<18){ criterio="Bajo de peso"; } if(Imc>=18 & Imc<25){ criterio="Peso Normal (Saludable)"; } if(Imc>=25 & Imc<30){

criterio="Sobrepeso (Obsidad grado 1)"; } if(Imc>=30 & Imc<35){ criterio="Sobrepeso (Obsidad grado 2)"; } if(Imc>=35 & Imc<40){ criterio="5obrepeso (Obsidad grado 3)"; } if(Imc>=40){ criterio="Sobrepeso (Obsidad mórbida grado 4)"; } return "El estado del paciente es "+ criterio; } }; int main(){ string Nombre; float peso,talla; cout<<"Digite el Nombre"; cin>>Nombre; cout<<"Digite el peso "; cin>>peso; cout<<"Digite la talla"; cin>>talla; //Paciente Paciente1; Paciente Paciente1(Nombre,peso,talla); Paciente1.CalcularIMC(); cout<<Paciente1.obtenerIMC(); system("pause");

}


HERENCIA. Es la propiedad que permite la creación de clases a partir de clases que ya existen, las cuales heredan característica y funciones de las clases existentes. En c++ la clase original se llama clase base; y las clases definidas a partir de dicha clase base se llaman clases derivadas. Las clases derivadas pueden heredar atributas de la base pero también pueden adicionar sus propias características y funciones.

EJEMPLO 1: #include <iostream> #include <string> using namespace std; class Empleado{ protected: string Nombre, Puesto, Departamento; public: Empleado(){} Empleado(string NO, string PU, string DE ){ Nombre=NO;Puesto=PU;Departamento=DE; } string getNombre(){ return Nombre; } string getPuesto(){ return Puesto; } string getDepartamento(){ return Departamento; } }; class Asalariado : public Empleado{ float SalarioM, Salario; public: Asalariado(){} Asalariado(string no,string pu,string de,float SM):Empleado(no,pu,de){ SalarioM=SM;

} void setSalarioMen(float Sa ){ SalarioM=Sa; } float getCalcularSalario(){ Salario=SalarioM/2; return Salario; } }; int main(){ string Nombre,Puesto,Departamento; float SalM; cout<<"DIGITE EL NOMBRE \n"; cin>>Nombre; cout<<"DIGITE EL Puesto \n"; cin>>Puesto; cout<<"DIGITE EL Departamento \n"; cin>>Departamento; cout<<"DIGITE EL salario \n"; cin>>SalM; Asalariado objAsalariado = Asalariado(Nombre,Puesto,Departamento,SalM); cout<<"el nombre"<<objAsalariado.getNombre(); cout<<"el salario es"<<objAsalariado.getCalcularSalario(); }


ESTRUCTURA DE DATOS DINÁMICAS. A diferencia de las estructuras de datos estáticas, como arreglos, estructuras y clases, en las que su tamaño se establece durante la compilación y permanece inalterable durante la ejecución del programa, las EDD pueden aumentar o disminuir su tamaño a medida que se ejecuta el programa.

LISTAS ENLAZADAS. Son colecciones de elementos (llamados nodos) dispuestos uno a continuación del otro, conectados por apuntadores (enlaces). Los nodos son objetos de una clase auto-referenciada, cuyos datos miembro se dividen en dos partes: una parte que contiene la información del objeto (características) que puede ser uno a varios datos de diferentes tipos, y la segunda parte que contiene un apuntador del mismo tipo de la clase, que guarda la dirección del siguiente elemento de la lista.

Una representación gráfica de una EDD formada con objetos de una clase auto-referenciada.

En la gráfica se observa una serie de objetos conectados entre sí por apuntadores, que a su vez son datos miembros de la clase; el último apuntador es nulo (no apunta a nada) para representar el final de la EDD.

CLASES AUTO - REFERENCIADAS Una clase Auto - referenciada contiene un miembro apuntador que apunta a un objeto de una clase del mismo tipo de clase. class Nodo{ private: int datos; Nodo *siguientePtr; // Miembro apuntador que apunta a un tipo de dato de tipo Nodo. public: Nodo(int); void establecerDatos( int); int obtenerDatos() const; void establecerSiguientePtr(Nodo *); Nodo *obtenerSiguiente() const; }; // Fin de la clase Nodo

El miembro siguientePtrse conoce como un enlace, es decir se usa para enlazar un objeto con otro de su mismo tipo.

Los objetos de clases auto - referenciadas pueden enlazarse entre sí para formas listas pilas y colas.

Dos objetos de una clase auto - referenciada enlazados entre sí.


ASIGNACIÓN DE MEMORIA DINÁMICA. En algunos casos, no se puede saber con anterioridad a la ejecución cuantos elementos tendrá dichas variables, y la mejor solución es crear un arreglo lo suficientemente grande y en algunos casos desperdiciar memoria. La forma de resolver este inconveniente en C++ es la utilización de apuntadores y de ciertos operadores especiales que permiten gestionar una parte de la memoria llamada memoria dinámica. Los operadores new y delete hacen posible la reserva de memoria durante la ejecución del programa, para variables asignadas dinámicamente.

OPERADOR NEW. El operador new asigna un bloque de memoria del tamaño del tipo de dato, que puede ser cualquier tipo integrado (int, double, etc.), o un tipo de dato estructura o clase. El operador new devuelve un apuntador con la dirección del bloque de memoria asignado.

//Sintaxis para la utilización del operador new tipo *apuntador=new tipo; //Para variables u objetos de cualquier tipo tipo *apuntador=new tipo[tamaño]; //Para arreglos de cualquier tipo y cualquier tamaño o bien tipo *apuntador; apuntador=new tipo; //Asignación de memoria dinámica int main(){ int *ptr=new int; //Reserva memoria dinámica para una variable entera Cliente *ptr1 =new Cliente; //Reserva memoria dinámica para una variable entera o bien Int tam; cin>>tam; double ‘apuntador; apuntador=new double[tam]; }

Asignar un valor o inicializar la memoria que se ha reservado. //Asignación de memoria dinámica int main(){ int *prt = new int (0); //inicializa en 0 la memoria dinámica para una variable entera cliente *ptrl = new cliente("Jessica", 00l);//lnicializa un objeto de la clase cliente //con memoria dinámica, a través de su constructor }

OPERADOR DELETE. Para casos en los cuales la capacidad de memoria dinámica no es suficiente, o se ha dejado de utilizar un bloque de memoria asignado por new, se puede liberar el espacio de memoria y de esta forma dejarlo disponible para otros usos mediante el operador delete, la sintaxis para su utilización es: //Asignación de memoria dinámica int main(){ int *ptr»new; int(0); //Inicializa en O la memoria dinámica para una variable entera delete ptr; //Libera la memoria, el apuntador se puede continuar usando cliente *ptrl=new clienteO'Pedro’', 001); //Inicializa un objeto de la clase cliente con memoria //dinámica, a través de su constructor delete ptr1; //Libera la memoria, el apuntador se puede continuar usando }


LISTAS ENLAZADAS. Una lista enlazada es una colección o secuencia de elementos (nodos), uno detrás del otro, en la que cada elemento se conecta al siguiente a través de un apuntador que se conoce como enlace.

LISTAS.

La lista es un TAD, que consta de una secuencia de elementos llamados nodos.

Nodo: Datos (Información).

Enlace o apuntador (Apunta al siguiente nodo).

CLASIFICACIÓN DE LAS LISTAS ENLAZADAS. Las listas se pueden dividir en cuatro categorías según el número de enlaces que poseen y el recorrido que se puede seguir:

Lista simplemente enlazada: cada nodo tiene un único enlace que lo conecta con el siguiente; solo se pueden recorrer en sentido directo, hacia delante.

Las operaciones básicas sobre una lista simple son: Insertar nodo.

Eliminar nodo.

Buscar nodo.

Mostrar lista.

Eliminar lista. Los nodos forman una secuencia desde el primer elemento al último elemento. El primer nodo se enlaza al segundo, éste se enlaza al tercero y así sucesivamente hasta llegar al último nodo, que debe ser representado de forma diferente para especificar que este nodo no se enlaza a ningún otro.

EJEMPLO 1: //crea una lista encadenada con los números de 1 a 4 #include <iostream> using namespace std; struct nodo{ int clave; nodo *sig; }; void main(){ nodo *L; nodo *p; int i; L = NULL; // Crea una lista vacia

for (i = 1; i <= 4; i++){ //Reserva memoria para un nodo p = new nodo; p->clave = i; // Introduce la información cout<<p->clave<<'\n'; p->sig = L; /* reorganiza */ L = p; /* los enlaces */ } cout<<"\nLOS DATOS CAPTURADOS SON:\n"; p = L; while (p != NULL){ cout<<p->clave«'\n'; p = p->sig; } system(" pause"); }


EJEMPLO 2: #include<iostream> using namespace std; struct nodo{ int nro; nodo *ste; }; struct nodo *pi, *pa, *pf; void main(){ int numero; cout<<"insertar el numero "<<endl; cin>>numero; //si la lista esta vacia if(pi==NULL){ pi=new(nodo); pi-*nro=numero; pi->ste=NULL;//MARCAMOS A SIGUIENTE COMO EL NODO FINAL pf-pi;//puntero inicial trasladado al puntero final } else{ pa=new(nodo); pf->ste=pa; pa->nro=numero; pf-pa; } //mostrar pa-pi; while(pa!=NULL){ cout<<endl<<" Números: "<<pa->nro; pa=pa->ste; //el mismo c=c+l } system("pau$e>null"); }


PILAS Y COLA. Las pilas y las colas son versiones restringidas de las listas enlazadas, en las que solo se pueden llevar acabo algunas de las funciones que se pueden realizar en las listas. Las pilas se conocen también como estructuras LIFO, por su sigla en inglés Last in, First out o último en entrar, primero en salir. Las colas se conocen como estructuras FIFO, First in, First out, o primero en entrar, primero en salir.

PILAS. Una pila es una colección ordenada de elementos (nodos) que permite que se agreguen y eliminen nodos tan solo de la parte superior de la misma. Las entradas de la pila deben ser eliminadas en el orden inverso al que se situaron en la misma. Por ejemplo, si se crea una pila de libros situando primero un diccionario, encima de él una enciclopedia, y encima de ambos una novela, de modo que esta quede en la parte superior, cuando se quitan los libros de la pila, primero debe quitarse la novela, luego la enciclopedia y por último el diccionario. Las funciones primarias en las pilas son insertar (push) que añade un elemento en la parte superior, y quitar (pop) que elimina un elemento de la pila.

COLAS. Las colas son EDD semejantes a las listas enlazadas en las que se permite acceder a la información por uno de los dos extremos, es decir, un elemento se inserta en la parte final de la cola y se suprime o elimina del frente. Las colas representan las líneas de espera, por ejemplo, en un banco o en un almacén; o cuando en una oficina muchos usuarios están conectados a una sola impresora y al enviar sus trabajos para imprimir, estos se organizan en una cola de tal forma que el primero que se envió es el primero en ser procesado y el último en llegar será el último en imprimirse. Las funciones primarias en las colas son insertar (enqueue) que añade un elemento al final de la cola, y eliminar (dequeue) que quita un elemento de la parte inicial de la cola.

ARBOL. Un árbol es una colección de elementos llamados nodos, uno de los cuales es distinguido y llamado raíz junto con una relación ser padre que impone una estructura jerárquica en los nodos. Un nodo, del mismo modo que un elemento en una lista, puede ser del tipo que deseemos. Puede ser un carácter, un string o un número. Algunas veces puede ser conveniente incluir entre los arboles el árbol vacío, el cual no tiene nodos, que representamos con NULL. Ejemplo: La tabla de contenidos de un libro. Esta es un árbol. La raíz, llamada "libro” tiene subárboles correspondientes a los capítulos. Los capítulos tienen subárboles correspondientes a las secciones y estas subárboles correspondientes a las subsecciones.

LOS ARBOLES REPRESENTAN LAS SIGUIENTES CARACTERÍSTICAS.

El primer nodo de un árbol se denomina raíz del árbol. Las flechas que conectan un nodo a otro se llaman arcos o ramas.

Los nodos terminales se denominan hojas.

Los nodos que no son hojas se denominan nodos internos.

En un árbol una rama va de un nodo N1 a un nodo N2, se dice que N1 es el padre de N2 y que N2 es el hijo de N1.

Un camino de N1 a N2 es una secuencia de ramas contiguas que van de N1 a N2.

Cada nodo del árbol puede ser alcanzado (se llega a él) siguiendo un único camino que comienza en el raíz.

La longitud de un camino es el número de ramas que contiene (también el número de nodos menos uno)

El nivel de un nodo es su distancia a la raíz.

Caminos: es una secuencia de nodos en un árbol.

Si hay camino del nodo a al nodo b, decimos a es ancestro de b y b es descendiente de a. En el ejemplo del libro los capítulos son ancestros de las secciones y subsecciones y estos últimos son descendientes de los capítulos.

Un nodo sin descendiente propio se llama hoja. Un subárbol de un árbol es un nodo junto con sus descendientes.

La altura de un nodo es el largo del camino más largo del nodo a una hoja.

La profundidad de un nodo es el largo del camino único de la raíz a dicho nodo.


RECURSIÓN.

Un tema fundamental para los próximos temas es el de recursión. La recursión es muy importante tanto en matemáticas como en computación, pues se usa recursión para definir procedimientos autosimilares. Un objeto es recursivo si en su definición se nombra a sí mismo.

EJEMPLO:

void main(){ int i, n; long double valorAc; valorAc= 1.0; cout<<"Numero entero: "; cin>> n; for(i=1; i<=n; i++) { valorAc = valorAc* i; cout<<"El factorial de "<<n<<" es: \n"<<valorAc; } system("pause>null"); }

FUNCIONES RECURSIVAS

La recursividad es una propiedad que poseen las funciones, por la cual dichas funciones pueden llamarse a sí mismas. Es una herramienta poderosa para la resolución de cierto tipo de problemas que, por sus características serían más difíciles de resolver de forma iterativa (con ciclos). void función1() { función1(); }

EJEMPLO: int factorial(int n){ if(n<2) return 1; else return n * factorial(n-l); } int main(){ int num=0; printf("::CALCULAR FACTORIAL::\n"); printf("Introduce un numero: "); scanf("%i",&num); //Pedir variable num printf("\tEl resultado es: %i\n", factorial(num)); //Llama la función e imprime resultado system("pause>null"); }


ARBOL BINARIO. Los árboles son EDD no lineales en dos dimensiones, a diferencia de listas, pilas y colas. Son muy utilizados para organizar información, por ejemplo para organizar los archivos en sistemas operativos, o para técnicas avanzadas de optimización como inteligencia artificial. El concepto de árbol implica una estructura en la que los datos están organizados de modo que los elementos de información se relacionen a través de ramas. Un árbol binario es un árbol en el que ningún nodo puede tener más de dos subárboles. Cada nodo puede tener cero, uno o dos hijos (subárboles). Es, además, una estructura recursiva, en la que cada nodo es el raíz de su propio subárbol y, si tiene hijos, cada uno es raíz del subárbol correspondiente, que se conocen como subárbol izquierdo y subárbol derecho. Los nodos de los árboles binarios contienen un campo para almacenar datos, y dos apuntadores, uno al subárbol izquierdo y otro al subárbol derecho. Un árbol se divide en subárboles. Un subárbol es cualquier estructura conectada por debajo del nodo raíz. Cada nodo de un árbol es la raíz de un subárbol que se define por ese nodo y todos sus descendientes. El primer nodo de un subárbol se conoce como la raíz del subárbol. A su vez, los subárboles se pueden dividir en subárboles.

ÁRBOLES BINARIOS DE EXPRESIÓN. Los árboles de expresión son una aplicación muy importante de los árboles binarios, que permite organizar expresiones aritméticas compuestas por operadores y operandos. Por ejemplo la expresión (b + c) * a + d.

Los árboles binarios de expresión presentan las siguientes propiedades:

El nodo raíz y los nodos internos (no hojas) deben ser operadores.

Los nodos hoja deben ser operandos.

Cada subárbol es una subexpresión en la que el nodo raíz es un operador. Para construir un árbol de expresión se deben seguir casi las mismas reglas que para evaluar una expresión aritmética, entre ellas la precedencia de los operadores; los operadores que tienen mayor prioridad son los paréntesis, seguidos de los operadores multiplicativos (multiplicación y división) y por último los operadores aditivos (suma y resta); el nodo raíz del árbol será el del operador que tenga menor precedencia y se construye cada subárbol siguiendo el mismo principio. Por ejemplo, en el árbol de la figura anterior, que representa la expresión (b + c) * a + d , el operador que tienen menor precedencia es el segundo más (+), que suma dos subexpresiones (b + c) * a y d , que serán el subárbol izquierdo y derecho respectivamente; de la misma forma, en la primera subexpresión, el operador multiplicación (*) es el que tiene menor precedencia ya que lo que está entre paréntesis se realiza primero, por esto se convierte en la raíz del subárbol izquierdo. Finalmente, la última subexpresión solo tiene un operador suma (+), que se convierte en nodo raíz, con dos hojas (b y c). Los nodos a y d también se convierten en hojas ya que cada subexpresión solo contiene un operando. Este tipo de árboles se utiliza generalmente en compiladores de lenguajes de programación para representar expresiones en memoria.

ÁRBOLES BINARIOS DE BÚSQUEDA.

Los árboles binarios de búsqueda son árboles que organizan datos numéricos no repetidos de forma tal que, dado un nodo, todos los nodos del subárbol izquierdo tienen valores menores, mientras que todos los nodos del subárbol derecho tienen valores mayores. El siguiente árbol, que organiza los datos 5, 4, 9, 1 , 6 , 1 1 , 3 , 1 0 y 1 5 , en ese orden, es un árbol binario de búsqueda:


El procedimiento para la creación de un árbol de este tipo es el siguiente: El primer elemento que se inserta será el nodo raíz, en este caso el 5.

El siguiente elemento, en este caso el 4, se inserta a la izquierda debido a que es menor que la raíz.- El siguiente elemento, en este caso el 9, se inserta a la derecha debido a que es mayor que la raíz.

Este procedimiento se sigue al insertar cada nodo. Como se puede ver, para una serie de datos dada, puede haber muchos árboles binarios de búsqueda, dependiendo del orden en el cual sean insertados en el árbol, por ejemplo para la serie de datos anterior, si los datos se insertan en sentido inverso el árbol binario de búsqueda es:

OPERACIONES EN ÁRBOLES BINARIOS DE BÚSQUEDA. Las operaciones más comunes que se realizan en árboles de búsqueda son:

Inserción de un nodo.

Recorrido del árbol

Búsqueda de un nodo La inserción de un nodo se realiza teniendo en cuenta la forma en que se organizan los datos, como se mencionó anteriormente. El recorrido de un árbol implica que todos los nodos del árbol tienen que ser visitados pero, a diferencia de las listas, pilas o colas, los árboles no tienen un orden específico desde un "primer” nodo a un “últimc” nodo, sino que existen diferentes secuencias de recorrido con el fin de visitarlos todos. Dado un árbol binario que cuenta con una raíz, un subárbol izquierdo y un subárbol derecho se definen tres secuencias de recorrido:

Recorrido preorden: primero se recorre el nodo raíz, luego el subárbol izquierdo y finalmente el subárbol derecho; para procesar cada subárbol se lleva a cabo la misma secuencia, dada la característica recursiva de los mismos.

Recorrido enorden: primero se recorre el subárbol izquierdo, luego el nodo raíz y finalmente el subárbol derecho; para procesar cada subárbol se lleva a cabo la misma secuencia, dada la característica recursiva de los mismos.

Recorrido postorden: primero se recorre el subárbol izquierdo, luego el subárbol derecho y finalmente el nodo raíz; para procesar cada subárbol

RECORRIDO EN ARBOLES BINARIOS. Una de las operaciones más importantes a realizar en un árbol binario es el recorrido de los mismos, recorrer significa visitar los nodos del árbol en forma sistemática, de tal manera que todos los nodos del mismo sean visitados una sola vez. Existen 3 formas diferentes de efectuar el recorrido y todas ellas de naturaleza recursiva, estas son: preorden, postorden e inorden. Estos se definen recursivamente como sigue: El ordenamiento de los nodos da una lista de nodos. Si el árbol es vacío, cualquiera de los tres ordenamientos son la lista vacía. Si T es un nodo simple este nodo en si mismo es la lista (en cualquiera de los tres ordenamientos). En otro caso, sea T un árbol con raíz n y subárboles TI; T2;:::; TK.

INORDEN. PREORDEN. POSTORDEN. 3, 4, 5, 7, 9, 14, 15, 18, 16, 17, 20. A – B – D – E – C – F – G 2, 5, 11, 6, 7, 4, 9, 5 y 2

Recorrer el subárbol izquierdo en entreorden Visitar la raíz. Recorrer el subárbol izquierdo en visitar la raíz. Recorrer el subárbol izquierdo en preorden postordenrecorrer. Recorrer d subárbol derecho en entreorden. recorrer. El subárbol derecho en postorden. El subárbol derecho en preorden. Visitar la raíz.


GRAFOS. Es un conjunto de objetos llamados vértices o nodos unidos por enlaces llamados aristas o arcos, que permiten representar relaciones binarias entre elementos de un conjunto. Un grato es una pareja G = (V, A), donde V es un conjunto de puntos, llamados vértices, y A es un conjunto de pares de vértices, Lomadas aristas. La posición de los vértices no importa, y se puede variar para obtener un grafo más claro.

Prácticamente cualquier red puede ser modelada con un grafo: una red de carreteras que conecta ciudades, una red eléctrica o un alcantarillado.

GRAFOS NO DIRIGIDOS. Los elementos de V se Llaman vértices o nodos.

Los pares de E son no ordenados se Llaman aristas se representan con puntos y Líneas. V= {V1,V2,V3,V45,V5} Cada elemento del conjunto se llama vértice y se representa por un punto {{V1,V1}1{V1IV2},{V1,V5},{V2,V3},{V2,V4},{V3,V4}){V4,V5}} Cada par no ordenado se llama arista y se representan por una línea.

GRAFOS DIRIGIDOS.

V = {V1,V2,V3,V45,V5} E {{vlA/2},{VlA }̂{V2y3}4V3AM},{V4,V3},{V4y4},{V4^S},{VSA'l}1{VS V3U Pares ordenados de vértices

MATRIZ DE ADYACENCIA.


GRADOS DE GRAFOS NO DIRIGIDOS. Se llama grado de v al número de aristas incidentes en v, en caso que la arista es un bucle se cuenta por dos

GREIDY SIERRA TALLERES 26

EJERCICOS. TALLER 1: #include <iostream> using namespace std; int x[5], i=0, cont=0; void datos() { for (i=0;i<=4;i++){ cout<<"INGRESAR EL NUMERO "<<i+1<<endl; cin>>x[i]; } } void suma(){ if ((x[0]+x[1])==x[2]){ cout<<"LA SUMA DE LOS DOS PRIMEROS NUMEROS INGRESADOS, SI ES IGUAL AL TERCERO "<<endl; } else { cout<<"LA SUMA DE LOS DOS PRIMEROS NUMEROS INGRESADOS, NO ES IGUAL AL TERCERO "<<endl; } } void multi(){ for (i=0;i<=4;i++){ if ((x[i]%3)==0){ cont++; } } cout<<"HAY "<<cont++<<" MULTIPLOS DE TRES "<<endl; } void menu() { int op; do { cout<<"///////////////MENU/////////////////"<<endl<<endl; cout<<"1. INGRESAR DATOS AL VECTOR "<<endl; cout<<"2. VERIFICAR SI LA SUMA DE LOS DOS PRIMERO DA EL TERCERO "<<endl; cout<<"3. DETERMINAR CUANTOS NUMEROS SON MULTIPLOS DE TRES"<<endl; cout<<"4. SALIR"<<endl; cin>>op; switch (op){ case 1: datos(); break; case 2: suma(); break; case 3: multi(); break; } } while(op!=4); } void main(){ menu(); } ----------------------------------------------------------------------------------------------------------------------------------------- TALLER 2:

EJERCICIO 1. // Crear una clase que involucre como datos miembro: el color, la forma, la cantidad y el precio de bombas de goma para una piñatería. Definir las funciones miembro: Ingresar datos, borrar datos, imprimir datos e implementar cada una. #include <iostream> #include <iomanip> #include <string> using namespace std; struct Bomba { string color; string forma;


int cantidad; double precio; }; Bomba datos; void Ingresar(){ cout<<"INGRESE EL COLOR: "; cin>>datos.color; cout<<endl; cout<<"INGRESE LA FORMA: "; cin>>datos.forma; cout<<endl; cout<<"INGRESE LA CANTIDAD: "; cin>>datos.cantidad; cout<<endl; while(datos.cantidad<10||datos.cantidad>1000){ cout<<"CANTIDAD NO VALIDA, INGRESE NUEVAMENTE LA CANTIDAD: ", cin>>datos.cantidad; cout<<endl; } cout<<"INGRESE EL PRECIO: "; cin>>datos.precio; cout<<endl; while(datos.precio<0||datos.precio>10000){ cout<<"PRECIO NO VALIDO, INGRESELO NUEVAMENTE: ", cin>>datos.precio; cout<<endl; } } void Borrar(){ for (int i=0;i<=2;i++){ datos.color=""; datos.forma=""; datos.cantidad=0; datos.precio=0; } } void Imprimir(){ cout<<endl; cout<<"\t\t\t\t LISTA \t\t\t\t"<<endl<<endl; cout<<"\t COLOR \t\t FORMA \t\t CANTIDAD \t\t PRECIO"<<endl; cout<<"\t "<<datos.color<<"\t\t"<<datos.forma<<"\t\t "<<datos.cantidad<<"\t\t "<<datos.precio<<endl; cout<<endl<<endl<<endl<<endl; } int main(){ Ingresar(); int op; do { cout<<"\t\t\t\t MENU \t\t\t\t"<<endl<<endl; cout<<"\t 1. IMPRIMMIR DATOS "<<endl; cout<<"\t 2. BORRAR DATOS "<<endl; cout<<"\t 3. SALIR"<<endl; cout<<"\t"; cin>>op; switch (op){ case 1: Imprimir(); break; case 2: Borrar(); break; } } while(op!=3); system("pause"); } -----------------------------------------------------------------------------------------------------------------------------------------


EJERCICIO 2. // Supermercados Cafam desea manejar el kardex de sus artículos teniendo como base el nombre, item, precio y existencias. Necesita manejar entrada de artículos, salida de artículos, búsqueda de algún artículo específico. #include <iostream> #include <string> #include <iomanip> using namespace std; struct Kardex{ int item; int exist; string nombre; float precio; } datos[4]; void productos(){ datos[0].item=1201; datos[0].nombre="Aceite"; datos[0].precio=7500; datos[0].exist=80; datos[1].item=1202; datos[1].nombre="Arroz"; datos[1].precio=2300; datos[1].exist=100; datos[2].item=1203; datos[2].nombre="Azucar"; datos[2].precio=3000; datos[2].exist=40; datos[3].item=1204; datos[3].nombre="Sandia"; datos[3].precio=20000; datos[3].exist=15; } void Imprimir(){ cout<<endl; cout<<"\t\t\t\t LISTADO DE PRODUCTOS \t\t\t\t"<<endl<<endl; cout<<"\t\tITEM NOMBRE PRECIO CANT. EXISTENTE "<<endl; cout<<endl; for (int i=0;i<=3;i++){ cout<<"\t\t"<<datos[i].item<<" "<<datos[i].nombre<<" \t"<<datos[i].precio<<"\t \t"<<datos[i].exist<<endl; } cout<<endl; } void entrada_prod(){ int item_a, cant, cont=0; cout<<"\t\t\t DIGITE EL ITEM DEL PRODUCTO"<<endl; cout<<"\t\t\t"; cin>>item_a; for (int i=0;i<=3;i++){ if (item_a==datos[i].item){ cout<<"\t\t\t DIGITE LA CANTIDAD DE ENTRADA "<<endl; cout<<"\t\t\t"; cin>>cant; datos[i].exist=datos[i].exist+cant; } else{ cont++; } }


if (cont==4) { cout<<" DATO ERRADO O PRODUCTO NO EXISTENTE "<<endl; } system("pause"); } void salida_prod(){ int item_a, cant, cont=0; cout<<"\t\t\t DIGISTE EL ITEM DEL PRODUCTO SALIENTE"<<endl; cout<<"\t\t\t"; cin>>item_a; for (int i=0;i<=3;i++){ if (item_a==datos[i].item){ cout<<"\t\t\t DIGITE LA CANTIDAD SALIENTE DEL PRODUCTO"<<endl; cout<<"\t\t\t"; cin>>cant; while(datos[i].exist<cant){ cout<<"NO HAY LA CANTIDAD DIGITADA, DIGITELA NUEVAMENTE"<<endl, cin>>cant; } datos[i].exist=datos[i].exist-cant; } else{ cont++; } } if (cont==4) { cout<<"DATO ERRADO O PRODUCTO NO EXISTENTE"<<endl; } system("pause"); } void busqueda_pro(){ int item_a, cant, cont=0; cout<<"\t\t\t DIGITE EL ITEM DEL PRODUCTO QUE VA A BUSCAR"<<endl; cout<<"\t\t\t"; cin>>item_a; for (int i=0;i<=3;i++){ if (item_a==datos[i].exist){ cout<<endl; cout<<"\t\t\t\t LISTADO DE PRODUCTOS \t\t\t\t"<<endl<<endl; cout<<"\t ITEM \t\t NOMBRE \t\t PRECIO \t\t CANT. EXISTENTE"<<endl; cout<<"\t "<<datos[i].item<<"\t\t"<<datos[i].nombre<<"\t\t "<<datos[i].precio<<"\t\t "<<datos[i].exist<<endl; cout<<endl<<endl<<endl<<endl; } else{ cont++; } } if (cont==4) { cout<<"DATO ERRADO O PRODUCTO NO EXISTENTE"<<endl; } system("pause"); } int main(){ int op; productos(); Imprimir(); do{ cout<<"\t\t\t\t\t MENU \t\t\t\t"<<endl; cout<<"\t\t\t 1. REGISTRAR ENTRADA"<<endl; cout<<"\t\t\t 2. REGISTRAR SALIDA"<<endl; cout<<"\t\t\t 3. BUSCAR PRODUCTO"<<endl; cout<<"\t\t\t 4. SALIR"<<endl; cout<<"\t\t\t\t"; cin>>op;


switch (op){ case 1: entrada_prod(); system("cls"); Imprimir(); break; case 2: salida_prod(); system("cls"); Imprimir(); break; case 3: busqueda_pro(); system("cls"); Imprimir(); break; } } while (op!=4); } ------------------------------------------------------------------------------------------------------------------------------------------

EJERCICIO 3. //Ingeominas está distribuyendo las zonas climáticas que se presentan en Colombia, dividida por regiones así: Orinoquía, Amazónica, Andina, Caribe, Insular, Pacífica. Cada una de estas regiones tiene unas zonas principales que deben involucrar código de región, nombre, fecha de fundación, cantidad de habitantes. #include <iostream> #include <string> using namespace std; class zonas{ private: string region, zona, codigo_reg, fecha, hab; public: zonas(){} void LeerRegion (string R){ region=R; } void LeerZona (string Z){ zona=Z; } void LeerCodigo (string C_R){ codigo_reg=C_R; } void LeerFecha (string F){ fecha=F; } void LeerCantidad (string H){ hab=H; } string EscribirRegion(){ return region; } string EscribirZona(){ return zona; } string EscribirCodigo(){ return codigo_reg; } string EscribirFecha(){ return fecha; }


string EscribirCantidad(){ return hab; } } info[5]; void Ingresar(string cont, int guar){ string tex, dia, mes, anio; info[guar].LeerRegion(cont); cout<<"\t\t\t DIGITE LA ZONA"<<endl; cout<<"\t\t\t "; cin>>tex; info[guar].LeerZona(tex); cout<<"\t\t\t DIGITE EL CODIGO DE DICHA ZONA"<<endl; cout<<"\t\t\t "; cin>>tex; info[guar].LeerCodigo(tex); cout<<"\t\t\t DIGITE EL DIA EN QUE SE FUNDO:"<<endl; cout<<"\t\t\t "; cin>>dia; cout<<"\t\t\t DIGITE EL MES EN QUE SE FUNDO:"<<endl; cout<<"\t\t\t "; cin>>mes; cout<<"\t\t\t DIGITE EL AÑO EN QUE SE FUNDO:"<<endl; cout<<"\t\t\t "; cin>>anio; info[guar].LeerFecha(dia+"/"+mes+"/"+anio); cout<<"\t\t\t DIGITE EL NUMERO DE HABITANTES "<<endl; cout<<"\t\t\t "; cin>>tex; info[guar].LeerCantidad(tex); } void Imprimir(int guar){ system("cls"); cout<<endl; cout<<"\t\t\t\t ZONAS CLIMATICAS \t\t\t\t"<<endl<<endl; cout<<" REGION ZONA CODIGO FECHA FUNDACION No. HABITANTES"<<endl; for (int i=0;i<=guar;i++){ cout<<" "<<info[i].EscribirRegion()<<" "<<info[i].EscribirZona()<<" "<<info[i].EscribirCodigo()<<" "<<info[i].EscribirFecha()<<" "<<info[i].EscribirCantidad()<<endl; } cout<<endl<<endl<<endl<<endl; } int main(){ int op, acum=0; string a; do{ Imprimir(acum); cout<<"\t\t\t\t MENU DE ZONAS \t\t\t\t"<<endl<<endl; cout<<"\t\t\t 1. ORINOQUIA"<<endl; cout<<"\t\t\t 2. AMAZONICA"<<endl; cout<<"\t\t\t 3. ANDINA"<<endl; cout<<"\t\t\t 4. CARIBE"<<endl; cout<<"\t\t\t 5. INSULAR"<<endl; cout<<"\t\t\t 6. PACIFICA"<<endl; cout<<"\t\t\t 7. SALIR"<<endl; cout<<"\t\t\t\t"; cin>>op; acum++; switch (op){


case 1: a="ORINOQUIA "; Ingresar(a,acum); break; case 2: a="AMAZONICA "; Ingresar(a,acum); break; case 3: a="ANDINA "; Ingresar(a,acum); break; case 4: a="CARIBE "; Ingresar(a,acum); break; case 5: a="INSULAR "; Ingresar(a,acum); break; case 6: a="PACIFICA "; Ingresar(a,acum); break; } } while (op!=7); } -----------------------------------------------------------------------------------------------------------------------------------------

EJERCICIO 4. //Polimérica S.A., líder en Colombia para la fabricación de botellas, desea manejar las ventas de subproductos en forma sistematizada, de tal forma que, se pueda disminuir, aumentar, adicionar las existencias de un producto dado, Dado el siguiente programa identificar que realiza cada uno de los métodos involucrados en el mismo, indicar los métodos(funciones miembro), y los datos miembro. #include <iostream> #include <iomanip> #include <string> using namespace std; struct Botella { string peso,forma, color; int id, existencias; } datos[3]; void base_datos(){ datos[0].color="azul"; datos[0].peso="50"; datos[0].forma="triangular"; datos[0].id=1201; datos[0].existencias=500; datos[1].color="rojo"; datos[1].peso="20"; datos[1].forma="redonda"; datos[1].id=1202; datos[1].existencias=20; datos[2].color="gris"; datos[2].peso="200"; datos[2].forma="rectangular"; datos[2].id=1203; datos[2].existencias=100; } void Imprime(){ cout<<"\t\t\t\t LISTA \t\t\t\t"<<endl<<endl; cout<<" Id \t COLOR PESO \t FORMA \t EXISTENCIAS"<<endl<<endl; for (int i=0;i<=2;i++){ cout<<" "<<datos[i].id<<" "<<datos[i].color<<" "<<datos[i].peso<<" \t"<<datos[i].forma<<" \t"<<datos[i].existencias<<endl; } cout<<endl<<endl; }


void Agregar(){ int item_a, cant, cont=0; cout<<"DIGITE EL ID DEL PRODUCTO "<<endl; cin>>item_a; for (int i=0;i<=2;i++){ if (item_a==datos[i].id){ cout<<"CANTIDAD:"<<endl; cin>>cant; datos[i].existencias=datos[i].existencias+cant; } else{ cont++; } } if (cont==3) { cout<<"ERROR, ID NO EXISTENTE"<<endl; } system("pause"); } void Retirar(){ int item_a, cant, cont=0; cout<<"DIGITE EL ID DEL PRODUCTO A RETIRAR "<<endl; cin>>item_a; for (int i=0;i<=2;i++){ if (item_a==datos[i].id){ cout<<"CANTIDAD:"<<endl; cin>>cant; while(datos[i].existencias<cant){ cout<<"NO EXISTE ESTA CANTIDAD, DIGITELA NUEVAMENTE"<<endl, cin>>cant; } datos[i].existencias=datos[i].existencias-cant; } else{ cont++; } } if (cont==3) { cout<<"ERROR, ID NO EXISTENTE"<<endl; } system("pause"); } int main(){ int op; base_datos(); Imprime(); do{ cout<<"\t\t\t\t MENU \t\t\t\t"<<endl<<endl; cout<<"1. AGREGAR"<<endl; cout<<"2. RETIRAR"<<endl; cout<<"3. SALIR"<<endl; cin>>op; switch (op){ case 1: Agregar(); system("cls"); Imprime(); break; case 2: Retirar(); system("cls"); Imprime(); break; } } while (op!=3);


} ------------------------------------------------------------------------------------------------------------------------- TALLER 3: //Modelo: biblioteca. Se debe llevar registro de: (a) información de libros: título del libro, nombre del autor. ISBN (numero de hasta 7 dígitos), cantidad de ejemplares, número correlativo de préstamo. (B) información de socios: nombre del socio, cédula de identidad, número correlativo de préstamo. (c) información de prestamos: ISBN del libro. C.I. del socio, número correlativo de I préstamo. DeFina la representación de los datos y que operaciones se consideran necesarias para manejar la información de la biblioteca. Describa lo que debe realizar cada operación. #include <iostream> #include <iomanip> #include <stdio.h> #include <string> using namespace std; int i=0; struct info_biblioteca{ char titulo_libro[50]; char nombre_autor[30]; char isbn[7]; char cantidad_ej[5]; char numero_pres[10]; char nombre_socio[30]; char cedula[12]; } datos[4]; void info_libros(){ cout<<"INFORMACION SOBRE LIBROS"<<endl; cout<<endl; for (i=0;i<1;i++){ gets(datos[i].titulo_libro); fflush(stdout ); printf("NOMBRE DEL LIBRO %i: ",i+1); gets(datos[i].titulo_libro); cout<<endl; fflush(stdout ); printf("NOMBRE DEL AUTOR %i: ",i+1); gets(datos[i].nombre_autor); cout<<endl; fflush(stdout ); printf("ISBN %i: ",i+1); gets(datos[i].isbn); cout<<endl; fflush(stdout ); printf("CANTIDAD DE EJEMPLARES %i: ",i+1); gets(datos[i].cantidad_ej); cout<<endl; fflush(stdout ); printf("NUMERO DE PRESTAMO %i: ",i+1); gets(datos[i].numero_pres); } } void Imprimir_libros(){ cout<<endl; cout<<"\t\t\t\t INFORMACION DE LIBROS \t\t\t\t"<<endl<<endl; cout<<" TITULO NOMBRE AUTOR ISBN CANT. EJEMPLARES NUM. PRESTAMO"<<endl; for (int i=0;i<=3;i++){ cout<<datos[i].titulo_libro<<" "<<datos[i].nombre_autor<<" "<<datos[i].isbn<<" "<<datos[i].cantidad_ej<<" "<<datos[i].numero_pres<<endl; } cout<<endl; } void info_socios(){ printf("INFORMACION SOBRE SOCIOS"); cout<<endl; for (i=0;i<1;i++){ gets(datos[i].nombre_socio); fflush(stdout); printf("NOMBRE DEL SOCIO: "); fflush(stdout); gets(datos[i].nombre_socio);


cout<<endl; printf("CEDULA DE IDENTIDAD: "); fflush(stdout); gets(datos[i].cedula); cout<<endl; } system("pause"); } void Imprimir_socios(){ cout<<endl; cout<<"\t\t\t\t INFORMACION DE SOCIOS \t\t\t\t"<<endl<<endl; cout<<"\t\t NOMBRE SOCIO CEDULA IDENTIDAD"<<endl; cout<<endl; for (int i=0;i<=3;i++){ cout<<"\t\t "<<datos[i].nombre_socio<<" "<<datos[i].cedula<<endl; } cout<<endl; } void info_prestamo(){ char pres[10], isbn_a[7], ci[12]; int cont; printf("INFORMACION SOBRE PRESTAMOS"); cout<<endl; for (int i=0;i<=3;i++){ printf("ISBN: "); fflush(stdout); cin>>isbn_a; if (isbn_a==datos[i].isbn){ printf("CEDULA DE IDENTIDAD: "); fflush(stdout); cin>>ci; if (ci==datos[i].cedula){ printf("NUMERO DE PRESTAMO: "); fflush(stdout); cin>>pres; if (pres==datos[i].numero_pres){ cout<<"\t\t\t\t INFORMACION DE PRESTAMO \t\t\t\t"<<endl<<endl; cout<<"\t\t TITULO NOMBRE AUTOR ISBN CANT. EJEMPLARES NUM. PRESTAMO NOMBRE SOCIO CEDULA"<<endl; cout<<endl; cout<<"\t\t"<<datos[i].titulo_libro<<" "<<datos[i].nombre_autor<<" \t"<<datos[i].isbn<<"\t \t"<<datos[i].cantidad_ej<<"\t \t"<<datos[i].numero_pres<<"\t \t"<<datos[i].nombre_socio<<"\t \t"<<datos[i].cedula<<endl; } cout<<endl; } else{ cont++; } } if (cont==4) { cout<<" DATO ERRADO O PRODUCTO NO EXISTENTE "<<endl; } system("pause"); } cout<<endl; system("pause"); } void main(){ int op; do{ cout<<"\t\t\t\t\t MENU \t\t\t\t"<<endl; cout<<"\t\t\t 1. REGISTRAR LIBROS"<<endl; cout<<"\t\t\t 2. REGISTRAR SOCIO"<<endl; cout<<"\t\t\t 3. REGISTRAR PRESTAMO"<<endl; cout<<"\t\t\t 4. SALIR"<<endl;


cout<<"\t\t\t\t"; cin>>op; switch (op){ case 1: info_libros(); system("cls"); Imprimir_libros(); break; case 2: info_socios(); system("cls"); Imprimir_socios(); break; case 3: info_prestamo(); break; } } while (op!=4); } -------------------------------------------------------------------------------------------------------------------------- PARCIAL 1: #include <stdio.h> #include <iostream> #include <math.h> #include <string> #include <string.h> using namespace std; struct disco{ char nomautor[50]; string fechadelanzamiento; int canciones; }; struct sucursales{ string nombre; int telefono; string direccion; int cantdiscos; struct disco dis[999]; }discotienda[999]; void agregar(struct sucursales z,int *); void buscar(struct sucursales z,char[50],int); int contar(struct sucursales z,int,int); int main(){ int n,i=0,cuenta=0; int *ii=&i; char autor[50]; do{ cout<<" Menu "<<endl; cout<<"1.AGREGAR SUCURSALES CON TODOS SUS DATOS "<<endl; cout<<"2.BUSCAR UN DISCO ESPECIFICO POR AUTOR "<<endl; cout<<"3.CONTAR LA TOTALIDAD DE DISCOS "<<endl; cout<<"4.SALIR "<<endl; cin>>n; switch(n){ case 1: agregar(discotienda[*ii],&i); *ii=*ii+1; break; case 2: cout<<"digite el nombre del autor del disco: "; gets(autor); while(getchar()!='\n'); cout<<"cuantos"<<*ii; for(int j=0;j<*ii;j++){ buscar(discotienda[j],autor,j); }


break; case 3: cuenta=0; for(int j=0;j<*ii;j++){ cuenta=contar(discotienda[j],cuenta,j); } cout<<"Hay "<<cuenta<<" discos entre todas las sucursales de la discotienda"<<endl; break; } } while(n!=4); system("pause"); return 0; } void agregar(struct sucursales z,int *ii){ cout<<"digite el nombre de la sucursal: "<<endl; cin>>discotienda[*ii].nombre; cout<<"digite el telefono de la sucursal: "<<endl; cin>>discotienda[*ii].telefono; cout<<"digite la direccion de la sucursal: "<<endl; cin>>discotienda[*ii].direccion; cout<<"digite la cantidad de discos de la sucursal: "<<endl; cin>>discotienda[*ii].cantdiscos; for(int j=0;j<discotienda[*ii].cantdiscos;j++){ cout<<"digite el nombre del autor del disco: "<<endl; gets(discotienda[*ii].dis[*ii].nomautor); while(getchar()!='\n'); cout<<"cuantos"<<discotienda[*ii].dis[j].nomautor; cout<<"digite la fecha de lanzamiento del disco: "<<endl; cin>>discotienda[*ii].dis[j].fechadelanzamiento; cout<<"digite la cantidad de canciones del disco: "<<endl; cin>>discotienda[*ii].dis[j].canciones; } } void buscar(struct sucursales z,char autor[50],int j){ for(int k=0;k<discotienda[j].cantdiscos;k++){ cout<<"------"<<j; cout<<"cant de canciones del disco del autor: "<<discotienda[j].dis[k].nomautor<<endl; if(strcmp(discotienda[j].dis[k].nomautor,autor)==0){ cout<<"cant de canciones del disco del autor: "<<discotienda[j].dis[k].canciones<<endl; } } } int contar(struct sucursales z,int cuenta,int j){ return cuenta+discotienda[j].cantdiscos; } -------------------------------------------------------------------------------------------------------------------------- TALLER 4:

EJERCICIO 1. //Elaborar un programa que permita leer dos números de tipo real en la función principal; que en una función los intercambie vía parámetros por referencia y los imprima en la función principal. #include<stdio.h> #include<iostream> using namespace std; void intercambio(float *ptrN1, float *ptrN2){ float A; A=*ptrN1; *ptrN1=*ptrN2; *ptrN2=A; } void main(){ float num1, num2; cout<<"digite el numero 1: "; cin>>num1; cout<<"digite el numero 2: "; cin>>num2;


cout<<"el valor inicial de los numeros es: "<<num1<<" y "<<num2<<" respectivamente"<<endl; intercambio(&num1, &num2); cout<<"el nuevo valor del numero 1 es: "<<num1<<endl; cout<<"el nuevo valor del numero 2 es: "<<num2<<endl; system("pause"); } --------------------------------------------------------------------------------------------------------------------------

EJERCICIO 2. //Elaborar un programa que permita leer un numero entero e indique si es capicúa; es capicúa si se lee igual de izquierda a derecha que en sentido contrario. Ejemplo 1991. Usar parámetros por valor y por referencia. #include <iostream> #include <iomanip> using namespace std; int v(int); int num; int main(){ system("cls"); cout<<"PROGRAMAS PARA IDENTIFICAR SI UN ENTERO EN CAPICUA "<<endl<<endl; cout<<"DIGITE UN NUMERO ENTERO: "; cin>>num; cout<<endl; while (num<=0){ cout<<"DIGITO ERRADO, DEBE SER MAYO A 0"<<endl; cout<<"DIGITE UN NUMERO ENTERO: "; cin>>num; cout<<endl; } v(num); system("pause"); } int v(int g){ int inv=0; int dig=0; dig = g / 10; g = g/10; inv = inv * 10 + dig; if (inv==g){ cout<<"EL NUMERO "<<num<<" ES CAPICUA "<<endl<<endl; } else{ cout<<"EL NUMERO "<<num<<" NO ES CAPICUA "<<endl<<endl; } return 0; } -------------------------------------------------------------------------------------------------------------------------

EJERCICIO 3. //Elaborar un programa que permita leer 3 números de tipo entero e imprima el mayor, utilizando una función para leer los números, otra función para obtener y devolver el mayor y una función para imprimir el mayor. Usar parámetros por valor y por referencia. #include <iostream> #include <iomanip> using namespace std; int imp(int); int v[3]; int i=0; void leer_num(){ system("cls"); cout<<"PROGRAMAS PARA IDENTIFICAR EL NUMERO MAYOR "<<endl<<endl; for(i=0; i<3; i++){ cout<<"DIGITE EL NUMERO"<<i+1<<": "; cin>>v[i];


} system("pause"); } void obt_dev(){ int mayor=0; for(i=0; i<3; i++){ if(mayor<v[i]){ mayor=v[i]; } } imp(mayor); system("pause"); } int imprimir(int g){ cout<<"EL NUMERO MAYOR ES: "<<g<<endl; } void main(){ system("cls"); leer_num(); } -------------------------------------------------------------------------------------------------------------------------- TALLER 5: //De un curso de Estructura de datos se desea almacenar el código y la nota de cada estudiante. Para el almacenamiento de los datos se puede almacenar en vectores de longitud n. Realice lo siguiente: a) Los datos deben ser leídos por teclado. b) Calcule el promedio de las notas por estudiante c) Calcule el promedio de las notas por examen d) Imprimir solamente a los estudiantes (código y nota) que obtuvieron una nota por encima de la media aritmética (promedio) de todo el curso. e) Imprima código y nota para la mínima nota y para la máxima nota. #include<iostream> #include<stdio.h> using namespace std; //DECLARACION DE VARIABLES GLOBALES int cant_est; int cant_nt; int cant_nq; int i=0, g=0, j=0; int c=0; double prot; double proq; double prop; double pro_total; double port; double porq; double porp; //ESTRUCTURA DE LOS DATOS DE LOS ESTUDIANTES struct notas{ double parcial; double notas_t; double notas_q; double pro_g; }n[100]; struct datos_estudiante{ char nombre[40]; int codigo; struct notas notas; }; //DECLARACION DE VECTOR DINAMICO Y VARIABLE APUNTADOR void mayor_menor(struct datos_estudiante *est); struct datos_estudiante *est= new struct datos_estudiante[cant_est]; struct datos_estudiante *ptrdatos= est; //DECLARACION DE FUNCION PARA INGRESAR DATOS void ingresar(){ ptrdatos=est; //SOLICITUD DE LA CANTIDAD DE DATOS QUE VA A LEER EL VECTOR cout<<"EQUIVALENCIAS DE NOTAS EN %"<<endl<<endl;


cout<<"PARCIAL: "; cin>>porp; cout<<endl; while(porp<0 && porp>100){ cout<<"ERROR, DIGITE NUEVAMENTE PARCIAL: "; cin>>porp; cout<<endl<<endl; } porp=(porp/100); cout<<"TALLERES: "; cin>>port; cout<<endl; while(port<0 && port>(100-porp)){ cout<<"ERROR, DIGITE NUEVAMENTE TALLERES: "; cin>>port; cout<<endl<<endl; } port=(port/100); cout<<"QUICES: "; cin>>porq; cout<<endl; while(porq<0 && porq>(100-(porp+port))){ cout<<"ERROR, DIGITE NUEVAMENTE QUICES: "; cin>>porq; cout<<endl<<endl<<endl; } porq=(porq/100); cout<<"INFORMACION DE ESTUDIANTES"<<endl<<endl; cout<<"CANTIDAD DE ESTUDIANTES: "; cin>>cant_est; cout<<endl<<endl; //SE INGRESA LA CANTIDAD DE DATOS ESTABLECIDAS ANTERIORMENTE for(i=0; i<cant_est;i++){ while(getchar()!='\n'); cout<<"INFORMACION DE ESTUDIANTE"<<endl<<endl; cout<<"NOMBRE "<<i+1<<": "; fflush(stdout); gets(ptrdatos->nombre); cout<<endl; cout<<"CODIGO DE "<<ptrdatos->nombre<<": "; cin>>(ptrdatos->codigo); cout<<endl; //SE DIGITAN LAS NOTAS DE TALLERES cout<<endl; cout<<"INFORMACION DE NOTAS"<<endl<<endl<<endl; cout<<"NOTA DEL PARCIAL DE "<<ptrdatos->nombre<<": "; cin>>n[0].parcial; cout<<endl<<endl; while(n[0].parcial<0 && n[0].parcial>5){ cout<<"ERROR, DIGITE NUEVAMENTE LA NOTA DEL PARCIAL DE "<<ptrdatos->nombre<<": "; cin>>n[0].parcial; cout<<endl<<endl; } cout<<"CANTIDAD DE TALLERES: "; cin>>cant_nt; cout<<endl; while(cant_nt<0 && cant_nt>100){ cout<<"ERROR, DIGITE NUEVAMENTE LA CANTIDAD DE TALLERES: "; cin>>cant_nt; cout<<endl; } for(j=0; j<cant_nt; j++){ cout<<"NOTA "<<j+1<<" DE TALLERES DE "<<ptrdatos->nombre<<" "<<ptrdatos->codigo<<": "; cin>>(n[j].notas_t); cout<<endl; while(n[j].notas_t<0 && n[j].notas_t>5){


cout<<"ERROR, DIGITE NUEVAMENTE LA NOTA "<<j+1<<" DE TALLERES DE "<<ptrdatos->nombre<<" "<<ptrdatos->codigo<<": "; cin>>(n[j].notas_t); cout<<endl; ptrdatos++; } } //SE DIGITAN LAS NOTAS DE QUICES cout<<endl; cout<<"CANTIDAD DE QUICES: "; cin>>cant_nq; cout<<endl; while(cant_nq<0 && cant_nq>100){ cout<<"ERROR, DIGITE NUEVAMENTE LA CANTIDAD DE QUICES: "; cin>>cant_nq; cout<<endl; } for(g=0; g<cant_nq; g++){ cout<<"NOTA "<<g+1<<" DE QUICES DE "<<ptrdatos->nombre<<" "<<ptrdatos->codigo<<": "; cin>>(n[g].notas_q); cout<<endl; while(n[g].notas_q<0 && n[g].notas_q>5){ cout<<"ERROR, DIGITE NUEVAMENTE NOTA "<<g+1<<" DE QUICES DE "<<ptrdatos->nombre<<" "<<ptrdatos->codigo<<": "; cin>>(n[g].notas_q); cout<<endl; ptrdatos++; } } cout<<endl<<endl; //SE AUMENTA LA POSICION DE LOS DATOS DE LAS ESTRUCTURAS ptrdatos++; } } void pro_curso(){ ptrdatos=est; int m=0; //SE COMPARA EL CODIGO DIGITADO CON LOS DATOS YA EN SISTEMA cout<<"NOMBRE CODIGO P. TALLERES P. QUICES P. PARCIAL P. TOTAL"<<endl; for(i=0; i<cant_est; i++){ //PROMEDIO DE NOTAS DE TALLERES Y QUICES for(j=0; j<cant_nt; j++){ prot=prot+(n[j].notas_t); } for(g=0; g<cant_nq; g++){ proq=proq+(n[g].notas_q); } prot= ((prot/cant_nt)*port); proq= ((proq/cant_nq)*porq); prop=((n[0].parcial)*porp); pro_total= prot + proq + prop; n[m].pro_g = pro_total; cout<<ptrdatos->nombre<<" "<<ptrdatos->codigo<<" "<<prot<<" "<<proq<<" "<<prop<<" "<<pro_total<<endl; ptrdatos++; } } //FUNCION PARA CALCULAR EL PROMEDIO DE UN ESTUDIANTE ESPECIFICO CON LOS DATOS INGRESADOS ANTERIORMENTE void buscar_est(){ ptrdatos=est; int cod; //SE INGRESA EL CODIGO DEL ESTUDIANTE A LA CUAL SE LE VA A CUALCULAR EL PROMEDIO cout<<"INGRESE EL CODIGO: "; cin>>cod; cout<<endl; //SE COMPARA EL CODIGO DIGITADO CON LOS DATOS YA EN SISTEMA for(i=0; i<cant_est; i++){ if(cod==(ptrdatos->codigo)){ //PROMEDIO DE NOTAS DE TALLERES Y QUICES


for(j=0; j<cant_nt; j++){ prot=prot+(n[j].notas_t); ptrdatos++; } for(g=0; g<cant_nq; g++){ proq=proq+(n[g].notas_q); ptrdatos++; } } ptrdatos++; } //PROMEDIO TOTAL DEL ESTUDIANTE prot= ((prot/cant_nt)*port); proq= ((proq/cant_nq)*porq); prop=((n[0].parcial)*porp); pro_total= prot + proq + prop; cout<<"EL PROMEDIO DE "<<cod<<" ES: "<<" total: "<<pro_total<<" talleres: "<<prot<<" quices: "<<proq<<" parcial: "<<prop<<endl; cout<<endl; } void pro_examen(){ ptrdatos=est; double pro_exa=0; for(i=0; i<cant_est; i++){ pro_exa=pro_exa+(n[0].parcial); ptrdatos++; } pro_exa=pro_exa/cant_est; cout<<"EL PROMEDIO POR EXAMEN ES: "<<pro_exa<<endl; } // FUNCION PARA CALCULAR LA MEDIA ARITMEDICA DE LOS ESTUDIANTES ANTERIORMENTE INGRESADOS void media_arit(){ double media=0; for (int i=0;i<cant_est;i++){ media=media+n[i].pro_g; ptrdatos++; } media=media/cant_est; for (j=0; j<cant_est; j++){ ptrdatos--; } printf("MEDIA: ",media); cout<<endl; printf("LOS ESTUDIANTES QUE OBTUVIERON UN PROMEDIO POR ENCIMA DE LA MEDIA SON: \n"),fflush(stdout); printf("CODIGO: \t"),fflush(stdout); printf("PROMEDIO: \n"),fflush(stdout); for (g=0; g<cant_est; g++){ if (n[g].pro_g>media){ printf("%i \t", ptrdatos->codigo),fflush(stdout); printf("%f\n", n[g].pro_g),fflush(stdout); } ptrdatos++; } } //FUNCION PARA HALLAR EL MENOR Y MAYOR PROMEDIO ENTRE TODOS LOS ESTUDIANTES void mayor_menor(){ double mayor=0; double menor=5; for(c=0; c<cant_est; c++){ //SE VERIFICA CUAL PROMEDIO ES EL MAYOR if((n[c].pro_g>=mayor)){ mayor=(n[c].pro_g); } //SE VERIFICA CUAL PROMEDIO ES EL MENOR else if((n[c].pro_g)<menor){ menor=(n[c].pro_g); } ptrdatos++; }


cout<<"EL ESTUDIANTE "<<"CODIGO: "<<ptrdatos->codigo<<" NOMBRE: "<<ptrdatos->nombre<<" OBTUVO LA MAYOR NOTA: "<<mayor<<endl<<endl; cout<<"EL ESTUDIANTE "<<"CODIGO: "<<ptrdatos->codigo<<" NOMBRE: "<<ptrdatos->nombre<<" OBTUVO LA MENOR NOTA: "<<menor<<endl; } //EN EL MAIN SE COLOCAN TODAS LA FUNCIONES QUE SE HICIERON int main(){ int op; do{ cout<<"\t\t\t\t\t MENU \t\t\t\t"<<endl; cout<<"\t\t\t 1. INGRESAR DATOS ESTUDIANTES"<<endl; cout<<"\t\t\t 2. IMPRIMIR PROMEDIO DEL CURSO"<<endl; cout<<"\t\t\t 3. BUSCAR ESTUDIANTE"<<endl; cout<<"\t\t\t 4. PROMEDIO DE EXAMENES"<<endl; cout<<"\t\t\t 5. NOTAS POR ENCIMA DE LA MEDIA ARITMEICA"<<endl; cout<<"\t\t\t 6. MAYOR Y MENOR NOTA"<<endl; cout<<"\t\t\t 7. SALIR "<<endl; cin>>op; switch (op){ case 1: ptrdatos=est; ingresar(); system("pause"); break; case 2: ptrdatos=est; pro_curso(); system("pause"); break; case 3: ptrdatos=est; buscar_est(); system("pause"); break; case 4: pro_examen(); ptrdatos=est; system("pause"); break; case 5: media_arit(); ptrdatos=est; system("pause"); break; case 6: mayor_menor(); ptrdatos=est; system("pause"); break; } } while (op!=7); } -------------------------------------------------------------------------------------------------------------------------- TALLER 6: /* Escribir una función que verifique si dos listas son iguales (mismos elementos en el mismo orden). Escribir una función que verifique si un elemento x se encuentra en una lista l. Escribir una función que cuente la cantidad de ocurrencias de un elemento x en una lista l. AUTOR: GREIDY SIERRA. FECHA: 18-09-2013. */ #include<iostream> using namespace std; //Captura datos clase autoreferenciada int cant2=0; int cant=0; class Nodo1{ private: int nro; Nodo1 *ste;


public: Nodo1(){ int numero; cout<<"DIGITE EL NUMERO: "; cin>>numero; nro=numero; }; void ste_ptr(Nodo1 *numero){ ste = numero; }; int obtener_nro()const{ return nro; }; Nodo1 *obtener_ste()const{ return ste; }; }; Nodo1 *pa; //Lista Nodo1 *pi; //Elemento que genera class Nodo2{ private: int nro2; Nodo2 *ste2; public: Nodo2(){ int numero2; cout<<"DIGITE EL NUMERO: "; cin>>numero2; nro2=numero2; }; void ste_ptr2(Nodo2 *numero2){ ste2 = numero2; }; int obtener_nro2()const{ return nro2; }; Nodo2 *obtener_ste2()const{ return ste2; }; }; Nodo2 *pa2; //Lista Nodo2 *pi2; //Elemento que genera void ingresar_l1(){ int cant=0; int i=0; pa=NULL; cout<<" El USUARIO INGRESA DATOS A LA LISTA "<<endl<<endl<<endl; cout<<" CANTIDAD DE NUMEROS: "; cin>>cant; cout<<endl; for (i=0; i<cant; i++) { pi = new Nodo1(); cout<<"NUMERO INGRESADO: "<<pi->obtener_nro()<<endl<<endl; //Reorganizacion de elementos pi -> ste_ptr(pa); pa = pi; } cout<<" DATOS CAPTURADOS LISTA 1 "<<endl<<endl<<endl; pi = pa; while (pi!=NULL) { cout<<" "<<pi->obtener_nro()<<endl; pi =pi->obtener_ste(); } } void ingresar_l2(){ int i2=0; pa2=NULL;


cout<<" El USUARIO INGRESA DATOS A LA LISTA "<<endl<<endl<<endl; cout<<" CANTIDAD DE NUMEROS: "; cin>>cant2; cout<<endl; for (i2=0; i2<cant2; i2++) { pi2 = new Nodo2(); cout<<"NUMERO INGRESADO: "<<pi2->obtener_nro2()<<endl<<endl; //Reorganizacion de elementos pi2 -> ste_ptr2(pa2); pa2 = pi2; } cout<<" DATOS CAPTURADOS LISTA 2 "<<endl<<endl<<endl; pi2 = pa2; while (pi2!=NULL) { cout<<" "<<pi2->obtener_nro2()<<endl; pi2 =pi2->obtener_ste2(); } } void verificar_iguales(){ while (pi!=NULL){ if(pi->obtener_nro()==pi2->obtener_nro2()){ cout<<"LOS ELEMENTOS DE LA LISTA 1, SON IGUALES A LOS ELEMENTOS DE LA LISTA 2"<<endl; } else{ cout<<"LOS ELEMENTOS DE LA LISTA 1, SON DIFERENTES A LOS ELEMENTOS DE LA LISTA 2"<<endl; } pi=pi->obtener_ste(); } system("pause"); } void buscar_l1(){ int buscar; cout<<"ELEMENTO QUE DESEA BUSCAR"<<endl; cin>>buscar; pi = pa; while (pi!=NULL){ if(pi->obtener_nro()==buscar){ cout<<"EL ELEMENTO "<<buscar<<" SI ESTÁ EN LA LISTA 1 "<<endl; } else{ cout<<"EL ELEMENTO "<<buscar<<" NO ESTÁ EN LA LISTA 1 "<<endl; } pi = pi->obtener_ste(); } } void buscar_l2(){ int buscar2; cout<<"ELEMENTO QUE DESEA BUSCAR"<<endl; cin>>buscar2; pi2 = pa2; while (pi2!=NULL){ if(pi2->obtener_nro2()==buscar2){ cout<<"EL ELEMENTO "<<buscar2<<" SI ESTÁ EN LA LISTA 1 "<<endl; } else{ cout<<"EL ELEMENTO "<<buscar2<<" NO ESTÁ EN LA LISTA 1 "<<endl; } pi2 = pi2->obtener_ste2(); } } void ocurrencias_l1(){ int buscar; int cont=0; cout<<"ELEMENTO QUE DESEA VERIFICAR OCURRENCIAS"<<endl; cin>>buscar; pi = pa; while (pi!=NULL){


if(pi->obtener_nro()==buscar){ cont++; } pi = pi->obtener_ste(); } cout<<"LA CANTIDAD DE OCURRENCIAS DEL NUMERO "<<buscar<<" EN LA LISTA 1 ES: "<<cont<<endl; } void ocurrencias_l2(){ int buscar2; int cont2=0; cout<<"ELEMENTO QUE DESEA VERIFICAR OCURRENCIAS"<<endl; cin>>buscar2; pi2 = pa2; while (pi2!=NULL){ if(pi2->obtener_nro2()==buscar2){ cont2++; } pi2 = pi2->obtener_ste2(); } cout<<"LA CANTIDAD DE OCURRENCIAS DEL NUMERO "<<buscar2<<" EN LA LISTA 2 ES: "<<cont2<<endl; } void main(){ int op; do{ cout<<"\t\t\t\t * MENU PRINCIPAL * \t\t\t\t"<<endl; cout<<"\t\t\t 1. INGRESAR DATOS"<<endl; cout<<"\t\t\t 2. VERIFICAR LISTAS IGUALES"<<endl; cout<<"\t\t\t 3. BUSCAR ELEMENTO"<<endl; cout<<"\t\t\t 4. CONTAR OCURRENCIAS"<<endl; cout<<"\t\t\t 5. SALIR"<<endl; cin>>op; switch (op){ case 1: int op1; do{ cout<<"\t\t\t\t * MENU CASO 1 * \t\t\t\t"<<endl; cout<<"\t\t\t 1. INGRESAR DATOS LISTA 1"<<endl; cout<<"\t\t\t 2. INGRESAR DATOS LISTA 2"<<endl; cout<<"\t\t\t 3. SALIR"<<endl; cin>>op1; switch (op1){ case 1: ingresar_l1(); break; case 2: ingresar_l2(); break; } } while (op1!=3); break; case 2: verificar_iguales(); break; case 3: int op2; do{ cout<<"\t\t\t\t * MENU CASO 3 * \t\t\t\t"<<endl; cout<<"\t\t\t 1. BUSCAR ELEMENTO EN LISTA 1"<<endl; cout<<"\t\t\t 2. BUSCAR ELEMENTO EN LISTA 2"<<endl; cout<<"\t\t\t 3. SALIR"<<endl; cin>>op2; switch (op2){ case 1: buscar_l1(); break; case 2: buscar_l2(); break; } } while (op2!=3); break; case 4:


int op3; do{ cout<<"\t\t\t\t * MENU CASO 4 * \t\t\t\t"<<endl; cout<<"\t\t\t 1. OCURRENCIAS EN LISTA 1"<<endl; cout<<"\t\t\t 2. OCURRENCIAS EN LISTA 2"<<endl; cout<<"\t\t\t 3. SALIR"<<endl; cin>>op3; switch (op3){ case 1: ocurrencias_l1(); break; case 2: ocurrencias_l2(); break; } } while (op3!=3); break; } } while (op!=5); system("pause"); } -------------------------------------------------------------------------------------------------------------------------- TALLER 7: /* AUTOR: GREIDY SIERRA FECHA: 19-09-2013*/ #include<iostream> #include<string> using namespace std; struct numero{ short int nro; }; struct Nodo{ //anida estructura numero campo; Nodo *ste; Nodo *ant; }; struct Nodo *pi=NULL,*pf=NULL, *pa=NULL, *r; void insertarDatos(numero datos); void insertaCabeza(numero datos); void insertaCola(numero datos); void eliminar_Nodo (int eliminar); void mostrar(); void sumar(int suma); void inser_cab(numero datos){ if(pi==NULL){ pi=r; r->ste=NULL; pf=r; pa=r; } else{ pa= pi; r->ste=pi; pi = r; pa->ant=r; pa=r; } } void inser_cola(numero datos){ if(pf==NULL){ pf=r; pi=r; } else{ pa=pi; while(pa->ste != NULL){


pa = pa->ste; } pf=r; pf->ant=pa; pa->ste=r; } } void insertarDatos(numero datos){ cout<<"INGRESE EL NUMERO "<<endl; cin>>datos.nro; //crea el espacio para el nodo y asigna r al nuevo nodo r = new Nodo(); //datos.nombre se asigna a persona.nombre r->campo.nro=datos.nro; r->ste=NULL; r->ant=NULL; if(pf==NULL && pi == NULL){ //pi = puntero inicial ... pf = puntero final pf=r; pi=r; pa=r; } else if(r->campo.nro <= pi->campo.nro){ inser_cab(datos); } else if(r->campo.nro >= pf->campo.nro){ inser_cola(datos); } else{ pa=pi; Nodo *au = pa; while(pa !=NULL){ if(pa->campo.nro >= r->campo.nro){ au->ste = r; r->ste = pa; pa->ant=r; r->ant=au; return; } au =pa; pa = pa->ste; } //aux=aux->ste;//avanzamos el puntero para que el ciclo no se haga infinito } } void eliminar(){ r=pi; Nodo *au = r; short int eliminar; cout<<"Ingrese el numero que desea eliminar \n"; cin>>eliminar; while(r!=NULL){ cout<<"entra"<<endl; if(r->campo.nro == eliminar){ if(r==pi){ pi=r->ste;//Eliminando la cabeza delete r; return; } else{ cout<<"elimina en cualquier"; au->ste =r->ste;//Eliminando cualquier nodo r->ste->ant = au; r->ste =NULL; // ¿que pasa con pf ? r->ant=NULL; delete r; return;


} } au =r; r=r->ste;//avanzamos el puntero para que el ciclo no se haga infinito } } void mostrar(){ pa=pi; cout<<"\tNUMERO"<<"\t"<<endl; while(pa!=NULL){ cout<<"\t"<<pa->campo.nro; pa=pa->ste; //avanzamos el puntero para que el ciclo no se haga infinito } } void sumar_con(){ int suma; pa= pi; Nodo *au = pa; while(pa !=NULL){ if(pa->campo.nro >= r->campo.nro+1){ suma= pa->campo.nro + r->campo.nro; cout<<"\n LA SUMA DE LOS NUMEROS CONSECUTIVOS DE LA LISTA ES: "<<suma<<endl; return; } else{ cout<<"\n EN ESTA LISTA NO HAY NUMEROS CONSECUTIVOS "<<suma<<endl; } pa = pa -> ste; } } void main(){ int suma = 0; int n;//iniciamos variables a utilizar numero datos; do{ cout<<"\t\t MENU \n"<<endl; cout<<"1. INSERTAR DATOS\n"<<endl; cout<<"2. ELIMINAR DATOS\n"<<endl; cout<<"3. MOSTRAR DATOS\n"<<endl; cout<<"4. SUMA DE NUMEROS CONSECUTIVOS \n"<<endl; cout<<"5. SALIR "<<endl; cin>>n; switch (n) { case 1: insertarDatos(datos); break; case 2: eliminar(); break; case 3: mostrar(); break; case 4: sumar_con(); break; default : break; } } while(n!=5); system("pause > null"); } -------------------------------------------------------------------------------------------------------------------------- PARCIAL 2: /* Usted ha sido contratado en una tienda de venta de Banco en la cual se tiene la información de las cuentas la cual es nombre del titular de la cuenta, número de la cuenta, fecha de creación y saldo de la cuenta. Usted debe crear una estructura de datos que le permita almacenar la información de las cuentas,


cree un menú de opciones que permita: Primero ingresar la información de las cuentas, eliminar información y por último el banco ha decidido adicionar a cada cuenta un bono diferente, este bono corresponde al 20% del saldo de la cuenta. AUTOR: GREIDY SIERRA FECHA:20-09-2013*/ #include<iostream> #include<string> using namespace std; struct banco{ string nombre_t; string apellido_t; double numero_cta; string fecha; double saldo; }; struct Nodo{ banco campo; Nodo *ste; Nodo *ant; }; struct Nodo *pi=NULL, *pf=NULL, *pa=NULL, *r; void insertar_cab(banco datos); void insertar_cola(banco datos); void insertar_datos(banco datos); void eliminar(int eliminar); void mostrar(banco datos); void bono(banco datos); void insertar_cab(banco datos){ if(pi==NULL){ pi=r; r->ste=NULL; pf=r; pa=r; } else{ pa=pi; r->ste=pi; pi=r; pa->ant=r; pa=r; } } void insertar_cola(banco datos){ if(pf==NULL){ pf=r; pi=r; } else{ pa=pi; while(pa->ste!=NULL){ pa=pa->ste; } pf=r; pf->ant=pa; pa->ste=r; } } void insertar_datos(banco datos){ cout<<"NOMBRE TITULAR: "; cin>>datos.nombre_t; cout<<endl; cout<<"APELLIDO TITULAR: "; cin>>datos.apellido_t; cout<<endl; cout<<"NRO. DE LA CUENTA: "; cin>>datos.numero_cta; cout<<endl; /* while(r->campo.numero_cta==pi->campo.numero_cta){ cout<<"ERROR, NRO. DE LA CUENTA YA EXISTENTE, INGRESELO NUEVAMENTE: ";


cin>>datos.numero_cta; cout<<endl; } */ cout<<"FECHA DE CREACION (Example 20-09-2013): "; cin>>datos.fecha; cout<<endl; cout<<"SALDO: "; cin>>datos.saldo; cout<<endl; r=new Nodo(); r->campo.nombre_t=datos.nombre_t; r->campo.apellido_t=datos.apellido_t; r->campo.numero_cta=datos.numero_cta; r->campo.fecha=datos.fecha; r->campo.saldo=datos.saldo; r->ste=NULL; r->ant=NULL; if(pf==NULL && pi==NULL){ pf=r; pi=r; pa=r; } else if(r->campo.numero_cta<=pi->campo.numero_cta){ insertar_cab(datos); } else if(r->campo.numero_cta>=pi->campo.numero_cta){ insertar_cola(datos); } else{ pa=pi; Nodo *au=pa; while(pa!=NULL){ if(pa->campo.numero_cta>=r->campo.numero_cta){ au->ste=r; r->ste=pa; pa->ant=r; r->ant=au; return; } au=pa; pa=pa->ste; } } } void eliminar(int eliminar){ r=pi; Nodo *au=r; cout<<"NRO. DE LA CUENTA QUE DESEA ELIMINAR: "; cin>>eliminar; while(r!=NULL){ if(r->campo.numero_cta==eliminar){ if(r==pi){ pi=r->ste; delete r; return; cout<<"LA CUENTA NRO. "<<eliminar<<"SE HA ELIMINADO EXITOSAMENTE"<<endl; } else{ au->ste=r->ste; r->ste->ant=au; r->ste=NULL; r->ant=NULL; delete r; return; cout<<"LA CUENTA NRO. "<<eliminar<<"SE HA ELIMINADO EXITOSAMENTE"<<endl; } } else{ cout<<"LA CUENTA NRO. "<<eliminar<<"NO EXISTE"<<endl; } au=r; r=r->ste; }


} void mostrar(banco datos){ pa=pi; cout<<"\t\t\t\t * INFORMACION INGRESADA * "<<endl<<endl; cout<<" N. CUENTA NOMBRE APELLIDO SALDO FECHA DE CREACION "<<endl; while(pa!=NULL){ cout<<datos.numero_cta<<" "<<pa->campo.nombre_t<<" "<<pa->campo.apellido_t<<" "<<pa->campo.saldo<<" "<<pa->campo.fecha<<endl; pa=pa->ste; } } void bono(banco datos){ int cuenta; double bono, total=0; Nodo *au=r; while(r!=NULL){ if(r==pi){ pi=r->ste; bono=((r->campo.saldo)*0.20); total=bono+r->campo.saldo; return; cout<<"LA CUENTA NRO. "<<cuenta<<"TIENE UN BONO DE "<<bono<<"EN TOTAL EL SALDO ES DE "<<total<<endl; } au=r; r=r->ste; cout<<" N. CUENTA NOMBRE APELLIDO SALDO FECHA DE CREACION "<<endl; cout<<pa->campo.numero_cta<<" "<<pa->campo.nombre_t<<" "<<pa->campo.apellido_t<<" "<<total<<" "<<pa->campo.fecha<<endl; } } void main(){ int op; banco datos; do{ cout<<"\t\t MENU"<<endl<<endl; cout<<"1. INGRESAR DATOS."<<endl; cout<<"2. ELIMINAR DATOS."<<endl; cout<<"3. INGRESAR BONO."<<endl; cin>>op; switch(op){ case 1: insertar_datos(datos); mostrar(datos); break; case 2: eliminar(int (eliminar)); break; case 3: bono(datos); break; } } while(op!=3); system("pause>null"); } ------------------------------------------------------------------------------------------------------------------------------------------ TALLER 8: /* COLAS AUTOR: GREIDY SIERRA FECHA: 01-10-2013 */ #include <iostream> #include <stdlib.h> using namespace std; struct Nodo{ int nro; struct Nodo *ste; }; struct cola{ Nodo *pd; Nodo *pa;


}; void agregar(struct cola q , int valor ){ struct Nodo *p_aux = new(struct Nodo); p_aux->nro = valor; p_aux->ste = NULL; if( q.pd == NULL) q.pd = p_aux; // agrega el primer elemento a la cola else (q.pa)->ste = p_aux; q.pa = p_aux; // siempre apunta al ultimo elemento } int borrar(struct cola q){ int num; struct Nodo *p_aux; p_aux = q.pd; // el apuntador p_aux apunta al inicio de la cola num = p_aux->nro; q.pd=(q.pd)->ste; delete(p_aux); // elimina el elemento que se encuentra donde apunta p_aux return num; } void mostrar(struct cola q){ struct Nodo *p_aux; p_aux = q.pd; while( p_aux != NULL ){ cout<<" "<<p_aux->nro; p_aux = p_aux->ste; } } int main(){ struct cola q; q.pd=NULL; q.pa=NULL; int dato; // numero a encolar int op; // opcion del menu int x ; // numero que devuelve la funcon pop do{ cout<<"\n\t MENU\n\n"; cout<<" 1. INSERTAR COLA "<<endl; cout<<" 2. ELIMINAR CABEZA "<<endl; cout<<" 3. MOSTRAR COLA "<<endl; cout<<" 4. SALIR "<<endl; cin>>op; switch(op) { case 1: cout<< "\n INGRESE EL NUMERO A LA COLA: "; cin>> dato; agregar(q, dato); cout<<"\n DATO: " << dato << " INGRASADO A COLA\n\n"; break; case 2: x = borrar(q); cout<<"\n CABEZA "<< x <<" ELIMINADA\n\n"; break; case 3: cout << "\n MOSTRANDO COLA\n\n"; mostrar(q); //cout<<"\n NO HAY DATOS EN COLA!"<<endl; break; } }while(op!=5); system("pause"); return 0; } -------------------------------------------------------------------------------------------------------------------------- /* PILAS AUTOR: GREIDY SIERRA


FECHA: 01-10-2013 */ #include <iostream> using namespace std; struct nodo{ int nro; struct nodo *sgte; }; typedef nodo *Pila; void ingresar(Pila &p, int numero){ Pila aux; aux = new(struct nodo); // apuntamos al nuevo nodo creado aux->nro = numero; aux->sgte = p; p = aux; } int eliminar(Pila &p){ int num; Pila aux; aux = p ; num = aux->nro; // asignamos el primer vamor de la pila p = aux->sgte ; delete(aux); return num; } void mostrar(Pila p){ Pila aux; aux = p; // apunta al inicio de la lista while( aux !=NULL ) { cout<<"\t"<< aux->nro <<endl; aux = aux->sgte; } } int main(){ Pila p = NULL; // creando pila int dato; int op; int x ; // numero que devuelve la funcon pop do{ cout<<" 1. INGRESAR DATOS "<<endl; cout<<" 2. ELIMINAR DATOS "<<endl; cout<<" 3. MOSTRAR DATOS APILADOS "<<endl; cout<<" 4. SALIR"<<endl; cin>> op; switch(op){ case 1: cout<< "\n NUMERO A APILAR: "; cin>> dato; ingresar(p, dato); cout<<" NUMERO " << dato << " APILADO "<<endl<<endl; break; case 2: x = eliminar( p ); cout<<"\n NUMERO "<< x <<" ELIMINADO "<<endl<<endl; break; case 3: cout << "\n MOSTRANDO PILA"<<endl; if(p!=NULL){ mostrar(p); cout<<endl; }


else{ cout<<"\n PILA VACIA"<<endl; } break; cout<<endl<<endl; system("pause"); system("cls"); return 0; } }while(op!=4); } ------------------------------------------------------------------------------------------------------- TALLER 9: /* CLASES AUTOREFERENCIADAS (PONTENCIAS) AUTOR: GREIDY SIERRA FECHA: 04-10-2013 */ #include <iostream> using namespace std; double potencias(int b, int e){ if(e==0){ return 1; } else{ return b*(potencias(b, e-1)); } } int main(){ int base=2; int cant=0; int i=0; cout<<"\t CALCULAR LAS POTENCIAS DE 2"<<endl<<endl; cout<<"\t HASTA QUE POTENCIA DESEA CALCULAR? "; cin>>cant; for(i=0; i<=cant; i++){ cout<<"EL NUMERO 2^"<<i<<" = "<<potencias(base, i)<<endl; } system("pause"); } -------------------------------------------------------------------------------------------------------------------------- /* CLASES AUTOREFERENCIADAS (MCD) AUTOR: GREIDY SIERRA FECHA: 04-10-2013 */ #include <iostream> using namespace std; int MCD(int x, int y){ if(y==0){ return x; } else{ return MCD(y, x%y); } } int main(){ int m=0; int n=0; cout<<"DIGITE EL PRIMER NUMERO "; cin>>m; cout<<endl; cout<<"DIGITE EL SEGUNDO NUMERO "; cin>>n; cout<<endl; cout<<"EL RESULTADO ES:"<<MCD(m, n)<<endl; system("pause"); } -------------------------------------------------------------------------------------------------------------------------- /* CLASES AUTOREFERENCIADAS (FIBONACCI) AUTOR: GREIDY SIERRA FECHA: 04-10-2013 */ #include <iostream> using namespace std;


double fibonacci(int n){ if(n<=1){ return n; } else{ return fibonacci(n-1)+fibonacci(n-2); } } int main(){ int cant=0; int i=0; cout<<"\t SERIE DE FIBONACCI"<<endl<<endl; cout<<"\t HASTA QUE NUMERO DESEA LLEGAR "; cin>>cant; for(i=0; i<=cant; i++){ cout<<"LA SERIE HASTA EL NUMERO "<<cant<<" ES: "<<fibonacci(i)<<endl; } system("pause"); } -------------------------------------------------------------------------------------------------------------------------- TALLER 10: /* Escribir una función que devuelva el numero de nodos de un árbol binario Escribir una función que retorna la distancia máxima de la raíz a una hoja Escribir una función que retorna el numero de subarboles izquierdos no vacíos. */ #include<iostream> #include<stdlib.h> using namespace std; int con; int conN; struct Nodo { int nro; struct Nodo *izq, *der; }; typedef struct Nodo *ABB; ABB crearNodo(int x){ ABB nuevoNodo=new(struct Nodo); nuevoNodo->nro=x; nuevoNodo->izq=NULL; nuevoNodo->der=NULL; return nuevoNodo; } void insertar(ABB &arbol, int x){ if (arbol==NULL){ arbol=crearNodo(x); //Limite de la funcion } else if(x<arbol->nro) insertar(arbol->izq, x); else if(x>arbol->nro) insertar(arbol->der, x); } void imprimir(ABB arbol, int n); bool buscar(ABB &arbol, int x); void inorden(ABB &arbol); void postorden(ABB &arbol); void preorden(ABB &arbol); void impresion_basica(ABB &arbol); void contarNodo(ABB &arbol); void contarDistancia(ABB &arbol); void contarIzquiedovacios(ABB &arbol); int main(){ ABB arbol = NULL; //Crear arbol int n; int x; int opcion; do { system("color 4F"); system("cls"); cout<<"--------------------------------------------------------"<<endl; cout<<"__________________________________________________________"<<endl; cout<<"||Menu de opciones ARBOL BINARIO DE BUSQUEDA CON NUMEROS||"<<endl; cout<<"|| 1) Ingresar Datos al arbol...........................|| "<<endl; cout<<"|| 2) Ver arbol (Horizontal)............................|| "<<endl;


cout<<"|| 3) Observar Datos (Inorden)..........................||"<<endl; cout<<"|| 4) Observar Datos (Preorden).........................||"<<endl; cout<<"|| 5) Observar Datos (PostOrden)........................||"<<endl; cout<<"|| 6) Busqueda en el arbol..............................|| "<<endl; cout<<"|| 7) Contar Nodo.......................................|| "<<endl; cout<<"|| 8) Distancia de la raiz la hoja.....................|| "<<endl; cout<<"|| 9) Cantidad de Izquierdos vacios.....................|| "<<endl; cout<<"|| 10) Distancia Raiz - Numero..........................|| "<<endl; cout<<"|| 11) Salir............................................|| "<<endl; cout<<"||______________________________________________________||"<<endl; cout<<"---------------------------------------------------------"<<endl; cin>>opcion; switch (opcion){ case 1: system("cls"); system("color 3F"); cout<<"Numero de nodos del arbol: "; cin>>n; cout<<endl; for(int i=0; i<n; i++){ system("cls"); cout<<"Numero del nodo "<<i+1<<":"; cin>>x; insertar(arbol, x); cout<<endl<<endl; system("pause"); } break; case 2: system("cls"); system("color 5F"); cout<<"SE IMPRIMIRA EL ARBOL DE BUSQUEDA EN FORMA HORIZONTAL"<<endl; imprimir(arbol, n); system("pause"); break; case 3: system("color F0"); system("cls"); cout<<"SE IMPRIMIRAN DATOS DE MODO (INORDEN)"<<endl; inorden(arbol); system("pause"); break; case 4: system("color 6F"); system("cls"); cout<<"SE IMPRIMIRAN DATOS DE MODO (PREORDEN)"<<endl; preorden(arbol); system("pause"); break; case 5: system("color F4"); system("cls"); cout<<"SE IMPRIMIRAN DATOS DE MODO (POST-ORDEN)"<<endl; postorden(arbol); system("pause"); break; case 6: system("color 0A"); cout<<" FUNCION DE BUSQUEDA PARA EL ARBOL BINARIO "<<endl; cout<<"Ingrese el numero a buscar "<<endl; cin>>x; buscar(arbol, x); system("pause"); break; case 7: system("color 4A"); system("cls"); cout<<" NUMEROS DE NODOS"<<endl; con=0; contarNodo(arbol); cout<<con<<endl; system("pause"); break; case 8: system("color 3A");


system("cls"); cout<<" DISTANCIA DE LA RAIZ A LA HOJA"<<endl; con=0; contarDistancia(arbol); cout<<con<<endl; system("pause"); break; case 9: system("color 7A"); system("cls"); cout<<"Subarboles Izquierdos Vacios"<<endl; con=0; contarIzquiedovacios(arbol); cout<<con<<endl; system("pause"); break; case 10: system("color 3A"); system("cls"); cout<<" DISTANCIA DE LA RAIZ AL NUMERO"<<endl; cout<<"Ingrese el Numero a buscar"<<endl; con=0; cin>>x; buscar(arbol, x); system("cls"); if (con!=0){ cout<<"La distancia del numero "<<x<<" a la raiz es de:"<<con<<endl; } system("pause"); break; } } while (opcion!=11); } void imprimir(ABB arbol, int n){ if(arbol==NULL){ return;// ¿Que retorna? } //cout<<"antes"<<arbol->nro<<endl; imprimir(arbol->der, n+1); //cout<<"Despues"<<arbol->nro<<endl; for(int i=0; i<n; i++){ cout<<" "; //Espacios horizontales por niveles } cout<< arbol->nro <<endl;//¿En que momento se va a la raiz? imprimir(arbol->izq, n+1); } bool buscar(ABB &arbol, int x){ if (arbol!=NULL){ if(arbol->nro==x){ system("cls"); cout<<"Elemento encontrado"<<endl; cout<<x; return 1;//Preguntar?? exit(0);//preguntar?? } else{ if (arbol->nro>x){ con++; buscar(arbol->izq, x); } else if (arbol->nro<x){ con++; buscar(arbol->der, x); } return 0; } } } void inorden(ABB &arbol){ //Izquierda || Raiz || Derecha if (arbol!=NULL){ inorden(arbol->izq); impresion_basica(arbol); inorden(arbol->der); } }


void postorden(ABB &arbol){ //Izquierda || Derecha || Raiz if (arbol!=NULL){ postorden(arbol->izq); postorden(arbol->der); impresion_basica(arbol); } } void preorden(ABB &arbol){ // Raiz || Izquierda || Derecha if (arbol!=NULL){ impresion_basica(arbol); preorden(arbol->izq); preorden(arbol->der); } } void impresion_basica(ABB &arbol){ //Para no poner el mismo código en los 3 ordenes y tener control de la funcion recursiva cout<<arbol->nro<<endl; system("pause"); system("cls"); } void contarNodo(ABB &arbol){ if (arbol!=NULL){ con=con+1; contarNodo(arbol->izq); contarNodo(arbol->der); } } void contarDistancia(ABB &arbol){ if (arbol!=NULL){ if (arbol->der!=NULL || arbol->izq!=NULL){ con=con+1; contarDistancia(arbol->izq); contarDistancia(arbol->der); } } } void contarIzquiedovacios(ABB &arbol){ if (arbol!=NULL){ if (arbol->izq==NULL){ con=con+1; } contarIzquiedovacios(arbol->izq); contarIzquiedovacios(arbol->der); } } -------------------------------------------------------------------------------------------------------------------------- TALLER 10: /* 1. Definir una función que dados dos árboles m-arios de naturales retorne true si ambos árboles representan a un mismo conjunto (tienen los mismos elementos sin duplicados). 2. Definir una función que dado un árbol m-ario de naturales y un natural k la lista de los elementos que se encuentran en el nivel k, ordenados de izquierda a derecha.La raíz de un árbol no vacio se encuentra en el nivel 1. Si no existe nivel k se debe retornar la lista vacia.*/ #include<iostream> #include<stdlib.h> using namespace std; int nodos1, nodos2, igual; struct Nodo1 { int nro1; struct Nodo1 *izq1, *der1; }; struct Nodo2 { int nro2; struct Nodo2 *izq2, *der2; }; typedef struct Nodo1 *ARBOL1; ARBOL1 crearNodo1(int x){// Es necesario crear dos arboles ARBOL1 nuevoNodo=new(struct Nodo1); nuevoNodo->nro1=x; nuevoNodo->izq1=NULL; nuevoNodo->der1=NULL; return nuevoNodo; } typedef struct Nodo2 *ARBOL2; ARBOL2 crearNodo2(int x){


ARBOL2 nuevoNodo=new(struct Nodo2); nuevoNodo->nro2=x; nuevoNodo->izq2=NULL; nuevoNodo->der2=NULL; return nuevoNodo; } struct nodoCola{ ARBOL2 ptr; struct nodoCola *sgte; }; struct cola{ struct nodoCola *delante; struct nodoCola *atras; }; void inicializaCola(struct cola &q) { q.delante = NULL; q.atras = NULL; } void encola(struct cola &q, ARBOL2 n) { struct nodoCola *p; p = new(struct nodoCola); p->ptr = n; p->sgte = NULL; if(q.delante==NULL) q.delante = p; else (q.atras)->sgte = p; q.atras = p; } ARBOL2 desencola(struct cola &q) { struct nodoCola *p; p = q.delante; ARBOL2 n = p->ptr; q.delante = (q.delante)->sgte; delete(p); return n; } void insertar1(ARBOL1 &raiz1, int x){ if (raiz1==NULL){ raiz1=crearNodo1(x); //Limite de la funcion } else if(x<raiz1->nro1) insertar1(raiz1->izq1, x); else if(x>raiz1->nro1) insertar1(raiz1->der1, x); } void insertar2(ARBOL2 &raiz2, int x){ if (raiz2==NULL){ raiz2=crearNodo2(x); //Limite de la funcion } else if(x<raiz2->nro2) insertar2(raiz2->izq2, x); else if(x>raiz2->nro2) insertar2(raiz2->der2, x); } void imprimir1(ARBOL1 raiz1, int n){ if(raiz1==NULL){ return;//Que hace, no cotinua? } imprimir1(raiz1->der1, n+1); for(int i=0; i<n; i++){ cout<<" "; //Espacios horizontales por niveles } cout<< raiz1->nro1 <<endl; imprimir1(raiz1->izq1, n+1); } void imprimir2(ARBOL2 raiz2, int n){ if(raiz2==NULL){ return;//Que hace, no cotinua? } imprimir2(raiz2->der2, n+1); for(int i=0; i<n; i++){ cout<<" "; //Espacios horizontales por niveles }


cout<< raiz2->nro2 <<endl; imprimir2(raiz2->izq2, n+1); } void preorden(ARBOL1 &raiz1, ARBOL2 &raiz2, int nodos1, int nodos2); void contarNodo1(ARBOL1 &raiz1); void contarNodo2(ARBOL2 &raiz2); void recorrerxNivel(ARBOL2 raiz2); int main(){ ARBOL1 raiz1 = NULL; ARBOL2 raiz2 = NULL; int n, x, K; int opcion; cout<<"INGRESAR EL PRIMER ARBOL"<<endl; cout<<"Numero de nodos del arbol1: "; cin>>n; cout<<endl; for(int i=0; i<n; i++){ system("cls"); cout<<"Numero del nodo "<<i+1<<":"; cin>>x; insertar1(raiz1, x); cout<<endl<<endl; system("pause"); } do { system("cls"); cout<<"__________________________________________________________"<<endl; cout<<"||MENU ARBOL BINARIO ||"<<endl; cout<<"|| 1) Ingresar Arbol No 2...............................|| "<<endl; cout<<"|| 2) Ver arboles (Horizontal)..........................|| "<<endl; cout<<"|| 3) Comprobar el mismo conjunto de arboles............||"<<endl; cout<<"|| 4) Datos de un Nivel.................................||"<<endl; cout<<"|| 5) Salir.............................................|| "<<endl; cout<<"||______________________________________________________||"<<endl; cout<<"---------------------------------------------------------"<<endl; cin>>opcion; switch (opcion){ case 1: system("cls"); cout<<"Numero de nodos del arbol2: "; cin>>n; cout<<endl; for(int i=0; i<n; i++){ system("cls"); cout<<"Numero del nodo "<<i+1<<":"; cin>>x; insertar2(raiz2, x); cout<<endl<<endl; system("pause"); } break; case 2: system("cls"); cout<<"ARBOL 1 DE BUSQUEDA EN FORMA HORIZONTAL"<<endl; imprimir1(raiz1, n); cout<<endl<<endl; cout<<"ARBOL 2 DE BUSQUEDA EN FORMA HORIZONTAL"<<endl; imprimir2(raiz2, n); cout<<endl; system("pause"); break; case 3: system("cls"); nodos1=0; nodos2=0; contarNodo1(raiz1); contarNodo2(raiz2); igual=0; preorden(raiz1, raiz2, nodos1, nodos2); if (igual==nodos1 & igual==nodos2){ cout<<"Los dos arboles son exactamente IGUALES"<<endl; } else { cout<<"NO son Iguales"<<endl; }


system("pause"); break; case 4: system("cls"); cout<<"Ingrese el numero del nivel"<<endl; cin>>K; recorrerxNivel(raiz2); system("pause"); break; } } while (opcion!=5); } void preorden(ARBOL1 &raiz1, ARBOL2 &raiz2, int nodos1, int nodos2){ // Raiz || Izquierda || Derecha if (nodos1==nodos2){ if (raiz1!=NULL & raiz2!=NULL){ if (raiz1->nro1==raiz2->nro2){ preorden(raiz1->izq1, raiz2->izq2, nodos1, nodos2); preorden(raiz1->der1, raiz2->der2, nodos1, nodos2); igual++; } } } else{ cout<<"No tienen la misma cantidad de nodos"; } } void contarNodo1(ARBOL1 &raiz1){ if (raiz1!=NULL){ nodos1++; contarNodo1(raiz1->izq1); contarNodo1(raiz1->der1); } } void contarNodo2(ARBOL2 &raiz2){ if (raiz2!=NULL){ nodos2++; contarNodo2(raiz2->izq2); contarNodo2(raiz2->der2); } } void recorrerxNivel(ARBOL2 raiz2) { struct cola q; inicializaCola(q); cout << "\t"; if(raiz2!=NULL) { encola(q, raiz2); while(q.delante!=NULL) { raiz2 = desencola(q); cout << raiz2->nro2 << ' '; if(raiz2->izq2!=NULL) encola(q, raiz2->izq2); if(raiz2->der2!=NULL) encola(q, raiz2->der2); } } } -------------------------------------------------------------------------------------------------------------------------- OPCIONES: #include <iostream> #include <stdlib.h> using namespace std; /*--------- Estructura del arbol -------*/ typedef struct nodo{ int nro; struct nodo *izq, *der; }*ABB; int numNodos = 0; // nummero de nodos del arbol ABB int numK = 0, k; // nodos menores que un numero k ingresado /* ---------- Estructura de la cola ---------*/ struct nodoCola{ ABB ptr; struct nodoCola *sgte; };


struct cola{ struct nodoCola *delante; struct nodoCola *atras; }; void inicializaCola(struct cola &q) { q.delante = NULL; q.atras = NULL; } void encola(struct cola &q, ABB n) { struct nodoCola *p; p = new(struct nodoCola); p->ptr = n; p->sgte = NULL; if(q.delante==NULL) q.delante = p; else (q.atras)->sgte = p; q.atras = p; } ABB desencola(struct cola &q) { struct nodoCola *p; p = q.delante; ABB n = p->ptr; q.delante = (q.delante)->sgte; delete(p); return n; } ABB crearNodo(int x) { ABB nuevoNodo = new(struct nodo); nuevoNodo->nro = x; nuevoNodo->izq = NULL; nuevoNodo->der = NULL; return nuevoNodo; } void insertar(ABB &arbol, int x) { if(arbol==NULL) { arbol = crearNodo(x); cout<<"\n\t Insertado..!"<<endl<<endl; } else if(x < arbol->nro) insertar(arbol->izq, x); else if(x > arbol->nro) insertar(arbol->der, x); } void preOrden(ABB arbol) { if(arbol!=NULL) { cout << arbol->nro <<" "; preOrden(arbol->izq); preOrden(arbol->der); } } void enOrden(ABB arbol) { if(arbol!=NULL) { enOrden(arbol->izq); cout << arbol->nro << " "; enOrden(arbol->der); } } void postOrden(ABB arbol) { if(arbol!=NULL) { enOrden(arbol->izq); enOrden(arbol->der); cout << arbol->nro << " "; } } void verArbol(ABB arbol, int n) { if(arbol==NULL) return; verArbol(arbol->der, n+1); for(int i=0; i<n; i++) cout<<" "; numNodos++; cout<< arbol->nro <<endl; verArbol(arbol->izq, n+1); }


bool busquedaRec(ABB arbol, int dato) { int r=0; // 0 indica que lo encontre if(arbol==NULL) return r; if(dato<arbol->nro) r = busquedaRec(arbol->izq, dato); else if(dato> arbol->nro) r = busquedaRec(arbol->der, dato); else r = 1; // son iguales, lo encontre return r; } ABB unirABB(ABB izq, ABB der) { if(izq==NULL) return der; if(der==NULL) return izq; ABB centro = unirABB(izq->der, der->izq); izq->der = centro; der->izq = izq; return der; } void elimina(ABB &arbol, int x) { if(arbol==NULL) return; if(x<arbol->nro) elimina(arbol->izq, x); else if(x>arbol->nro) elimina(arbol->der, x); else { ABB p = arbol; arbol = unirABB(arbol->izq, arbol->der); delete p; } } int alturaAB(ABB arbol) { int AltIzq, AltDer; if(arbol==NULL) return -1; else { AltIzq = alturaAB(arbol->izq); AltDer = alturaAB(arbol->der); if(AltIzq>AltDer) return AltIzq+1; else return AltDer+1; } } void recorrerxNivel(ABB arbol) { struct cola q; inicializaCola(q); cout << "\t"; if(arbol!=NULL) { encola(q, arbol); while(q.delante!=NULL) { arbol = desencola(q); cout << arbol->nro << ' '; if(arbol->izq!=NULL) encola(q, arbol->izq); if(arbol->der!=NULL) encola(q, arbol->der); } } } ABB arbolEspejo(ABB arbol) { ABB temp; if(arbol!=NULL) { temp = arbol->izq; arbol->izq = arbolEspejo(arbol->der); arbol->der = arbolEspejo(temp); } return arbol; } void nodosMenoresQueK(ABB arbol, int n) { if(arbol==NULL) return; nodosMenoresQueK(arbol->der, n+1);


if(arbol->nro<k) numK++; nodosMenoresQueK(arbol->izq, n+1); } int contarHojas(ABB arbol) { if (arbol==NULL) { return 0; } if ((arbol->der ==NULL)&&(arbol->izq ==NULL)) { return 1; } else { return contarHojas(arbol->izq) + contarHojas(arbol->der); } } void menu() { //system("cls"); cout << "\n\t\t ..[ ARBOL BINARIO DE BUSQUEDA ].. \n\n"; cout << "\t [1] Insertar elemento \n"; cout << "\t [2] Mostrar arbol \n"; cout << "\t [3] Recorridos de profundiad \n"; cout << "\t [4] Buscar elemento \n"; cout << "\t [5] Eliminar elemento \n"; cout << "\t [6] Recorrido por nieveles (Amplitud) \n"; cout << "\t [7] Altura del arbol \n"; cout << "\t [8] Construir arbol reflejo \n"; cout << "\t [9] Contar nodos \n"; cout << "\t [x] Contar hojas \n"; cout << "\t [11] Nodos menores de 'k' \n"; cout << "\t [12] SALIR \n"; cout << "\n\t Ingrese opcion : "; } void menu2() { //system("cls"); // para limpiar pantalla cout << endl; cout << "\t [1] En Orden \n"; cout << "\t [2] Pre Orden \n"; cout << "\t [3] Post Orden \n"; cout << "\n\t Opcion : "; } int main() { ABB arbol = NULL; int x; int op, op2; //system("color f9"); // poner color a la consola do { menu(); cin>> op; cout << endl; switch(op) { case 1: cout << " Ingrese valor : "; cin>> x; insertar( arbol, x); break; case 2: verArbol(arbol, 0); break; case 3: menu2(); cin>> op2; if(arbol!=NULL) { switch(op2) { case 1: enOrden(arbol); break; case 2: preOrden(arbol); break; case 3: postOrden(arbol); break; } } else cout << "\n\t Arbol vacio..!"; break; case 4: bool band; cout<<" Valor a buscar: "; cin>> x;


band = busquedaRec(arbol,x); if(band==1) cout << "\n\tEncontrado..."; else cout << "\n\tNo encontrado..."; break; case 5: cout<<" Valor a eliminar: "; cin>> x; elimina(arbol, x); cout << "\n\tEliminado..!"; break; case 6: cout<<"\n\n Mostrando recorrido por amplitud\n\n"; recorrerxNivel(arbol); break; case 7: int h; h = alturaAB(arbol); cout << " La altura es : "<< h << endl; break; case 8: ABB espejo; espejo = NULL; cout << "\n\n Arbol incial \n\n"; verArbol(arbol, 0); cout << "\n\n Arbol espejo \n\n"; espejo = arbolEspejo(arbol); verArbol(espejo, 0); break; case 9: verArbol(arbol, 0); cout << "\n\n El numero de nodos es : "; cout << numNodos; break; case 11: cout << " Ingrese k: "; cin>> k; nodosMenoresQueK(arbol, 0); cout <<" Son "<< numK << " numeros"; break; case 12: exit(0); } cout<<"\n\n\n"; //system("pause"); // hacer pausa y presionar una tecla para continuar }while(op!=11); } ------------------------------------------------------------------------------------------------------- BUSQUEDA Y ORDEN: #include<iostream> using namespace std; typedef struct Nodo{ int info;//informacion de tipo entero que contiene la lista Nodo* ste;//puntero siguiente de la lista }; //definicion de los punteros que va a tener la lista struct Nodo *r,*pi=NULL,*pf=NULL, *aux, *auxini, *auxfin, *aux2,*minimo, *cab;//ptr como puntero inicial void InsertarCabeza(int num); void insertar_cola(int nu); void muestra_lista(); void isertar_ordenado(int ordenado); void eliminar_Nodo (int eliminar); void buscar_Nodo (int buscar); int contarNodos(Nodo *auxini,Nodo *auxfin); void buscar_Binaria (int buscar,Nodo *auxini,Nodo *auxfin); void ordenamientoBurbuja(); void ordenamientoLineal(); int encontrarMinimo(); void main(){ int n,num,eliminar,ordenado,buscar;//iniciamos variaobles a utilizar cout<<"Cuantos numeros desea ingresar \n"; do{ cout<<"\t\t MENU \n"<<endl;


cout<<"1. INSERTAR CABEZA\n"<<endl; cout<<"2. INSERTAR COLA\n"<<endl; cout<<"3. ELIMINAR \n"<<endl; cout<<"4. INSERTAR ORDENADO \n"<<endl; cout<<"5. MOSTRAR \n"<<endl; cout<<"6. BUSQUEDA BINARIAV \n"<<endl; cout<<"7. ORDENAMIENTO BURBUJA \n"<<endl; cout<<"8. ORDENAMIENTO LINEAL \n"<<endl; cout<<"9. SALIR "<<endl; cin>>n; switch (n) { case 1: cout<<"Ingrese el numero "<<endl; cin>>num; InsertarCabeza(num); break; case 2: cout<<"Ingrese el numero "<<endl; cin>>num; insertar_cola(num); break; case 3: cout<<"Ingrese el numero a eliminar "<<endl; cin>>eliminar; eliminar_Nodo(eliminar); break; case 4: cout<<"Ingrese el numero a insertar "<<endl; cin>>ordenado; isertar_ordenado( ordenado); case 5: muestra_lista(); break; case 6: cout<<"Ingrese el numero a buscar "<<endl; cin>>buscar; auxini = pi; auxfin = pf; buscar_Binaria(buscar,auxini,auxfin); break; case 7: ordenamientoBurbuja(); break; case 8: ordenamientoLineal(); break; default : break; } }while(n!=9); system("pause>null"); } void InsertarCabeza(int num){//la funcion que hago en c, no lleva ptr por que la lista la estoy tomando global r = new Nodo(); r->info=num; if(pi==NULL){ pi=r; r->ste=NULL; pf=r; } else{ r->ste=pi; pi = r; } } void insertar_cola(int nu){ r = new Nodo(); r->info=nu; r->ste=NULL; if(pf==NULL){ pf=r; pi=r; } else{ aux=pi;


while(aux->ste != NULL){ aux = aux->ste; } aux->ste=r; pf=r; } } void eliminar_Nodo (int eliminar){ r=pi; Nodo *au = r; while(r!=NULL){ cout<<"entra"<<endl; if(r->info == eliminar) { if(r==pi){ pi=r->ste;//Eliminando la cabeza delete r; return; } else{ cout<<"elimina en cualquier"; au->ste =r->ste; //Eliminando cualquier nodo r->ste =NULL; delete r; return; } } au =r; r=r->ste;//avanzamos el puntero para que el ciclo no se haga infinito } } void buscar_Nodo (int buscar){ aux=pi; while(aux!=NULL){ if(aux->info == buscar) { cout<<"Numero encontrado "<<aux->info; return;//El return nos devuelve a donde fue llamada la funcion } aux=aux->ste;//avanzamos el puntero para que el ciclo no se haga infinito } cout<<"el numero que busca en la lista no existe"<<endl; } void buscar_Binaria (int buscar,Nodo *auxini,Nodo *auxfin){ int numeroNodos = 0; int contador = 0; numeroNodos = contarNodos(auxini,auxfin); aux = auxini; auxfin->ste = NULL; cout<<numeroNodos<<endl; cout<< "auxini"<< auxini ->info <<endl; cout<< "auxfin"<< auxfin ->info <<endl; while(aux != auxfin){ cout<<"mitad"<< numeroNodos/2 <<endl; cout<<"contador1 "<<contador<<endl; if(numeroNodos/2 == 1 && numeroNodos == 2){ if (auxini->info ==buscar ){ cout<<"Numero encontrado "<<auxini->info; break; } else if (auxfin->info == buscar){ cout<<"Numero encontrado "<<auxfin->info; break; } else { cout<<"el numero que busca en la lista no existe"<<endl; break; } } if(contador == numeroNodos/2) { cout<<"auxinfo"<<aux->info<<endl; if(aux->info == buscar){ cout<<"Numero encontrado "<<aux->info; break; } else if (aux->info < buscar){ auxini = aux;


buscar_Binaria(buscar,auxini,auxfin); } else if (aux->info > buscar){ auxfin = aux; buscar_Binaria(buscar,auxini,auxfin); } } contador++; aux=aux->ste; } } int contarNodos(Nodo *auxini,Nodo *auxfin){ int contador = 0; while(auxini!=auxfin->ste){ contador ++; auxini=auxini->ste;//avanzamos el puntero para que el ciclo no se haga infinito } return contador; } void muestra_lista(){ aux=pi; while(aux!=NULL){ cout<<"Numero nodo "<<aux->info; aux=aux->ste;//avanzamos el puntero para que el ciclo no se haga infinito } } void isertar_ordenado(int ordenado){ r = new Nodo(); r->info=ordenado; if(pf==NULL && pi == NULL){ cout<<"inserta el primero"<<endl; pf=r; pi=r; } else if(ordenado < pi->info){ cout<<"inserta por cabeza"<<endl; InsertarCabeza(ordenado); } else if(ordenado > pf->info) { cout<<"inserta por cola"<<endl; insertar_cola(ordenado); } else{ aux=pi; Nodo *au = aux; while(aux !=NULL){ cout<<"info"<<aux->info<<endl; if(aux->info > ordenado) { cout<<"inserta en medio"<<endl; au->ste = r; r->ste = aux; return; } au =aux; aux = aux->ste; } } } void ordenamientoBurbuja(){ int temp; bool cambio = true; aux = pi; aux2 = aux->ste; while(cambio){ aux = pi; aux2 = aux->ste; while(aux2 != NULL){ if(aux->info > aux2->info){ temp = aux->info; aux->info = aux2->info; aux2->info = temp; cambio = true; } else { cambio = false;


} aux = aux->ste; aux2 = aux2->ste; } } } void ordenamientoLineal(){ cab = pi; aux = pi; int min = aux->info; minimo = pi; bool cambio = false; while (cab!=NULL){ min = aux->info; while (aux != NULL){ cout<<"min"<<min<<endl; cout<<"aux"<<aux->info<<endl; if(aux->info< min ){ minimo = aux; min= aux->info; cambio = true; cout<<"nunca deberia entrar"<<endl; } aux=aux->ste; } if(cambio){ cout<<"cambio"<<min; minimo->info = cab->info; cab->info = min; muestra_lista(); } cambio = false; cout<<"cab"<<cab->info<<endl; cab = cab->ste; //cout<<"aux"<<aux->info; aux = cab; } } ------------------------------------------------------------------------------------------------------------------------- GRAFOS: #include<iostream> #include<conio.h> using namespace std; struct nodo{ char nombre;//nombre del vertice o nodo struct nodo *sgte; struct arista *ady;//puntero hacia la primera arista del nodo }; struct arista{ struct nodo *destino;//puntero al nodo de llegada struct arista *sgte; }; typedef struct nodo *Tnodo;// Tipo Nodo typedef struct arista *Tarista; //Tipo Arista Tnodo p;//puntero cabeza void menu(); void insertar_nodo(); void agrega_arista(Tnodo &, Tnodo &, Tarista &); void insertar_arista(); void vaciar_aristas(Tnodo &); void eliminar_nodo(); void eliminar_arista(); void mostrar_grafo(); void mostrar_aristas(); //Funcion Principal int main(void){ p=NULL; int op; // opcion del menu system("color 0b"); do{ menu(); cin>>op; switch(op){ case 1: insertar_nodo();


break; case 2: insertar_arista(); break; case 3: eliminar_nodo(); break; case 4: eliminar_arista(); break; case 5: mostrar_grafo(); break; case 6: mostrar_aristas(); break; default: cout<<"OPCION NO VALIDA...!!!"; break; } cout<<endl<<endl; system("pause"); system("cls"); }while(op!=7); getch(); return 0; } //Menu void menu(){ cout<<"\n\tREPRESENTACION DE GRAFOS DIRIGIDOS\n\n"; cout<<" 1. INSERTAR UN NODO "<<endl; cout<<" 2. INSERTAR UNA ARISTA "<<endl; cout<<" 3. ELIMINAR UN NODO "<<endl; cout<<" 4. ELIMINAR UNA ARISTA "<<endl; cout<<" 5. MOSTRAR GRAFO "<<endl; cout<<" 6. MOSTRAR ARISTAS DE UN NODO "<<endl; cout<<" 7. SALIR "<<endl; cout<<"\n INGRESE OPCION: "; } //INSERTAR NODO AL GRAFO void insertar_nodo(){ Tnodo t,nuevo=new struct nodo; cout<<"INGRESE VARIABLE:"; cin>>nuevo->nombre; nuevo->sgte = NULL; nuevo->ady=NULL; if(p==NULL){ p = nuevo; cout<<"PRIMER NODO...!!!"; } else{ t = p; while(t->sgte!=NULL){ t = t->sgte; } t->sgte = nuevo; cout<<"NODO INGRESADO...!!!"; } } //AGREGAR ARISTA //funcion que utilizada para agregar la arista a dos nodos void agrega_arista(Tnodo &aux, Tnodo &aux2, Tarista &nuevo){ Tarista q; if(aux->ady==NULL){ aux->ady=nuevo; nuevo->destino=aux2; cout<<"PRIMERA ARISTA....!"; } else{ q=aux->ady; while(q->sgte!=NULL) q=q->sgte; nuevo->destino=aux2; q->sgte=nuevo; cout<<"ARISTA AGREGADA...!!!!";


} } //INSERTAR ARISTA //funcion que busca las posiciones de memoria de los nodos y hace llamado a agregar_arista para insertar la arista void insertar_arista(){ char ini, fin; Tarista nuevo=new struct arista; Tnodo aux, aux2; if(p==NULL){ cout<<"GRAFO VACIO...!!!!"; return; } nuevo->sgte=NULL; cout<<"INGRESE NODO DE INICIO:"; cin>>ini; cout<<"INGRESE NODO FINAL:"; cin>>fin; aux=p; aux2=p; while(aux2!=NULL){ if(aux2->nombre==fin){ break; } aux2=aux2->sgte; } while(aux!=NULL){ if(aux->nombre==ini){ agrega_arista(aux,aux2, nuevo); return; } aux = aux->sgte; } } //FUNCION PARA BORRAR TODAS LAS ARISTAS DE UN NODO //esta funcion es utilizada al borrar un nodo pues si tiene aristas es nesesario borrarlas tambien y dejar libre la memoria void vaciar_aristas(Tnodo &aux){ Tarista q,r; q=aux->ady; while(q->sgte!=NULL){ r=q; q=q->sgte; delete(r); } } //ELIMINAR NODO //funcion utilizada para eliminar un nodo del grafo pero para eso tambien tiene que eliminar sus aristas por lo cual //llama a la funcion vaciar_aristas para borrarlas void eliminar_nodo(){ char var; Tnodo aux,ant; aux=p; cout<<"ELIMINAR UN NODO\n"; if(p==NULL){ cout<<"GRAFO VACIO...!!!!"; return; } cout<<"INGRESE NOMBRE DE VARIABLE:"; cin>>var; while(aux!=NULL){ if(aux->nombre==var){ if(aux->ady!=NULL) vaciar_aristas(aux); if(aux==p){ p=p->sgte; delete(aux); cout<<"NODO ELIMINADO...!!!!"; return; }else{ ant->sgte = aux->sgte; delete(aux); cout<<"NODO ELIMINADO...!!!!"; return; }


}else{ ant=aux; aux=aux->sgte; } } } //ELIMINAR ARISTA //funcion utilizada para eliminar una arista void eliminar_arista(){ char ini, fin; Tnodo aux, aux2; Tarista q,r; cout<<"\n ELIMINAR ARISTA\n"; cout<<"INGRESE NODO DE INICIO:"; cin>>ini; cout<<"INGRESE NODO FINAL:"; cin>>fin; aux=p; aux2=p; while(aux2!=NULL){ if(aux2->nombre==fin){ break; } else aux2=aux2->sgte; } while(aux!=NULL){ if(aux->nombre==ini){ q=aux->ady; while(q!=NULL){ if(q->destino==aux2){ if(q==aux->ady) aux->ady=aux->ady->sgte; else r->sgte=q->sgte; delete(q); cout<<"ARISTA "<<aux->nombre<<"----->"<<aux2->nombre<<" ELIMINADA.....!!!!"; return; } } r=q; q=q->sgte; } aux = aux->sgte; } } //MOSTRAR GRAFO //funcion que imprime un grafo en su forma enlazada void mostrar_grafo(){ Tnodo ptr; Tarista ar; ptr=p; cout<<"NODO|LISTA DE ADYACENCIA\n"; while(ptr!=NULL){ cout<<" "<<ptr->nombre<<"|"; if(ptr->ady!=NULL){ ar=ptr->ady; while(ar!=NULL){ cout<<" "<<ar->destino->nombre; ar=ar->sgte; } } ptr=ptr->sgte; cout<<endl; } } //MOSTRAR ARISTAS //funcion que muestra todas las aristas de un nodo seleccionado void mostrar_aristas(){ Tnodo aux; Tarista ar; char var; cout<<"MOSTRAR ARISTAS DE NODO\n"; cout<<"INGRESE NODO:";


cin>>var; aux=p; while(aux!=NULL){ if(aux->nombre==var){ if(aux->ady==NULL){ cout<<"EL NODO NO TIENE ARISTAS...!!!!"; return; }else{ cout<<"NODO|LISTA DE ADYACENCIA\n"; cout<<" "<<aux->nombre<<"|"; ar=aux->ady; while(ar!=NULL){ cout<<ar->destino->nombre<<" "; ar=ar->sgte; } cout<<endl; return; } } else aux=aux->sgte; } }

PROGRAMACÍON C++ 3

Documents

Transcript of PROGRAMACÍON C++ 3