Programacíon C++ 3

INTRODUCCIN.
Las computadoras fueron diseadas o ideadas como una herramienta mediante la cual podemos realizar operaciones de clculo
complicadas en un lapso de mnimo tiempo. Pero, la mayora de las aplicaciones de este fantstico invento del hombre, son las de
almacenamiento y acceso de grandes cantidades de informacin.
La informacin 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.
INTRODUCCIN.
Una estructura de datos es una coleccin de datos organizados de un modo particular, las estructuras de datos pueden ser de dos
tipos: estructuras de datos estticas y estructura de datos dinmicas. Las estructuras de datos estticas son aquellas en las que el
espacio en memoria se define en tiempo de compilacin y no pueden ser modificados durante la ejecucin del programa,
corresponden a este tipo los arrays (vectores y matrices). Las estructuras de datos dinmicas son aquellas en las que el espacio
ocupado en memoria puede ser modificada en tiempo de ejecucin, corresponden a este tipo: las listas, rboles y grafos.
ESQUEMA.
- Boolean.
- char.
- integer
Smples o
Fundamentales
- real.
Estticas
- String.
- Arreglos.
- Conjuntos.
- Registros.
Compuestas o
Estructuradas
Estructuras de
Datos
- Archivos
- pilas.
- colas.
- listas.
- rboles.
- Grfos.
Dinmicas
TIPOS DE DATOS ABSTRACTOS (TDA).
Creacin de tipos de datos definidos por el usuario.
Permite organizar de manera ms 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).
GREIDY SIERRA
CORTE 1
EJEMPLO
#include<iostream>
#include<string>
using namespace std;
class Empleados{
private:
int horas;
float valor, salario;
string nombre;
public :
//Acceso a mtodos 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 mtodos 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.
Unin, para crear uniones.
Typedef, para crear un sinnimo 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 tamao total que ocupa una estructura en memoria es la suma del tamao que ocupa cada uno de sus miembros.
CREACION DE TDA EN MEMORIA.
GREIDY SIERRA
TIPOS DE DATOS:
VARIABLES:
INT
INT NMERO;
STRING
STRING NOMBRE;
DOUBLE
DOUBLE NOTA;
TDA(Tiempo)
TIEMPO HORA;
CORTE 1
La creacin 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.
DECLARACIN DE OBJETOS.
tiempo objtiempo;
tiempo arregloObjestos[10];
Estructuras ej1.
//Crea una estructura, establece sus miembros
y la imprime.
#include<iostream>
#include<iomanip>
//Definicin de la estrctura
struct Tiempo{
int hora;
int minuto;
int segundo;
}; //Fin de la estructura tiempo
//definicin 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;
GREIDY SIERRA
CORTE 1
}
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 funcin impresin 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 nmeros de telfono de nuestros amigos.
Necesitaramos un array de Cadenas para almacenar sus nombres, otro para sus apellidos y otro para
sus nmeros de telfono. Esto puede hacer que el programa quede desordenado y difcil de seguir. Y
aqu es donde vienen en nuestro auxilio las estructuras.*/
//declaracin de estructura
#include<stdio.h>
#include<iostream>
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telfono[10];
char edad;
};
//Declaracin de una variable con esa
estructura.
struct estructura_amigo 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
vaca en determinadas ocasiones
scanf("%s", &amigo.nombre);
printf("Escribe el apellido del amigo:");
fflush( stdout );
scanf("%s", &amigo.apellido);
printf("Escribe el nmero de telfono del
amigo:");
fflush( stdout);
scanf("%s",&amigo.telefono);
printf("El amigo %s %s tiene el nmero:
%s.\n", amigo.nombre, amigo.apellido,
amigo.telefono);
system("pause");
}
ARRAYS DE ESTRUCTURAS.
Supongamos ahora que tenemos que guardar la informacin de varios amigos. Con una variable de estructura solo podemos guardar
los datos de uno. Para manejar los datos de ms 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);
GREIDY SIERRA
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);
CORTE 1
printf("%s tiene ",

amigo[num_amigo].apellido);
printf("%i aos ", amigo[num_amigo].edad);
printf("y su telfono es el %s.\n ",
amigo[num_amigo].telefono);
}
system("pause");
}
INICIALIZAR UNA ESTRUCTURA.

