UNIVERSIDAD NACIONAL DE INGENIERIA

ARCHIVOS
FACULTAD DE INGENIERIA INDUSTRIAL Y DE SISTEMAS

Programación Dinámica:
Punteros
I.-RAM II.-Fisico

Córdova Neri, T
Company Logo
 Contenido
Introducción a la Programación Dinámica

Punteros

Declaración de variables Dinámicas simples

Aplicación usando variables dinámicas simples

Declaración de variables Dinámicas Registro

Creación de Pilas

Pilas con múltiples Punteros

Pila con n nodos

Proceso de Archivo con Pilas

Aplicaciones
 3.-Diseñar
1.- Definir
2.- Procesar sistemas de
nueva
registros mantenimiento
estructura de
almacenados usando
datos forma
en un Archivo. Programación
Dinámica
Dinámica
Un puntero es un objeto que apunta a otro objeto. Es decir,
una variable cuyo valor es la dirección de memoria de otra
variable. Las direcciones de memoria dependen de la
arquitectura del ordenador y de la gestión del sistema
operativo Valor

Puntero

Variable

Simple Nodo
Operadores de Punteros
Existen dos operadores :

 Operador de dirección: & Representa la dirección de

memoria de la variable que le sigue:
(& dato): representa la dirección de dato.

Operador de contenido o indirección: * Permite

acceder a la variable situada en la dirección de memoria que
se especifica en el operando.

(*dato): es el contenido del la dirección de dato

Liberar Espacio de memoria : delete dato;

Declaración de variables puntero
T
Se declara como todas las variables y donde su
identificador va precedido de un símbolo asterisco (*).
veamos:
int * dato , donde:
dato: Es una variable puntero a una variable de tipo entero.

char *letra;
Letra: Es un puntero a variable de tipo carácter.
float *num;
float *mat[5]; // . . .
Asignación de Direcciones a los variables Puntero

Después de crear una variable puntero, se debe asignar una dirección

memoria donde se procesa cualquier tipo de dato; simple, Estructuras,
etc. Usar el siguiente método;

A = new int;

Dirección de memoria a

Porción de memoria
*a

Puntero Nulo:
a=NULL
 Int *dato,*valor ? dato ? valor

Dirección de memoria dato ? valor

Porción de memoria * dato *valor

dato= new int, valor= new int

Variable Dinamica

1 palabra = 1 byte =8 bits

0 0 1 1 1 …….. 1
0001 valor
0010 dato
0101
1000 valor
……….
1111
0000
Aplicación 1.- Leer 2 números en forma dinámica y buscar el
mayor

void main()
{ int *a,*b,mayor;
a=new int
b=new int;
gotoxy(10,4);
cout<<"Ingrese a = "; cin>>*a;
gotoxy(10,5);
cout<<"Ingrese b = "; cin>>*b;
if(*a>*b)
{mayor=*a;
}
else
{mayor=*b;
}
gotoxy(10,9); cout<<"de "<<*a<<" y "<<*b<<" el mayor es =
<<mayor;
delete a; delete b;
getche();
}
II.- Uso de estructuras y Archivos

Registro (Nodo)

Typedef struct alumnos File *datos

{ int cod, edad
struct alumnos * sigte;
} nodo;
Nodo: es un puntero de tipo registro el cual iene n campos denominados:
1.- De Usuario y
2.- Del Sistema

p q
typedef struct Alumnos
{ int nota;
Nuevo(q)
struct Alumnos *sigte; Nuevo(p)

Nodo
}nodo;
12 NULL
nota sigte nota sigte
Nodo
Variables
nodo *p,*q ;
P  nota = 12

p = new nodo; P --> . Sigte = NULL

q = new nodo;
12
 ESTRUCTURAS DINAMICAS:PILAS(LIFO)

Una pila representa una

estructura lineal de datos en
que se puede agregar o quitar
elementos únicamente por *
uno de los dos extremos. En
consecuencia, los elementos
de una pila se eliminan en el
orden inverso al que se
insertaron. Debido a está
característica, se le conoce
como estructura LIFO (last
input, first output)
 LIFO :
Para esta técnica es necesario el uso de Registros

ESTRUCTURAS: PILAS
Declaración
P
Typedef struct Nodo
{ int *P
struct Nodo *sigte;
} Nodo;
dato sigte
Lectura - Escritura

typedef struct nodo

{ int nota;
struct nodo *sigte;
} nodo;

