Datos Punteros e Implementación Dinámica de Pilas

Datos Punteros e Implementación
Dinámica de Pilas
Lección 8

Índice
• 8.1 Datos puntero y datos dinámicos
• 8.2 Estructuras de datos recursivas:
representación mediante punteros y datos
dinámicos
• ADA: Tipos puntero y datos dinámicos
• 8.3 Representación dinámica de una pila e
implementación de operaciones

Datos puntero y datos dinámicos
• Un puntero es un dato cuyo valor es la dirección
en memoria de otro determinado dato.
p
1467 1467 dato
• El valor de p puede verse como un apuntador
(puntero) del dato, gráficamente se representa
así:
p
dato

• La dirección almacenada en un puntero va a
ser transparente al programador. A éste sólo
le interesa conocer el valor de un puntero
como referencia a un determinado dato.
• Los punteros con los que vamos a trabajar
están especializados para servir como
referencia de datos de un determinado tipo.
• Nuestro lenguaje algorítmico estará dotado
del siguiente mecanismo constructor de
datos puntero:
tipos tx = ...
...
tp_punt_a_tx = tx
...
variables p,q:tp_punt_a_tx

• Un puntero se puede utilizar para servir de referencia
de datos creados dinámicamente (es decir, durante
la ejecución del algoritmo (*) ) mediante la instrucción:
nuevoDato(p)
que tiene como efecto la reserva de espacio para
almacenar una nueva variable del tipo apuntado por
el puntero p, es decir, del tipo tx; esta variable queda
apuntada por el puntero p:
antes después
p ?
p dato
creado
(*) Se denominan datos estáticos los almacenados en las variables
declaradas al principio de los algoritmos (variables estáticas) y datos
dinámicos los referenciados por un puntero (durante la ejecución del
algoritmo).

• Un dato creado dinámicamente no tiene ningún
identificador asociado como nombre. Se puede hacer
referencia a él a través de algún puntero, p, que
apunte al dato, de acuerdo con la siguiente sintaxis:
p
que significa “dato apuntado por el puntero p”.
p
• A una variable de tipo puntero se le puede asignar el
valor de otra variable de tipo puntero (ambos deben
ser punteros de datos del mismo tipo):
q:=p
p
q
p
p
q

• En este caso, el dato creado dinámicamente puede
ser accedido de dos formas:
p
q
• Existe un valor constante, nil, que debe ser
asignado a todo puntero que se desee que no apunte
a ningún dato. A cualquier variable de tipo puntero
(independientemente del tipo del dato al que apunte)
puede ser asignado dicho valor:
p:=nil
• La acción opuesta a nuevoDato es disponer:
disponer(p)
– Esta instrucción libera la zona de memoria que
ocupaba el dato apuntado por el puntero p.
• Finalmente, dos datos de tipo puntero (a datos del
mismo tipo) pueden ser comparados con los
operadores relacionales de igualdad (=) o
desigualdad ().

Estructuras de Datos Recursivas
• Estructuras recursivas serían aquellas que en su
definición incluyesen un dato de su mismo tipo
– Problema: cómo sabría el compilador o interprete
cuánta memoria debe asignarle a una variable
estática de ese tipo?

Estructuras de Datos Recursivas
• Se definen utilizando punteros a diferentes
partes de la estructura
– El tamaño y forma de la estructura podrá
variar en ejecución (dinámica)

Punteros y Datos Dinámicos en Ada
• Declaración de tipos
OPCIÓN 1:
type celda is
record
valor: integer;
siguiente: enlace; -- enlace sin definir
end record;
type enlace is access celda;
OPCIÓN 2:
type enlace is access celda;--celda sin definir
type celda is
record
valor: integer;
siguiente: enlace;
end record;
En ADA, se declara un tipo
puntero para acceder a datos
de un determinado tipo

Punteros y Datos Dinámicos en Ada
• Declaración de tipos
OPCIÓN CORRECTA (declaración circular):
type celda; -- declaración parcial
type enlace is access celda;
-- declaración tipo punteros a celdas
type celda is -- declaración completa de celda
record
valor: integer;
siguiente: enlace;
end record;

Punteros y Datos Dinámicos en Ada
• Declaración de punteros y creación dinámica de datos
type celda;
type enlace is access celda;
type celda is
record
valor:integer;
siguiente:enlace;
end record;
e:enlace; -- equivale a e:enlace:=null;
e:=new celda;
e.valor:=13;
e:=new celda'(13,null);
e
e
•
•
e
?
null
13
null
•
En ADA, todo puntero no
inicializado toma valor null
Es válido asignar o
comparar null para
cualquier tipo de puntero
e
13
null
null