A las estructuras se les pueden dar valores iniciales de manera anloga como hacamos 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>
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo = {
"Juanjo",
"Lpez",
"592-04873",
30
};
int main()
{
system("color 1F");
printf("%s tiene",amigo.apellido);
printf("%i aos", amigo.edad);
printf("y su telefono es el %s.\n",
amigo.telefono);
system("pause");
}
EJEMPLO 2:
#include<stdio.h>
#include<iostream>
char nombre[30];
char apel1ido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo[] = {
"Juanjo","Lpez","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 aos", 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>
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
GREIDY SIERRA
struct estructura_amigo amigo={

"juanjo",
"Lpez",
"454565",
30
};
int suma (struct estructura_amigo arg_amigo)
{
CORTE 1
return arg_amigo.edad+20;
}
int main()
{
printf("%s tiene", amigo.apellido);

printf("y dentro de 20 a{os tendr
%i.\n",suma(amigo));
system("pause");
}
EJEMPLO 2:
#include<stdio.h>
#include<iostream>
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo = {
"Juanjo",
"Lpez",
"454565",
30
};
int suma(struct estructura_amigo *arg_amigo) {
return arg_amigo->edad+20;
}
int main(){
printf("%s tiene",amigo.apellido);
printf("y dent de 20 aos 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 ms ordenada.
/* Una tienda de msica quiere hacer un programa
para el inventario de los discos, cintas y cds
que tienen. Para cada ttulo 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 cmo 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';
GREIDY SIERRA
CORTE 1
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 tambin el nombre porque la inicial y la primera letra del nombre son
la misma posicin 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_enumeracin {
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 ms 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");
}
GREIDY SIERRA
CORTE 1
APUNTADORES.
(*) <- Smbolo:
El uso de apuntadores en c++ es muy importante debido a que permite hacer los programas ms eficientes y ms flexibles (*)
Permiten manipular estructuras dinmicas (Arreglos, Listas, Pilas, Colas) de datos, es decir estructuras de datos que crecen y
disminuyen y cualquier tipo de variable.
(&) <- Smbolo:
La referencia es la obtencin de la direccin de una variable.
Una variable por lo general contiene un valor especifico en cambio un apuntador contiene la direccin 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.
DECLARACIN.
int *ptrcontador; // Apuntador a una variable int
Los apuntadores se pueden declarar para apuntar a un objeto de cualquier tipo.

La declaracin de un puntero no implica la reserva de memoria, salvo 2 bytes para almacenar una direccin en memoria,
por esa razn podra 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 dinmica 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 direccin 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 hara la instruccin
<<cout<<y<<endl;
EJEMPLO 1:
EJEMPLO 2:
#include<iostream>
#include<stdio.h>
#include<iostream>
void main(){
int a=4,z=5;
int*ptra;
ptra=&a;

void main(){
int x;
int *ptry=&x;
cout<<" La direccin en memoria de a

es"<<ptra<<endl;
cout<<" El valor de la variable a es
"<<*ptra<<endl ;
cout<<" La direccin con ampersam es
"<<&a<<endl;
cin>>*ptry; //Apuntador utilizado

cout<<x;
//tambin como entrada
system("pause");
}
system("pause");
}
GREIDY SIERRA
CORTE 1
LLAMADA A FUNCIONES POR REFERENCIA

Un parmetro puede ser pasado a una funcin de dos modos diferentes: por valor y por referencia. Pasarlo por valor implica que la funcin receptora hace
una copia del argumento y trabaja con ese doble del original, cualquier modificacin realizada en la variable-copia no producir ningn cambio en el
parmetro enviado. En cambio al pasar un valor por referencia estamos pasando la direccin 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 enva el dato y la que lo recibe.
Funcin paso por Valor:
#include<iostream>
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 funcin por valor es "<<numero<<endl;
system("pause");
CONTENIDO.
NUMERO
cuboPorValor(int num)
Cuando se llama la funcin se conectan las dos variables va

parmetros por valor, lo hace que el valor de nmero se le
asigne a num, de ah en adelante no tienen ninguna relacin
NUM
NUMERO
NUM
5
5
cout<<"El valor inicial del numero es
"<<numero<<endl;
cuboPorReferencia(&numero);//pasa la
direccin de numero a cuboPorReferencia
cout<<"El nuevo valor de numero es:
"<<numero<<endl;
system("pause");
}
void cuboPorReferencia(int *ptrN){
*ptrN>>*ptrN**ptrN**ptrN;
}
EJEMPLO 1:
Funcin paso por referencia
#include<iostream>
void cuboPorRefcrencia(int *); //Prototipo
void main(){ int numero=5;
EXPRESIONES ARITMTICAS
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 direccin de memoria.
La expresin ptr+k es un puntero que apunta a la direccin de ptr sumndole k veces el espacio ocupado por un elemento del tipo al que apunta (en este
caso un int).
GREIDY SIERRA
CORTE 1
RELACIN 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 subndices de arreglos, int b[5]; int *ptrB; ptrB = b;
*(ptrB+3); //Avanza a la tercera posicin del arreglo
EJEMPLO 1:
#include<iostream>
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 notacin de subndice de arreglo
cout<<"se imprime el arreglo b con: \n \n Notacin de subndice 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 subndice de arreglo
cout<<"\n Notacion de subndice 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>
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",
"Lpez",
"592-0483",
GREIDY SIERRA
CORTE 1
30
};
struct estructura_amigo *p_amigo;
int main(){
p_amigo = &amigo;
printf( "%s tiene ", p_amigo->apellido);
printf( "%i aos ", p_amigo->edad);
printf ("y su telfono es el %s.\n" ,
p_amigo->telefono);
system("pause");
10
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 aos.\n", p_amigo->edad);
EJEMPLO 2:
#include <stdio.h>
char nombre[30];
char apellidlo];
int edad;
};
struct estructura_amigo amigo, *p_amigo;
void mainO {
p.amigo = &amigo;
printf("Nombre: ");
PUNTEROS A ARRAYS DE ESTRUCTURAS.
EJEMPLO 1:
#include <stdio.h>
#include<iostream>
#define ELEMENTOS 3
20,
};
struct estructura_amigo *p_amigo;
void main(){
int num_amigo;
p_amigo = amigo; // Apuntamos al primer
elemento del array.
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo[] ={
"Juanjo",
"Lpez",
"504-4342",
30,
// 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 aos ", p_amigo->edad);
printf( "y su telfono es el %s.\n",
p_amigo->telefono);
/* y ahora saltamos al siguiente
elemento */
p_amigo++;
}
system("pause");
"Marcos",
"Gamindez",
"405-4823",
42,
"Ana",
"Martnez",
"533-5694",
GREIDY SIERRA
CORTE 1
11
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
//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 aos.\n", p_amigo->edad);
p_amigo++;
}
system("pause");
}
EJEMPLO 2:
#include <stdio.h>
#include<iostream>
#define ELEMENTOS 3
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: ");
mayor-p[0];
menor-p[0];
EJEMPLO 3:
/*crea un vector en forma dinmica y encuentra
el mayor y el menor,
utilizando apuntadores*/
#include<iostream>
int n,i;
float *ptr,mayor,menor;
int main(){
cout<<"DIGITE EL TAMAO 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];
GREIDY SIERRA
CORTE 1
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");
12
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 Programacin Orientada a Objetos (POO) es un estilo de programacin que emplea los objetos como
componentes fundamentales para la construccin de programas. Es decir, realiza un modelado de objetos reales, sus caractersticas y comportamientos.
CLASES.
Una clase se puede considerar como un patrn 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 slo 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 coleccin de objetos similares y un objeto es una instancia de una definicin de una
clase. La clase es simplemente una declaracin, no tiene asociado ningn objeto, de modo que no puede recibir mensajes ni procesarlos, esto
nicamente lo hacen los objetos.
//Sintaxis de La declaracin de una clase
class nombre_clase{
membro_dato1;
miembro_dato2;
class elemento{
char nom[20];
char marca [20];
int cantidad;
void aumentar_cantidad(int numero);
void disminuir_cantidad(int numero);
};
............
funcion_miembro1O;
funcion_miembro20;
};
EJEMPLO 1:
#include<iostream>
#include<string>
}
float EscrbirValor(){
return valor;
}
float salario(){
return salario;
}

class Empleados {
private:
int horas;
float valor, salario;
string nombre;
public ://Acesso a mtodos 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 mtodos getter
string EscribirNombre(){
return nombre;
}
int EscribirHoras(){
return horas;
GREIDY SIERRA
};
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");
}
CORTE 2
13
CONSTRUCTORES.
EJEMPLO 1:
#include<string>
#include <iostream>
#include <math.h>
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){
GREIDY SIERRA
CORTE 2
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 mrbida 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");
}
14
HERENCIA.
Es la propiedad que permite la creacin de clases a partir de clases que ya existen, las cuales heredan caracterstica 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 tambin pueden adicionar sus propias
caractersticas y funciones.
}
void setSalarioMen(float
EJEMPLO 1:
#include <iostream>
#include <string>
Sa ){

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;
GREIDY SIERRA
CORTE 2
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(
);
}
15
ESTRUCTURA DE DATOS DINMICAS.