void main()
{ nodo *p;
p=new nodo;

cin>> p -> nota; / / LECTURA

cout<< r -> nota // ESCRITURA

}
Técnica para diseñar una PIL A

typedef struct nodo p q r

{ int nota;
struct nodo *sigte;
} nodo; ? ?
void main()
{ nodo *p,*q,*r;
p=new nodo; q=new nodo; r=new nodo;
cout<<"Nota P = "; cin>>p->nota;
cout<<"Nota q = "; cin>>q->nota;
p->sigte=q;
cout<<"Nota r = "; cin>>r->nota;
q->sigte=r;
r->sigte=NULL;
cout<<"PILA : "<<r->nota<<"-->"<<q->nota<<"-->"<<p->nota;
delete p; delete q; delete r;
}

Pila formada:
Recorrer Pila.- Para ingresar a recorrer una pila, se debe sacar una
copia para NO perder las direcciones de sus elementos y luego con
la copia hacer procesos

p: Pila original Original

aux=p;//copia

while(aux!=NULL)
{ if (aux->nota >10)
{ ap++;
notas[ap]=aux->nota;
} Copia
else
{ de++;
notasde[de]=aux->nota;
}
aux=aux->sgte;
}
Diseñar un programa que permita almacenar las notas de tres alumnos en
una estructura dinámica pila, luego genere un reporte de los elementos de
la pila, su promedio. liberar (eliminar) espacio de memoria utilizada por cada
nodo. Use los siguientes modulos

crear(nodo *p,nodo *q,nodo *r): permite crear nodos con asignación de

memoria
leer(nodo *p,nodo *q,nodo *r): proceso para leer notas

float prom(nodo *&p,nodo *&q,nodo *&r): funcion para calcular promedio

a b c

*a *b *c
typedef struct nodo
{ int nota;
struct nodo *sigte;
}nodo;
nodo *a,*b,*c;

void crear(nodo *p, nodo *q, nodo *r)

{ a=new nodo; b=new nodo; c=new nodo;
return;
}
void leer(nodo *p,nodo *q,nodo *r)
{ gotoxy(10,7); cout<<"Ingreso de Notas ";
gotoxy(5,8); cout<<" ---------------------------";
do{ gotoxy(10,10); clreol();system("color 1b");
cout<<"Nota P = "; cin>>p->nota;
} while(p->nota<0 || p->nota>20 );
gotoxy(10,11); cout<<"Nota q = "; cin>>q->nota;
p->sigte=q;
gotoxy(10,12); cout<<"Nota r = "; cin>>r->nota;
p->sigte=r;
r->sigte=NULL;// fin de crear PILA
gotoxy(5,14); cout<<" ---------------------------";
return;
}
 float prom(nodo *&p,nodo *&q,nodo *&r)
{ float pp; gotoxy(10,17);
cout<<"PILA :"<<r->nota<<" --> "<<q->nota<<" --> "<<p->nota;
pp=(p->nota+q->nota+r->nota)/3.0;
return pp;
}
void main()
{char resp; int na=0;
do{clrscr(); na++;

gotoxy(10,4);cout<<"Alumno No."<<na;
system("title Cordova Neri, T. Pila_3_notas.cpp"); system("color CE");
gotoxy(20,12);cout<<" Cargando sistema de Notas...espere....";
caratula1(); system("color CE"); Sleep(1800);
caratula(); system("color 1a"); caratula();
textcolor(1);gotoxy(50,22);cout<<"Favor espere....";
caratula1(); Sleep(1800);
clrscr(); caratula1();
crear(a,b,c) ;
leer(a,b,c);cout<<" Promedio = "<<prom(a,b,c);
gotoxy(10,22); cout<<"Desea continuar..?(S/N)==>";
resp=toupper(getche());
}while(resp=='S');
}
Aplicación 2.- Diseñar un programa que permita almacenar notas de alumnos en
una pila de tamaño n (n definido por usuario), luego clasificar notas aprobadas y
guardar en el vector Aprob[ ], así como notas desaprobadas y guardar en el vector
desp[ ]. Luego genere un reporte de los elementos de la pila. Use los siguientes
subprogramas:
crear_nodo (int valor): función para inicializar e ir creando nodos.
crear_lista (nodo *&p): procedimiento para crear la pila.
aprob_desap (nodo *&p): procedimiento para recorrer la pila en busca de notas
aprobadas y desaprobadas.
Listar datos (nodo *&p): procedimiento para recorrer la pila y mostrar la
estructura formada por todos los elementos de cada nodo, tal como se ilustra en la
figura adjunta.
Int n,j, i, aprob=0, desap=0,de=0,ap=0,notas[100], notasde[100],aux, datos[100];

