CONCEPTOS BÁSICOS

1. Un puntero es una variable que contiene la

dirección de memoria donde se encuentra
almacenado un dato.

2. Una variable referenciada o dato apuntado

es el dato cuya posición en memoria está
contenida en un determinado puntero (variable
dinámica)
DEFINICIÓN Y DECLARACIÓN DE PUNTEROS

Para poder usar una variable puntero es necesario:

– Definir el tipo de dato (o estructura) al que se apunta.

(Esta declaración se realiza dentro de la sección
TYPE).

– Declarar las variables punteros que sean necesarias

(esta declaración se realiza dentro de la sección VAR).
CREACIÓN Y DESTRUCCIÓN DE VARIABLES
DINÁMICAS

 Las variables dinámicas son por definición

aquellas que se crean cuando se necesitan y se
destruyen cuando ya han cumplido con su
cometido.

 En pascal la creación y destrucción de variables

dinámicas se realiza mediante los siguientes
procedimientos:

– New (puntero)

– Dispose (puntero)
 CREACIÓN DE UNA VARIABLE DINÁMICA

•New(puntero)

–Reserva la memoria necesaria para un dato del

tipo apropiado.

–Coloca la dirección de memoria de esta nueva

variable en el puntero.

Gráficamente esto se representa:

 VAR PUNTERO:^INTEGER;

En el código anterior hemos declarado un puntero llamado

PUNTERO que está apuntando a un tipo de dato entero, es
decir que en él podemos almacenar valores de direcciones de
memoria dónde se encuentren enteros.
Si bien el puntero está listo para guardar una dirección aún no lo hemos
inicializado con ninguna dirección, el siguiente paso es reservar la memoria de un
entero y guardar la dirección de ese lugar en el puntero.

NODOS

Un nodo es una pequeña estructura especialmente creada por el programador,

para poder crear otras estructuras tal cómo Listas o Colas en memoria dinámica.

Los nodos guardan en una parte de la estructura la información que justamente

requiere guardar nuestra aplicación o programa, en la otra parte tenemos un
puntero que guarda la dirección de otro nodo.

Ejemplo de definición:

TYPE
TipoLista =^ TipoNodo;
TipoNodo = Record
Info:TipoInfo;
Siguiente:TipoLista
END;
Listas

Llamamos Lista a una variable de tipo puntero que apunta a un nodo.

Ese nodo puede apuntar a otro nodo y este último a un próximo, por lo tanto
podemos hablar de ciertas operaciones posibles en una Lista, como por ejemplo:
insertar nodo al final, insertar al principio, insertar en el medio, buscar nodo,
sacar del final, sacar del principio, etc.

LISTAS (LISTS)
Son TAD en las que los elementos están organizados siguiendo un orden secuencial. Cada
elemento tiene un anterior y un siguiente en la lista..
Inicio Final (apunta a NULL)
------ ------ ------ --------
| 23 |--->| 12 |--->| 11 |--->| 99 |\|
------ ------ ------ --------

Crear Lista

Ejemplo de procedimiento que crea una Lista:

PROCEDURE CrearLista (VAR Lista:TipoLista);

BEGIN
Lista:= NIL

END;

El código anterior recibe un puntero y lo inicializa en NIL.

Insertar primer Nodo

Ejemplo de procedimiento que inserta el primer nodo de una Lista:

PROCEDURE InsertaPrimero (VAR

Lista:TipoLista; Valor:TipoInfo);
VAR
Ptr:TipoLista;

BEGIN
New(Ptr);
Ptr^.Info := Valor;
Ptr^.Siguiente := NIL;
Lista := Ptr;
END;

El código anterior recibe la Lista en la cual vamos a insertar un primer nodo, y el

valor de la información que contendrá este nodo. Dentro del procedimiento
tenemos una variable local a él, que la reservamos con la instrucción New(Ptr),
luego le asignamos el valor recibido como parámetro e indicamos que este primer
nodo apunta a NIL, por último debemos apuntar la lista a este nodo recién
creado.
Insertar adelante

Ejemplo de procedimiento inserta un nodo para que sea el primero de la lista:

PROCEDURE InsertaAdelante (VAR

Lista:TipoLista; Valor:TipoInfo);
VAR
Ptr:TipoLista;
BEGIN
New(Ptr);
Ptr^.Info := Valor;
Ptr^.Siguiente := Lista;
Lista := Ptr;
END;

Nuestro objetivo es insertar un nodo que sea el primero de la lista, para esto
recibimos como parámetro la Lista en la cual queremos insertar el nodo y el valor
que guardará como información el nodo. Creamos el nodo, guardamos la
información recibida, y le decimos al nuevo nodo que apunte a dónde está
apuntando actualmente la Lista, resguardada esta dirección podemos decirle a
Lista que apunte al nuevo nodo, de esta manera el nodo queda insertado al
principio de todo.
Pilas

La Pila es una Lista a la que sólo se le permite insetar y quitar nodos por el
principio.

Crear Pila

PROCEDURE CrearPila ( VAR Pila : TipoPila );

BEGIN
Pila := NIL;
END

Nuevamente recibimos por referencia el nombre de la pila y la inicializamos en

nil

Insertar PUSH
PROCEDURE Insertar ( VAR Pila:TipoPila ; Valor:TipoInfo);
VAR
Ptr:TipoPila;
BEGIN
New(Ptr);
Ptr^.Info := Valor;
Ptr^.Siguiente := Pila;
Pila := Ptr;
END;
Sacar POP

Nuevamente a este procedimiento se lo suele llamar Pop en muchos programas:

PROCEDURE Pop ( VAR Pila:TipoPila ; VAR Valor:TipoInfo);

VAR
Ptr:TipoPila;
BEGIN
Ptr := Pila;
Pila := Ptr^.Siguiente;
DISPOSE(Ptr);
END;
COLAS (QUEUES)
Son un TAD formados por una sencuencia de elementos, caracterizados porque sus
elementos se insertan por un extremo y se extraen por el extremo opuesto (el primer
elemento en insertarse es el primero en extraerse, o FIFO).

-------------------------------
<- | 23 | 21 | 31 | 12 | 99 | 02 | <-
-------------------------------
Cabeza COLA

(lugar de extraccion) (Lugar de insercion)