A diferencia de las estructuras de datos estticas, como arreglos, estructuras y clases, en las que su tamao se establece
durante la compilacin y permanece inalterable durante la ejecucin del programa, las EDD pueden aumentar o disminuir
su tamao a medida que se ejecuta el programa.
LISTAS ENLAZADAS.
Son colecciones de elementos (llamados nodos) dispuestos uno a continuacin 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 informacin del objeto (caractersticas) 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 direccin del siguiente elemento de la lista.
Una representacin grfica de una EDD formada con objetos de una clase auto-referenciada.
En la grfica 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
GREIDY SIERRA
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.
CORTE 2
16
ASIGNACIN DE MEMORIA DINMICA.

En algunos casos, no se puede saber con anterioridad a la ejecucin cuantos elementos tendr dichas variables, y la mejor
solucin es crear un arreglo lo suficientemente grande y en algunos casos desperdiciar memoria. La forma de resolver este
inconveniente en C++ es la utilizacin de apuntadores y de ciertos operadores especiales que permiten gestionar una parte
de la memoria llamada memoria dinmica.
Los operadores new y delete hacen posible la reserva de memoria durante la ejecucin del programa, para variables
asignadas dinmicamente.
OPERADOR NEW.
El operador new asigna un bloque de memoria del tamao 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 direccin del bloque de
memoria asignado.
//Sintaxis para la utilizacin del operador new
tipo *apuntador=new tipo; //Para variables u objetos de cualquier tipo
tipo *apuntador=new tipo[tamao]; //Para arreglos de cualquier tipo y cualquier
tamao o bien
tipo *apuntador;
apuntador=new tipo;
//Asignacin de memoria dinmica
int main(){
int *ptr=new int;
//Reserva
memoria
dinmica
para
una
variable
entera
Cliente *ptr1 =new Cliente; //Reserva memoria dinmica 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.

//Asignacin de memoria dinmica int main(){
int *prt = new int (0); //inicializa en 0 la memoria dinmica para una variable
entera
cliente *ptrl = new cliente("Jessica", 00l);//lnicializa un objeto de la clase
cliente //con memoria dinmica, a travs de su constructor
}
OPERADOR DELETE.
Para casos en los cuales la capacidad de memoria dinmica 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 utilizacin es:
//Asignacin de memoria dinmica
int main(){
int *ptrnew;
int(0); //Inicializa en O la memoria dinmica 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
//dinmica, a travs de su constructor
delete ptr1; //Libera la memoria, el apuntador se puede continuar usando
}
GREIDY SIERRA
CORTE 2
17
LISTAS ENLAZADAS.
Una lista enlazada es una coleccin o secuencia de elementos (nodos), uno detrs del otro, en la que cada elemento se
conecta al siguiente a travs 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 (Informacin).
Enlace o apuntador (Apunta al siguiente nodo).
CLASIFICACIN DE LAS LISTAS ENLAZADAS.