Punteros y Datos Dinámicos en Ada
type celda;
type enlace is access celda;
type celda is
record
valor:integer;
siguiente:enlace;
end record;
e:enlace; e null
e:=new celda'(13,null);
e:=new celda'(7,e);
{
•
e
1- Evaluación de la expresión
7
•
2- Asignación del valor
•
7
•
13
null
e
e
•
•
13
null
13
null

Punteros y Datos Dinámicos en Ada
• Asignación de punteros
e,f:enlace;
f:=new celda'(13,null);
e:=f;
f
e
•
•
f:=new celda'(13,null);
e:=new celda;
e.all:=f.all;
e
null
f
e
13
null
•
•
f
null
f
e
f
e
•
null
13
null
13
null
•
•
13
null
13
null
?
null

Punteros y Datos Dinámicos en Ada
• Asignación a datos apuntados
e,f:enlace;
f:=new celda'(13,null);
e:=new celda;
e.all:=f.all;
f
e
-- asignación entre los datos apuntados,
-- no reserva espacio…
•
•
13
null
13
null
-- e.valor:= 13; equivaldría a e.all.valor:=13;
e
f
e
null
•
•
f
null
13
null
?
null

Punteros y Datos Dinámicos en Ada
• Comparación (entre tipos idénticos)
e=f
-- será cierto únicamente si ambos apuntan al
-- mismo dato en memoria, o si ambos son null
f
e
null
null
e.all=f.all
-- será cierto únicamente si los datos a los que
-- apuntan tienen los mismos contenidos
f
e
•
•
•
•
13
null
13
null
13
null
e
f
f •
13
e •
13
52
null

Punteros y Datos Dinámicos en Ada
• Liberación de memoria de datos inaccesibles:
– Debe hacerlo el programador
with unchecked_deallocation;
procedure disponer is new
unchecked_deallocation(celda,enlace);
e:enlace;
...
disponer(e);
e •
-- libera la memoria a la que apuntaba e,
-- y deja a e con valor null
CUIDADO!!!
e
f
•
•
13
null
e
f
null
•
e
null
13
null

Representación Dinámica de Pila

Representación Dinámica de Pila
• Representación por encadenamiento mediante
punteros de los elementos de la pila
– la pila será un puntero que apunta al elemento que
está en la cima de la pila, y cada elemento apuntará
al anterior
– Ejemplos:
• Pila con tres elementos
• Pila vacía: p

Representación Dinámica de Pila
• ESTATICA:
• DINAMICA:

espec gpilas
usa booleanos, naturales
parametro formal
genero elemto
fpf
genero pila
operaciones
VACIA: -> pila
APILAR: pila elemto -> pila
DESAPILAR: pila -> pila
parcial CIMA: pila -> elemto
VACIA?: pila -> bool
ALTURA: pila -> nat
dominios de definicion p:pila; e:elemto
CIMA(APILAR(p,e))
ecuaciones p:pila, e:elemto
DESAPILAR(VACIA) = VACIA
DESAPILAR(APILAR(p,e)) = p
CIMA(APILAR(p,e)) = e
VACIA?(VACIA) = VERDAD
VACIA?(APILAR(p,e)) = FALSO
ALTURA(VACIA) = 0
ALTURA(APILAR(p,e)) = SUC(ALTURA(p))
fespec
ALTURA Diferencia con los apuntes!!!!
Estructura de datos diferente,
operación de coste (1)

Implementación Dinámica de Pila
• Características de la implementación:
– En esta implementación, todas las operaciones de la
especificación algebraica (VACIA, APILAR, DESAPILAR,
CIMA, VACIA?, ALTURA) tienen tiempo de ejecución de
(1)
– La pila puede crecer hasta ocupar el máximo de la
memoria (dinámica) disponible
– Coste de memoria:
• Coste “extra” para almacenar los punteros (encadenar datos
apilados)
• Coste ajustado al necesario para almacenar los datos
actuales de la pila
– Aconsejable redefinir las operaciones de “:=“ y “=“
– Se necesita una operación para liberar la memoria
ocupada por una pila

generic
type elemto is private;
package gpilas is
type pila is limited private;
procedure crearVacia(p:out pila);
--post: p=VACIA
procedure apilar(p:in out pila; e:in elemto);
--pre: p=p0
--post: p=APILAR(p,e)
procedure desapilar(p:in out pila);
--pre: (p=p0)
--post: p=DESAPILAR(p0)
….

function cima(p:in pila) return elemto;
--pre: (p=p0) and (p0/=VACIA)
--post: cima(p0)=CIMA(p0)
function esVacia(p:in pila) return boolean;
--post: esVacia(p)=VACIA?(p)
function altura(p:in pila) return natural;
--post: altura(p)=ALTURA(p)
procedure asignar(pout:out pila; pin:in pila);
--post: pout=pin, duplicando la representación en memoria
function "="(p1,p2:in pila) return boolean;
--post: p1=p2 si y solo si son iguales sus representaciones en
-- memoria
procedure liberar(p:in out pila);
--post: p=VACIA, y además libera la memoria utilizada
-- previamente por p
….

…
private
type unDato;
type ptDato is access unDato;
type unDato is record
dato:elemto;
sig:ptDato;
end record;
type pila is record
cim:ptDato;
alt:natural;
end record;
end gpilas;
ALTURA Diferencia con los apuntes!!!!
Estructura de datos diferente,
operación de coste (1)
________ ANTES:________
tipos
pila=unDato;
unDato= registro
dato:elemento;
sig: pila;
freg;
________AHORA:________
tipos
ptDato=unDato;
unDato= registro
dato:elemto;
sig: ptDato;
freg;
pila= registro
cim:ptDato;
alt: natural;
freg;

with unchecked_deallocation;
package body gpilas is
procedure disponer is new
unchecked_deallocation(unDato,ptDato);
procedure crearVacia(p:out pila) is
begin
p.cim:=null;
p.alt:=0;
end crearVacia;
….

procedure apilar(p:in out pila; e:in elemto) is
…?

procedure apilar(p:in out pila; e:in elemto) is
aux:ptDato;
begin
aux:=p.cim;
p.cim:=new unDato;
p.cim.dato:=e;
p.cim.sig:=aux;
p.alt:=p.alt+1;
end apilar;

procedure desapilar(p:in out pila) is
….?

procedure desapilar(p:in out pila) is
aux:ptDato;
begin
if p.cim/=null then
aux:=p.cim;
p.cim:=p.cim.sig;
disponer(aux);
p.alt:=p.alt-1;
end if;
end desapilar;

function altura(p:in pila) return natural is
begin
….?
end altura;
function esVacia(p:in pila) return boolean is
begin
….?
end esVacia;
function cima(p:in pila) return elemto is
begin
….?
end cima;

function altura(p:in pila) return natural is
begin
return p.alt;
end altura;
function esVacia(p:in pila) return boolean is
begin
return p.cim=null;
end esVacia;
function cima(p:in pila) return elemto is
begin
return p.cim.dato;
end cima;

procedure liberar(p:in out pila) is
…?

procedure liberar(p:in out pila) is
aux:ptDato;
begin
aux:=p.cim;
while aux/=null loop
p.cim:=p.cim.sig;
disponer(aux);
aux:=p.cim;
end loop;
p.alt:=0;
end liberar;

function "="(p1,p2:in pila) return boolean is
…?

function "="(p1,p2:in pila) return boolean is
pt1,pt2:ptDato;
iguales:boolean:=true;
begin
if p1.alt/=p2.alt then
return false;
else
pt1:=p1.cim;
pt2:=p2.cim;
while pt1/=null and iguales loop
iguales:=pt1.dato=pt2.dato;
pt1:=pt1.sig;
pt2:=pt2.sig;
end loop;
return iguales;
end if;
end "=";

procedure asignar(pout:out pila; pin:in pila) is
…?

procedure asignar(pout:out pila; pin:in pila) is
ptout,ptin: ptDato;
begin
if esVacia(pin) then
crearVacia(pout);
else
…..
end if;
end asignar;

… else
ptin:=pin.cim;
pout.cim:=new unDato;
pout.cim.dato:=ptin.dato;
ptout:=pout.cim;
ptin:=ptin.sig;
while ptin/=null loop
ptout.sig:=new unDato;
ptout:=ptout.sig;
ptout.dato:=ptin.dato;
ptin:=ptin.sig;
end loop;
ptout.sig:=null;
pout.alt:=pin.alt;

procedure asignar(pout:out pila; pin:in pila) is
ptout,ptin:ptDato;
begin
if esVacia(pin) then
crearVacia(pout);
else
ptin:=pin.cim;
pout.cim:=new unDato;
pout.cim.dato:=ptin.dato;
ptout:=pout.cim;
ptin:=ptin.sig;
while ptin/=null loop
ptout.sig:=new unDato;
ptout:=ptout.sig;
ptout.dato:=ptin.dato;
ptin:=ptin.sig;
end loop;
ptout.sig:=null;
pout.alt:=pin.alt;
end if;
end asignar;