Typedef struct notaslaumnos

{ int nota;
structnotaslaumnos *sgte;
}nodo;

nodo *crear_nodo(int valor)

{ nodo *r;
r = new nodo;
r->nota=valor ;
r->sgte=NULL ;
return(r );
}

Void marco()
{ int i; time_t t; t = time(&t);gotoxy(12,3);cout<<"Fecha y hora actual : "<<ctime(&t);
gotoxy(10,20) ;cout<<"È"; gotoxy(10,4) ;cout<<"É"; //esquinas
for (i=11 ;i <=59 ; i++) {gotoxy(i,4) ;cout<<"Í"; gotoxy(i,5) ;cout<<"Í";
gotoxy(i,20) ;cout<<"Í"; }
gotoxy(60,4) ;cout<<""; gotoxy(60,20) ;cout<<" "; //esquinas
for(i=5;i<=19;i++) {gotoxy(10,i) ;cout<<"º"; gotoxy(60,i );cout<<"º";
Void crear_lista(nodo *&p
{ marco();
int nota,i;
nodo *r;
p=NULL;
gotoxy(16,7);cout<<"Ingrese numero de nodos: ";cin>>n;
for(i=1;i<=n;i++)
{
gotoxy(18,i+8);cout<<"Nota "<<i<< ": ";cin>>nota;

r=crear_nodo(nota;
if (p==NULL)
{p=r;
}
else
{ r->sgte=p;
p=r;
}
}
}
Logica del procedimiento: crear_lista(nodo *&p )

----------------
cout<<“Ingrese numero de nodos : ”,
cin>>n; ? p caso1

For (i = 1 ;i<=n; i++)

{
cout<<“ código = ”), cin>> cod; p caso2
cout<<“ nombre = ”), gets(nomb )

r  Crea_nodo(cod , nomb )
1 A 2 M
ii(p==NULL)
{
p = r; r
}
else //pila xiste
{
r ->sigte = p
4 Ana NULL r
p=r; Cod nomb sigte
}
}
void aprob_desap(nodo *&p)// recorrer la pila
{ marco(); nodo *aux aux=new nodo; aux=p;
while(aux!=NULL)
{ if (aux->nota >10)
{ap++; notas[ap]=aux->nota;
}
else
{ de++; notasde[de]=aux->nota;
}
aux=aux->sgte;
}
gotoxy(13,n+10);cout<<"Total Aprobados: "<<ap;
gotoxy(18,n+11);cout<<"Notas ";
for(i=1;i<=ap;i++) // vector notasaprob
{ gotoxy(15,n+12);cout<<"----"; gotoxy(18,i+16);cout<<i<<".-
"<<notas[i]<<endl; }
gotoxy(36,n+10);cout<<"Total Desaprobados: "<<de;
gotoxy(42,n+11);cout<<"Notas "<<endl;
for(i=1;i<=de;i++) { gotoxy(39,n+12);cout<<"----------------";
gotoxy(40,i+16);cout<<"\t"<<i<<".-"<<" "<<notasde[i]<<endl;
} }
Void ListarDatos(nodo *&p
{
nodo *aux;// para obtener copia
aux=new nodo;// su espacio de memoria
aux=p; //hacer copia de p en aux

if(aux==NULL)
cout<<"\n\nLA LISTA ESTA VACIA"<<endl;
int k=0;
while(aux!=NULL)
{ k++;
gotoxy(14,10); cout<<"PILA: ";
gotoxy(12+7*k,11);cout<<" -> "<<aux->nota;
aux=aux->sgte;
getch();
}
void buscar_nota(nodo *&p)
{ int notas,nn=0; marco();
nodo *aux;// para obtener copia
aux=new nodo;
aux=p;
gotoxy(13,15);cout<<"Ingrese Nota a Buscar = ";cin>>notas;
while(aux!=NULL)
{ if(aux->nota==notas)
{ nn++;
}
aux=aux->sgte;// pasar al nuevo nodo
}
gotoxy(13,16);cout<<"Total de Notas Encontradas = "<<nn;
}
void main()
{nodo *lista;crear_lista(lista);aprob_desap(lista); getch(); clrscr();
marco(); ListarDatos(lista); // clrscr(); marco();
buscar_nota(lista);getche();
}