Las listas se pueden dividir en cuatro categoras segn el nmero 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 bsicas 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 ningn otro.
EJEMPLO 1:
//crea una lista encadenada con los
nmeros de 1 a 4
#include <iostream>
struct nodo{
int clave;
nodo *sig;
};
void main(){
nodo *L;
nodo *p;
int i;
L = NULL; // Crea una lista vacia
GREIDY SIERRA
CORTE 2
for (i = 1; i <= 4; i++){

//Reserva memoria para un nodo
p = new nodo;
p->clave = i; // Introduce la
informacin
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");
}
18
EJEMPLO 2:
#include<iostream>
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<<" Nmeros: "<<pa->nro;
pa=pa->ste; //el mismo c=c+l
}
system("pau$e>null");
}
GREIDY SIERRA
CORTE 2
19
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 tambin como estructuras LIFO, por su sigla en ingls 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 coleccin 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 aade 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 informacin 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 lneas de espera, por ejemplo, en un banco o en un almacn; o cuando en una oficina muchos usuarios estn 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 aade 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 coleccin de elementos llamados nodos, uno de los cuales es distinguido y llamado raz junto con una relacin ser padre que impone
una estructura jerrquica en los nodos.
Un nodo, del mismo modo que un elemento en una lista, puede ser del tipo que deseemos. Puede ser un carcter, un string o un nmero.
Algunas veces puede ser conveniente incluir entre los arboles el rbol vaco, el cual no tiene nodos, que representamos con NULL.
Ejemplo: La tabla de contenidos de un libro. Esta es un rbol. La raz, llamada "libro tiene subrboles correspondientes a los captulos. Los captulos
tienen subrboles correspondientes a las secciones y estas subrboles correspondientes a las subsecciones.
LOS ARBOLES REPRESENTAN LAS SIGUIENTES CARACTERSTICAS.
El primer nodo de un rbol se denomina raz 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 raz.
La longitud de un camino es el nmero de ramas que contiene (tambin el nmero de nodos menos uno)
El nivel de un nodo es su distancia a la raz.
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 captulos son ancestros de
las secciones y subsecciones y estos ltimos son descendientes de los captulos.
Un nodo sin descendiente propio se llama hoja. Un subrbol de un rbol es un nodo junto con sus descendientes.
La altura de un nodo es el largo del camino ms largo del nodo a una hoja.
La profundidad de un nodo es el largo del camino nico de la raz a dicho nodo.
GREIDY SIERRA
CORTE 3
20
RECURSIN.
Un tema fundamental para los prximos temas es el de recursin. La recursin es muy importante tanto en matemticas como en computacin, pues
se usa recursin para definir procedimientos autosimilares.
Un objeto es recursivo si en su definicin 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;
}
}
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 resolucin de cierto tipo de problemas que, por sus caractersticas seran ms difciles de resolver de forma iterativa (con ciclos).
void funcin1() {
funcin1();
}
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 funcin e imprime resultado
}
GREIDY SIERRA
CORTE 3
21
ARBOL BINARIO.
Los rboles son EDD no lineales en dos dimensiones, a diferencia de listas, pilas y colas. Son muy utilizados para organizar informacin, por ejemplo para
organizar los archivos en sistemas operativos, o para tcnicas avanzadas de optimizacin como inteligencia artificial.
El concepto de rbol implica una estructura en la que los datos estn organizados de modo que los elementos de informacin se relacionen a travs de
ramas.
Un rbol binario es un rbol en el que ningn nodo puede tener ms de dos subrboles. Cada nodo puede tener cero, uno o dos hijos (subrboles). Es,
adems, una estructura recursiva, en la que cada nodo es el raz de su propio subrbol y, si tiene hijos, cada uno es raz del subrbol correspondiente,
que se conocen como subrbol izquierdo y subrbol derecho.
Los nodos de los rboles binarios contienen un campo para almacenar datos, y dos apuntadores, uno al subrbol izquierdo y otro al subrbol derecho.
Un rbol se divide en subrboles. Un subrbol es cualquier estructura conectada por debajo del nodo raz. Cada nodo de un rbol es la raz de un subrbol
que se define por ese nodo y todos sus descendientes. El primer nodo de un subrbol se conoce como la raz del subrbol. A su vez, los subrboles se
pueden dividir en subrboles.
RBOLES BINARIOS DE EXPRESIN.

Los rboles de expresin son una aplicacin muy importante de los rboles binarios, que permite organizar expresiones aritmticas compuestas por
operadores y operandos. Por ejemplo la expresin (b + c) * a + d.
Los rboles binarios de expresin presentan las siguientes propiedades:

El nodo raz y los nodos internos (no hojas) deben ser operadores.
Los nodos hoja deben ser operandos.
Cada subrbol es una subexpresin en la que el nodo raz es un operador.
Para construir un rbol de expresin se deben seguir casi las mismas reglas que para evaluar una expresin aritmtica, entre ellas la precedencia de los
operadores; los operadores que tienen mayor prioridad son los parntesis, seguidos de los operadores multiplicativos (multiplicacin y divisin) y por
ltimo los operadores aditivos (suma y resta); el nodo raz del rbol ser el del operador que tenga menor precedencia y se construye cada subrbol
siguiendo el mismo principio.
Por ejemplo, en el rbol de la figura anterior, que representa la expresin (b + c) * a + d , el operador que tienen menor precedencia es el segundo ms
(+), que suma dos subexpresiones (b + c) * a y d , que sern el subrbol izquierdo y derecho respectivamente; de la misma forma, en la primera
subexpresin, el operador multiplicacin (*) es el que tiene menor precedencia ya que lo que est entre parntesis se realiza primero, por esto se
convierte en la raz del subrbol izquierdo. Finalmente, la ltima subexpresin solo tiene un operador suma (+), que se convierte en nodo raz, con dos
hojas (b y c). Los nodos a y d tambin se convierten en hojas ya que cada subexpresin solo contiene un operando.
Este tipo de rboles se utiliza generalmente en compiladores de lenguajes de programacin para representar expresiones en memoria.
RBOLES BINARIOS DE BSQUEDA.

Los rboles binarios de bsqueda son rboles que organizan datos numricos no repetidos de forma tal que, dado un nodo, todos los nodos del subrbol
izquierdo tienen valores menores, mientras que todos los nodos del subrbol 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 bsqueda:
GREIDY SIERRA
CORTE 3
22
El procedimiento para la creacin de un rbol de este tipo es el siguiente:

El primer elemento que se inserta ser el nodo raz, 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 raz.- El siguiente elemento, en este caso el 9,
se inserta a la derecha debido a que es mayor que la raz.
Este procedimiento se sigue al insertar cada nodo.
Como se puede ver, para una serie de datos dada, puede haber muchos rboles binarios de bsqueda, 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 bsqueda es:
OPERACIONES EN RBOLES BINARIOS DE BSQUEDA.

Las operaciones ms comunes que se realizan en rboles de bsqueda son:
Insercin de un nodo.
Recorrido del rbol
Bsqueda de un nodo
La insercin 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 especfico 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 raz, un subrbol izquierdo y un subrbol derecho se definen tres secuencias de recorrido:
Recorrido preorden: primero se recorre el nodo raz, luego el subrbol izquierdo y finalmente el subrbol derecho; para procesar cada subrbol
se lleva a cabo la misma secuencia, dada la caracterstica recursiva de los mismos.
Recorrido enorden: primero se recorre el subrbol izquierdo, luego el nodo raz y finalmente el subrbol derecho; para procesar cada subrbol
se lleva a cabo la misma secuencia, dada la caracterstica recursiva de los mismos.
Recorrido postorden: primero se recorre el subrbol izquierdo, luego el subrbol derecho y finalmente el nodo raz; para procesar cada
subrbol
RECORRIDO EN ARBOLES BINARIOS.

Una de las operaciones ms importantes a realizar en un rbol binario es el recorrido de los mismos, recorrer significa visitar los nodos del rbol en forma
sistemtica, 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 vaco, cualquiera de los tres ordenamientos son la lista vaca.
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 raz n y subrboles TI; T2;:::; TK.
INORDEN.
PREORDEN.
POSTORDEN.
3, 4, 5, 7, 9, 14, 15, 18, 16, 17, 20.
ABDECFG
2, 5, 11, 6, 7, 4, 9, 5 y 2
Visitar la raz.
Recorrer el subrbol izquierdo en preorden
recorrer.
El subrbol derecho en preorden.
Recorrer el subrbol izquierdo en

postordenrecorrer.
El subrbol derecho en postorden.
Visitar la raz.
Recorrer el subrbol izquierdo en entreorden

visitar la raz.
Recorrer d subrbol derecho en entreorden.
GREIDY SIERRA
CORTE 3
23
GRAFOS.
Es un conjunto de objetos llamados vrtices 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 vrtices, y A es un conjunto de pares de vrtices, Lomadas aristas.
La posicin de los vrtices no importa, y se puede variar para obtener un grafo ms claro.
Prcticamente cualquier red puede ser modelada con un grafo: una red de carreteras que conecta ciudades, una red elctrica o un alcantarillado.
GRAFOS NO DIRIGIDOS.
Los elementos de V se Llaman vrtices o nodos.

Los pares de E son no ordenados se Llaman aristas se representan con puntos y Lneas.
V= {V1,V2,V3,V45,V5}
Cada elemento del conjunto se llama vrtice 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 lnea.
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 vrtices
MATRIZ DE ADYACENCIA.
GREIDY SIERRA
CORTE 3
24
GRADOS DE GRAFOS NO DIRIGIDOS.

Se llama grado de v al nmero de aristas incidentes en v, en caso que la arista es un bucle se cuenta por dos
GREIDY SIERRA
CORTE 3
25
EJERCICOS.
TALLER 1:
#include <iostream>
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 piatera. Definir las funciones miembro: Ingresar datos, borrar datos, imprimir datos e implementar cada una.
#include <iostream>
#include <iomanip>
#include <string>
struct Bomba {
string color;
string forma;
GREIDY SIERRA
TALLERES
26
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");
}
-----------------------------------------------------------------------------------------------------------------------------------------
GREIDY SIERRA
TALLERES
27

EJERCICIO 2.
// Supermercados Cafam desea manejar el kardex de sus artculos teniendo como base el nombre, item, precio y existencias.
Necesita manejar entrada de artculos, salida de artculos, bsqueda de algn artculo especfico.
#include <iostream>
#include <string>
#include <iomanip>
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].exist=100;
datos[2].item=1203;
datos[2].nombre="Azucar";
datos[2].exist=40;
datos[3].item=1204;
datos[3].nombre="Sandia";
datos[3].exist=15;
}
void Imprimir(){
cout<<endl;
cout<<"\t\t\t\t
cout<<"\t\tITEM
cout<<endl;
LISTADO DE PRODUCTOS \t\t\t\t"<<endl<<endl;

NOMBRE
PRECIO
CANT. EXISTENTE "<<endl;
for (int i=0;i<=3;i++){

cout<<"\t\t"<<datos[i].item<<"
\t"<<datos[i].exist<<endl;
"<<datos[i].nombre<<"
\t"<<datos[i].precio<<"\t
}
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++;
}
}
GREIDY SIERRA
TALLERES
28
if (cont==4) {
cout<<" DATO ERRADO O PRODUCTO NO EXISTENTE "<<endl;
}
system("pause");
}
void salida_prod(){
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(){
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;
}
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;
GREIDY SIERRA
TALLERES
29
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 climticas que se presentan en Colombia, dividida por regiones as: Orinoqua,
Amaznica, Andina, Caribe, Insular, Pacfica. Cada una de estas regiones tiene unas zonas principales que deben involucrar
cdigo de regin, nombre, fecha de fundacin, cantidad de habitantes.
#include <iostream>
#include <string>
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;
}
GREIDY SIERRA
TALLERES
30
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 AO 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;
}
}
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\t";
cin>>op;
acum++;
switch (op){
GREIDY SIERRA
TALLERES
31
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.
//Polimrica S.A., lder en Colombia para la fabricacin 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 mtodos involucrados en el mismo, indicar los mtodos(funciones
miembro), y los datos miembro.
#include <iostream>
#include <iomanip>
#include <string>
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[2].color="gris";
datos[2].peso="200";
datos[2].forma="rectangular";
datos[2].id=1203;
}
void Imprime(){
cout<<"\t\t\t\t
cout<<"
Id \t
LISTA
COLOR
\t\t\t\t"<<endl<<endl;
PESO \t FORMA \t
EXISTENCIAS"<<endl<<endl;
for (int i=0;i<=2;i++){

cout<<" "<<datos[i].id<<"
"<<datos[i].color<<"
\t"<<datos[i].forma<<" \t"<<datos[i].existencias<<endl;
}
cout<<endl<<endl;
}
GREIDY SIERRA
TALLERES
"<<datos[i].peso<<"
32
void Agregar(){
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(){
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);
GREIDY SIERRA
TALLERES
33
}
------------------------------------------------------------------------------------------------------------------------TALLER 3:
//Modelo: biblioteca. Se debe llevar registro de: (a) informacin de libros: ttulo del libro, nombre del autor. ISBN
(numero de hasta 7 dgitos), cantidad de ejemplares, nmero correlativo de prstamo. (B) informacin de socios: nombre del
socio, cdula de identidad, nmero correlativo de prstamo. (c) informacin de prestamos: ISBN del libro. C.I. del socio,
nmero correlativo de I prstamo. DeFina la representacin de los datos y que operaciones se consideran necesarias para
manejar la informacin de la biblioteca. Describa lo que debe realizar cada operacin.
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <string>
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);
GREIDY SIERRA
TALLERES
34
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 1. REGISTRAR LIBROS"<<endl;
cout<<"\t\t\t 2. REGISTRAR SOCIO"<<endl;
cout<<"\t\t\t 3. REGISTRAR PRESTAMO"<<endl;
GREIDY SIERRA
TALLERES
35
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>
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);
cout<<"cuantos"<<*ii;
for(int j=0;j<*ii;j++){
buscar(discotienda[j],autor,j);
}
GREIDY SIERRA
TALLERES
36
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);
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 nmeros de tipo real en la funcin principal; que en una funcin los
intercambie va parmetros por referencia y los imprima en la funcin principal.
#include<stdio.h>
#include<iostream>
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;
GREIDY SIERRA
TALLERES
37
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 capica; es capica si se lee igual de izquierda
a derecha que en sentido contrario. Ejemplo 1991. Usar parmetros por valor y por referencia.
#include <iostream>
#include <iomanip>
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 nmeros de tipo entero e imprima el mayor, utilizando una funcin para leer los
nmeros, otra funcin para obtener y devolver el mayor y una funcin para imprimir el mayor. Usar parmetros por valor y
por referencia.
#include <iostream>
#include <iomanip>
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];
GREIDY SIERRA
TALLERES
38
}
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 cdigo 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 ledos 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 (cdigo y nota) que obtuvieron una nota por encima de la media aritmtica (promedio) de todo el curso. e)
Imprima cdigo y nota para la mnima nota y para la mxima nota.
#include<iostream>
#include<stdio.h>
//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
void mayor_menor(struct
struct datos_estudiante
struct datos_estudiante
DINAMICO Y VARIABLE APUNTADOR

datos_estudiante *est);
*est= new struct datos_estudiante[cant_est];
*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;
GREIDY SIERRA
TALLERES
39
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++){
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){
GREIDY SIERRA
TALLERES
40
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
prot=prot+(n[j].notas_t);
}
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
if(cod==(ptrdatos->codigo)){
//PROMEDIO DE NOTAS DE TALLERES Y QUICES
GREIDY SIERRA
TALLERES
41

prot=prot+(n[j].notas_t);
ptrdatos++;
}
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;
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++;
}
GREIDY SIERRA
TALLERES
42
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 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 funcin que verifique si dos listas son iguales (mismos elementos en el mismo orden).
Escribir una funcin que verifique si un elemento x se encuentra en una lista l.
Escribir una funcin que cuente la cantidad de ocurrencias de un elemento x en una lista l.
AUTOR: GREIDY SIERRA.
FECHA: 18-09-2013. */
#include<iostream>
//Captura datos clase autoreferenciada
int cant2=0;
int cant=0;
class Nodo1{
private:
int nro;
Nodo1 *ste;
GREIDY SIERRA
TALLERES
43
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;
GREIDY SIERRA
TALLERES
44
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){
GREIDY SIERRA
TALLERES
45
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
cout<<"\t\t\t 1.
cout<<"\t\t\t 2.
cout<<"\t\t\t 3.
cout<<"\t\t\t 4.
cout<<"\t\t\t 5.
cin>>op;
switch (op){
case 1:
int op1;
do{
* MENU PRINCIPAL * \t\t\t\t"<<endl;

INGRESAR DATOS"<<endl;
VERIFICAR LISTAS IGUALES"<<endl;
BUSCAR ELEMENTO"<<endl;
CONTAR OCURRENCIAS"<<endl;
SALIR"<<endl;
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;
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
cout<<"\t\t\t 1. BUSCAR ELEMENTO EN LISTA 1"<<endl;
cout<<"\t\t\t 2. BUSCAR ELEMENTO EN LISTA 2"<<endl;
cin>>op2;
switch (op2){
case 1:
buscar_l1();
break;
case 2:
buscar_l2();
break;
}
}
while (op2!=3);
break;
case 4:
GREIDY SIERRA
TALLERES
46
int op3;
do{
cout<<"\t\t\t\t
cout<<"\t\t\t 1. OCURRENCIAS EN LISTA 1"<<endl;
cout<<"\t\t\t 2. OCURRENCIAS EN LISTA 2"<<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>
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){
GREIDY SIERRA
TALLERES
47
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;
GREIDY SIERRA
TALLERES
48
}
}
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 informacin
de las cuentas la cual es nombre del titular de la cuenta, nmero de la cuenta, fecha de creacin
y saldo de la cuenta.
Usted debe crear una estructura de datos que le permita almacenar la informacin de las cuentas,
GREIDY SIERRA
TALLERES
49
cree un men de opciones que permita: Primero ingresar la informacin de las cuentas, eliminar
informacin 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>
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: ";
GREIDY SIERRA
TALLERES
50
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;
}
GREIDY SIERRA
TALLERES
51
}
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);
}
-----------------------------------------------------------------------------------------------------------------------------------------TALLER 8:
/* COLAS
FECHA: 01-10-2013
*/
#include <iostream>
#include <stdlib.h>
struct Nodo{
int nro;
struct Nodo *ste;
};
struct cola{
Nodo *pd;
Nodo *pa;
GREIDY SIERRA
TALLERES
52
};
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;
num = p_aux->nro;
q.pd=(q.pd)->ste;
delete(p_aux);
// el apuntador p_aux apunta al inicio de la cola

// 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
GREIDY SIERRA
TALLERES
53
FECHA: 01-10-2013
*/
#include <iostream>
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;
}
GREIDY SIERRA
TALLERES
54
else{
cout<<"\n PILA VACIA"<<endl;
}
break;
cout<<endl<<endl;
system("pause");
system("cls");
return 0;
}
}while(op!=4);
}
------------------------------------------------------------------------------------------------------TALLER 9:
/* CLASES AUTOREFERENCIADAS (PONTENCIAS)
FECHA: 04-10-2013
*/
#include <iostream>
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)
FECHA: 04-10-2013
*/
#include <iostream>
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)
FECHA: 04-10-2013
*/
#include <iostream>
GREIDY SIERRA
TALLERES
55
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 funcin que devuelva el numero de nodos de un rbol binario
Escribir una funcin que retorna la distancia mxima de la raz a una hoja
Escribir una funcin que retorna el numero de subarboles izquierdos no vacos. */
#include<iostream>
#include<stdlib.h>
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;
GREIDY SIERRA
TALLERES
56
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");
GREIDY SIERRA
TALLERES
57
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;
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);
}
}
GREIDY SIERRA
TALLERES
58
void postorden(ABB &arbol){ //Izquierda || Derecha || Raiz

if (arbol!=NULL){
postorden(arbol->izq);
postorden(arbol->der);
}
}
void preorden(ABB &arbol){ // Raiz || Izquierda || Derecha
if (arbol!=NULL){
preorden(arbol->izq);
preorden(arbol->der);
}
}
void impresion_basica(ABB &arbol){ //Para no poner el mismo cdigo 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 funcin 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 funcin 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 raz 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>
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){
GREIDY SIERRA
TALLERES
59
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);
}
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);
}
GREIDY SIERRA
TALLERES
60
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;
system("cls");
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;
system("cls");
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;
}
GREIDY SIERRA
TALLERES
61
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>
/*--------- 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;
};
GREIDY SIERRA
TALLERES
62
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);
}
GREIDY SIERRA
TALLERES
63
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);
GREIDY SIERRA
TALLERES
64
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;
GREIDY SIERRA
TALLERES
65
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");
}while(op!=11);
// hacer pausa y presionar una tecla para continuar
}
------------------------------------------------------------------------------------------------------BUSQUEDA Y ORDEN:
#include<iostream>
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;
GREIDY SIERRA
TALLERES
66
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);
}
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;
GREIDY SIERRA
TALLERES
67
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;
GREIDY SIERRA
TALLERES
68
}
else if (aux->info > buscar){
auxfin = aux;
}
}
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;
GREIDY SIERRA
TALLERES
69
}
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>
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();
GREIDY SIERRA
TALLERES
70
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...!!!!";
GREIDY SIERRA
TALLERES
71
}
}
//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;
}
GREIDY SIERRA
TALLERES
72
}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:";
GREIDY SIERRA
TALLERES
73
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;
}
}
GREIDY SIERRA
TALLERES
74

Programacíon C++ 3

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programacíon C++ 3

Transféré par

Droits d'auteur :

Formats disponibles

INTRODUCCIN.

Se utilizan las palabras reservadas:

CREACION DE TDA EN MEMORIA.

fflush(stdout); //Sirve para vaciar el buffer

gets(amigo[num_amigo].nombre); //lee con

printf("%s tiene ",

INICIALIZAR UNA ESTRUCTURA.

PASO DE ESTRUCTURAS A FUNCIONES.

struct estructura_amigo amigo={

printf("%i aos", amigo.edad);

ESTRUCTURAS DENTRO DE ESTRUCTURAS (ANIDADAS).

printf("\nAhora tu nombre es %s\n", pers.nombre);

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

PERADORES PARA APUNTADORES.

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

using namespace std;

cout<<" La direccin en memoria de a

cin>>*ptry; //Apuntador utilizado

LLAMADA A FUNCIONES POR REFERENCIA

Cuando se llama la funcin se conectan las dos variables va

RELACIN ENTRE APUNTADORES Y ARREGLOS

PUNTEROS A ARRAYS DE ESTRUCTURAS.

// Ahora imprimimos sus datos

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

using namespace std;

using namespace std;

ESTRUCTURA DE DATOS DINMICAS.

CLASES AUTO - REFERENCIADAS

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

ASIGNACIN DE MEMORIA DINMICA.

Asignar un valor o inicializar la memoria que se ha reservado.

CLASIFICACIN DE LAS LISTAS ENLAZADAS.

for (i = 1; i <= 4; i++){

LOS ARBOLES REPRESENTAN LAS SIGUIENTES CARACTERSTICAS.

El primer nodo de un rbol se denomina raz del rbol.

RBOLES BINARIOS DE EXPRESIN.

Los rboles binarios de expresin presentan las siguientes propiedades:

RBOLES BINARIOS DE BSQUEDA.

El procedimiento para la creacin de un rbol de este tipo es el siguiente:

OPERACIONES EN RBOLES BINARIOS DE BSQUEDA.

RECORRIDO EN ARBOLES BINARIOS.

3, 4, 5, 7, 9, 14, 15, 18, 16, 17, 20.

Recorrer el subrbol izquierdo en

Recorrer el subrbol izquierdo en entreorden

Los elementos de V se Llaman vrtices o nodos.

GRADOS DE GRAFOS NO DIRIGIDOS.

cout<<"INGRESE LA CANTIDAD: ";

LISTADO DE PRODUCTOS \t\t\t\t"<<endl<<endl;

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

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

cout<<"el valor inicial de los numeros es: "<<num1<<" y "<<num2<<" respectivamente"<<endl;

DINAMICO Y VARIABLE APUNTADOR

//DECLARACION DE FUNCION PARA INGRESAR DATOS

cout<<"ERROR, DIGITE NUEVAMENTE LA NOTA "<<j+1<<" DE TALLERES DE "<<ptrdatos->nombre<<"

for(i=0; i<cant_est; i++){

for(j=0; j<cant_nt; j++){

cout<<"EL ESTUDIANTE "<<"CODIGO: "<<ptrdatos->codigo<<" NOMBRE: "<<ptrdatos->nombre<<" OBTUVO LA MAYOR

* MENU PRINCIPAL * \t\t\t\t"<<endl;

// el apuntador p_aux apunta al inicio de la cola

// asignamos el primer vamor de la pila

double fibonacci(int n){

cout<<"|| 3) Observar Datos (Inorden)..........................||"<<endl;