Programacin Dinmica

Algoritmos y Estructuras de Datos

Company

LOGO

Agenda

1.
1.Punteros
Punteros
2.
2. Estructuras
Estructurasautoreferenciadas
autoreferenciadas
3.
3.Asignacin
Asignacindinmica
dinmicade
dememoria
memoria
4.
4.Listas
Listasenlazadas,
enlazadas, Pilas
PilasyyColas
Colas

Punteros
Su valor es una
direccin de
memoria.

Las variables
normales contienen
un valor especfico.

Los punteros
almacenan la
direccin de una
variable que tiene
un valor especfico.

Sirven para simular

parmetros por
referencia.

Punteros

Declarar punteros
Sintaxis

Definir *mi_puntero como Entero;

Definicin

Declara un puntero hacia un

Entero.
Se pueden definir punteros
hacia cualquier tipo de dato.

Punteros y operadores
Operador
de
direccin
(&)

Devuelve la direccin de memoria del operando

Ejemplo

Declarar un_numero como Entero;

Declarar *un_puntero como Entero;
un_numero <- 5;
un_puntero <- &un_numero;
//un_puntero obtiene la direccin de un_numero

Punteros y operadores

Punteros y operadores
Operador de
indireccin(*)

Nos permite obtener el valor almacenado en la

direccin que tiene asignada.
*un_puntero nos devolvera un_numero, dado
que un_puntero apunta hacia un_numero.

Ejemplo

Para asignar:
*un_puntero <- 7;
//Ahora el valor de un_numero es 7

El ejemplo

Punteros y Estructuras
Operador
punto (.)

Definir una_carta como carta;

Escribir una_carta.signo;

Operador
flecha (<-)

Definir *puntero_carta como carta;

puntero_carta <- &una_carta;
Escribir puntero_carta->signo;

Equivalente
a:

Escribir (*puntero_carta).signo;

Estructuras de Datos
Dinmicas

Crecen o se contraen durante

la ejecucin
Listas
enlazadas
Inserciones y
eliminaciones
sin
restricciones.

Pilas

Colas

Inserciones y Inserciones
eliminaciones
en la parte
slo en la
posterior y
parte superior.
eliminaciones
en la parte
superior.

rboles
binarios
Bsqueda y
ordenamiento
de alta
velocidad y
eliminacin de
duplicados
eficiente

Estructura auto-referenciada

Contienen un
puntero a otra
estructura

Esta otra
estructura es del
mismo tipo.

Lo que permite
formas
estructuras de
datos.

Pueden
enlazarse
mutuamente.

Estas
estructuras
terminan con un
puntero NULO.

Estructura auto-referenciada

Estructura auto-referenciada
Sintaxis

Estructura nodo
Definir dato como Entero;
Definir *puntero_siguiente como nodo;
FinEstructura

Enlace

Es el vnculo entre un nodo y otro.

puntero_siguiente apunta hacia un dato del tipo

nodo.

Asignacin dinmica de
memoria
Definicin

Obtiene y libera memoria durante la ejecucin del

programa.

Funcin
reservar()

Reserva memoria para un puntero.

Definir *puntero_nodo como nodo;
reservar(puntero_nodo);

Funcin
liberar()

Libera la memoria reservada por la funcin

reservar.
liberar(puntero_nodo);

Listas enlazadas
Coleccin lineal de estructuras autoreferenciadas, llamadas nodos, conectadas
por enlaces mediante punteros.

Se acceden
Los
El ltimo
mediante
siguientes
elemento
un puntero
nodos se
tiene como
al primer
acceden a
enlace un
elemento
travs de
puntero
de la lista. los enlaces.
NULO.

Listas enlazadas

A diferencia de un
vector, soporta un
nmero indeterminado
de elementos.

A diferencia de un
vector, es fcil
mantenerla ordenada.

Nosotros trabajaremos
con LISTAS
ENLAZADAS SIMPLES

Existen varios tipos:

Simples, dobles,
circulares, etc.

Comienzan con un
puntero al primer nodo,
terminan en puntero
nulo y se recorren en
una direccin

Un problema
Disee un algoritmo que permita
manipular una lista de caracteres.

Debe permitir ingresar caracteres en la lista

en orden alfabtico.
Debe permitir eliminar cualquier carcter de la
lista.

Plan de accin
El usuario ingresa una opcin

En caso la opcin sea 1, se ejecuta el procedimiento

de insercin
En caso la opcin sea 2, se ejecuta el procedimiento
de eliminacin
Slo si la lista no est vaca

En caso la opcin sea 3, se termina la ejecucin del

programa

Estructura jerrquica

Mdulo
Principal
Insertar
carcter en
orden

Eliminar
carcter

Verificar que
lista est
vaca

Mostrar
contenido de
la lista

Definir Estructuras
Nodo en
Lista
Enlazada

Estructura nodo_lista

Definir caracter como Caracter;

Definir *puntero_siguiente

FinEstructura

como nodo_lista;

Mdulo Principal
Proceso principal
Definir *puntero_inicio como nodo_lista;
//Variables para opcin y caracteres ingresados
Leer opcion;
Mientras opcion <> 3 Hacer
Segun opcion Hacer
1:
Leer caracter_ingresado;
insertar(puntero_inicio, caracter_ingresado);
2:
es_una_lista_vacia <- esta_vacia(puntero_inicio);
Si ~es_una_lista_vacia Entonces
Leer caracter_ingresado;
caracter_eliminado <- suprimir(puntero_inicio, caracter_ingresado);
FinSi
FinSegun
Leer opcion;
FinMientras
FinProceso

Insertar elemento

Insertar elemento
Reservar memoria para el nuevo nodo

Ubicar entre que nodos hay que colocar el nuevo

elemento recin creado
En caso haya colocarlo en primera posicin, hay
que cambiar el valor del puntero al primer nodo.
En caso est al medio, la insercin se realiza
modificando las direcciones de los punteros.

Insertar elemento
SubProceso insertar (puntero_inicio por Referencia, caracter por Valor)
Definir *puntero_nuevo como nodo_lista;
Definir *puntero_previo como nodo_lista;
Definir *puntero_actual como nodo_lista;
reservar(puntero_nuevo);
puntero_nuevo->caracter <- caracter;
puntero_nuevo->puntero_siguiente <- NULO;
puntero_previo <- NULO;
puntero_actual <- puntero_inicio;
Mientras (puntero_actual <> NULO & caracter > puntero_actual->caracter) Hacer
puntero_previo <- puntero_actual;
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Si puntero_previo = NULO Entonces
puntero_nuevo->puntero_siguiente <- puntero_inicio;
puntero_inicio <- puntero_nuevo;
Sino
puntero_previo->puntero_siguiente <- puntero_nuevo;
puntero_nuevo->puntero_siguiente <- puntero_actual;
FinSi
FinSubProceso

Eliminar elemento

Eliminar elemento
La eliminacin implica remover los enlaces al nodo
a eliminar
Al eliminar, necesitamos liberar la memoria
reservada para el nodo eliminado.
Si el carcter a eliminar est en la primera
posicin, es necesario cambiar el puntero al primer
nodo.
Debemos informar al programa si el nodo a
eliminar fue encontrado en la lista.

Eliminar elemento
Funcion caracter_eliminado <- suprimir (puntero_inicio por Referencia, caracter por Valor)
Definir *puntero_previo, *puntero_actual,

*auxiliar

como nodo_lista;

Si caracter = puntero_inicio->caracter Entonces

auxiliar <- puntero_inicio;
puntero_inicio <- puntero_inicio<-puntero_siguiente;
liberar(auxiliar);
caracter_eliminado <- caracter;
Sino
puntero_previo <- puntero_inicio;
puntero_actual <- puntero_inicio->siguiente;
Mientras puntero_actual <> NULO & puntero_actual->caracter <> caracter Hacer
puntero_previo <- puntero_actual;
puntero_actual <- puntero_actual->siguiente;
FinMientras
Si puntero_actual <> NULO Entonces
auxiliar <- puntero_actual;
puntero_previo->puntero_siguiente <- puntero_actual->puntero_siguiente;
liberar(auxiliar);
caracter_eliminado <- caracter;
FinSi
FinSi
FinFuncion

Mostrar contenido
SubProceso mostrar_lista(puntero_actual)
Si puntero_actual = NULO Entonces
Escribir "La lista est vaca";
Sino
Mientras puntero_actual <> NULO Hacer
Escribir puntero_actual->caracter, "-->", Sin Saltar;
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Escribir "NULO";
FinSi
FinSubProceso

Est vaca?
Funcion resultado <- esta_vacia(puntero_inicio)

Definir resultado como Logico;

resultado <- puntero_inicio = NULO;

FinFuncion

Pilas

Los nodos slo

se agregan en el
extremo
superior.

Los nodos slo

se eliminan en
el extremo
superior.

Como en los
platos en un
Buffet

Modo de
acceso: LIFO

La base de la
pila es un
enlace a NULO.

En conclusin,
es una lista
enlazada con
restricciones

Pilas

Apilar

Desapilar

Agrega un nuevo Remueve un

nodo en la parte
nodo de la parte
superior de la pila
superior de la pila
Retorna el valor
retirado

Una pila de enteros

Mdulo
Principal
Apilar

Desapilar

Verificar si
est vaca

Mostrar en
pantalla

Pilas

Definir Estructuras

Nodo
en
Pila

Estructura nodo_pila

Definir dato como Entero;

Definir *puntero_siguiente

FinEstructura

como nodo_pila;

Mdulo Principal
Proceso principal
Definir *puntero_pila como nodo_pila;
//Declarar variables adicionales
puntero_pila <- NULO;
Leer opcion;
Mientras opcion <> 3 Hacer
Segun opcion Hacer
1:
Leer valor_ingresado;
apilar(puntero_pila, valor_ingresado);
mostrar_pila(puntero_pila);
2:
Si ~esta_vacia(puntero_pila) Entonces
Escribir desapilar(puntero_pila);
FinSi
mostrar_pila(puntero_pila);
FinSegun
Leer opcion;
FinMientras
FinProceso

Apilar elemento

Apilar elemento
SubProceso apilar (puntero_pila Por Referencia, dato
por Valor)
Definir *puntero_nuevo como nodo_pila;
reservar(puntero_nuevo);
puntero_nuevo->dato <- dato;
puntero_nuevo->puntero_siguiente <- puntero_pila;
puntero_pila <- puntero_nuevo;
FinSubProceso

Des-apilar elemento

Des-apilar elemento
SubProceso desapilar(puntero_pila por Referencia)
Definir *auxiliar como nodo_pila;
Definir valor_desapilado como Entero;
auxiliar <- puntero_pila;
valor_desapilado <- puntero_pila->dato;
puntero_pila <- puntero_pila->puntero_siguiente;
liberar(auxiliar);
FinSubProceso

Mostrar Pila
SubProceso mostrar_pila(puntero_actual)
Si puntero_actual = NULO Entonces
Escribir "La pila est vaca \n";
Sino
Escribir "Contenido de la pila: ";
Mientras puntero_actual <> NULO Hacer
Escribir puntero_actual->dato, "-->";
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Escribir "NULO";
FinSi
FinSubProceso

Est vaca?
Funcion resultado <- esta_vacia(puntero_inicio)

Definir resultado como Logico;

resultado <- puntero_inicio = NULO;

FinFuncion

Colas

Imaginen un
cajero de
supermercado.

Modo de
acceso: FIFO.

Los nodos slo

se eliminan
slo del inicio.

Los nodos se
ingresan slo al
final.

La base de la
pila es un
enlace a NULO.

tiles en, por

ejemplo, colas
de impresin.

Colas

Encolar

Desencolar

Para ingresar Para remover

elementos
elementos

Una cola de caracteres

Mdulo
Principal
Encolar

Desencolar

Verificar si
est vaca

Mostrar en
pantalla

Colas

Definir Estructuras

Nodo
en
Cola

Estructura nodo_cola

Definir dato como Caracter;

Definir *puntero_siguiente como nodo_cola;

FinEstructura

Mdulo Principal
Proceso principal
Definir *puntero_inico como nodo_cola;
Definir *puntero_fin como nodo_cola;
//Declarar variables adicionales
puntero_inicio <- NULO;
puntero_fin <- NULO;
Leer opcion;
Mientras opcion <> 3 Hacer
Segun opcion Hacer
1:
Leer valor_ingresado;
encolar(puntero_inicio, puntero_fin, valor_ingresado);
mostrar_contenido(puntero_inicio);
2:
Si ~esta_vacia(puntero_inicio) Entonces
Escribir desencolar(puntero_inicio, puntero_fin);
FinSi
mostrar_contenido(puntero_inicio);
FinSegun
Leer opcion;
FinMientras
FinProceso

Encolar

Encolar
Reservamos memoria para el nuevo nodo

Si la cola est vaca, el puntero de inicio debe

apuntar hacia el nuevo nodo
Si la cola no est vaca, el ltimo nodo debe
apuntar hacia el nuevo nodo
Finalmente, el puntero de fin debe de apuntar
ahora hacia el nuevo nodo

Encolar
SubProceso encolar(puntero_inicio Por Referencia, puntero_fin Por Referencia, dato Por
Valor)
Definir *puntero_nuevo como nodo_cola;
reservar(puntero_nuevo);
puntero_nuevo->dato <- dato;
puntero_nuevo->puntero_siguiente <- NULO;
Si esta_vacia(puntero_inicio) Entonces
puntero_inicio <- puntero_nuevo;
Sino
puntero_fin->puntero_siguiente <- puntero_nuevo;
FinSi
puntero_fin <- puntero_nuevo;
FinSubProceso

Desencolar

Desencolar
Extraer el dato del primer nodo de la cola.

El puntero de inicio ahora apunta hacia el

segundo nodo de la cola.
Si la cola queda vaca, debemos modificar el
valor del puntero fin.
Liberamos la memoria del nodo removido
mediante la variable auxiliar.

Mostrar contenido
SubProceso mostrar_contenido(puntero_actual)
Si puntero_actual = NULO Entonces
Escribir "La cola est vaca";
Sino
Escribir "La cola contiene: ";
Mientras puntero_actual <> NULO Hacer
Escribir puntero_actual->dato, " --> ";
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Escribir " NULO";
FinSi
FinSubProceso

Est vaca?
Funcion resultado <- esta_vacia(puntero_inicio)

Definir resultado como Logico;

resultado <- puntero_inicio = NULO;

FinFuncion

Un Problema
Para un grupo de n productos se desea
almacenar en una LISTA los siguientes datos:
cdigo, descripcin, cantidad solicitada, cdigo
de cliente.
Luego en base a la LISTA, se pide presentar un
listado que muestre el cdigo del producto,
descripcin y cantidad total solicitada, ordenado
en forma creciente respecto al cdigo.
Nota: En la LISTA algunos productos se
pueden repetir

Un problema
Productos de Entrada:
Cdigo

Descripcin

Cantidad

Cdigo de Cliente

201

Lpiz

500

820

105

Borrador

100

515

201

Lpiz

100

806

Reporte de Salida:
Cdigo

Descripcin

Cantidad

105

Borrador

100

201

Lpiz

600

Plan de accin
Definir estructuras de datos

Agregar las ventas a la lista enlazada

En orden de cdigo de producto

Calcular las cantidades acumuladas por

cada producto y mostrar el reporte.

Definir Estructuras

Venta

Estructura venta
Definir codigo_producto como Entero;
Dimension descripcion[50];
Definir descripcion como Caracter;
Definir cantidad como Entero;
Definir codigo_cliente como Entero;
FinEstructura

Nodo
en la
Lista

Estructura nodo_lista
Definir dato como venta;
Definir *puntero_siguiente como nodo_lista;
FinEstructura

Una cola de caracteres

Mdulo
Principal
Registrar
venta

Mostrar
reporte

Mdulo principal
Proceso principal
Definir numero_ventas como Entero;
Definir contador_ventas como Entero;
Definir *puntero_inicio como nodo_lista;
Definir informacion_ingresada como venta;
puntero_inicio <- NULO;
Leer numero_ventas;
Para contador_ventas <- 0 Hasta numero_ventas - 1 Hacer
Leer informacion_ingresada.codigo_producto;
Leer informacion_ingresada.descripcion;
Leer informacion_ingresada.cantidad;
Leer informacion_ingresada.codigo_cliente;
registrar_venta(puntero_inicio, informacion_ingresada);
FinPara
mostrar_reporte(puntero_inicio);
FinProceso

Registrar venta
SubProceso registrar_venta(puntero_inicio Por Referencia,
informacion_ingresada por Valor)
Definir *puntero_previo como nodo_lista;
Definir *puntero_actual como nodo_lista;
Definir *puntero_nuevo como nodo_lista;
reservar(puntero_nuevo);
puntero_nuevo->dato <- informacion_ingresada;
puntero_nuevo->puntero_siguiente <- NULO;
puntero_previo <- NULO;
puntero_actual <- puntero_inicio;
Mientras puntero_actual <> NULO &
informacion_ingresada.codigo_producto > (puntero_actual->dato).codigo_producto Hacer
puntero_previo <- puntero_actual;
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Si puntero_previo = NULO Entonces
puntero_nuevo->puntero_siguiente <- puntero_inicio;
puntero_inicio <- puntero_nuevo;
Sino
puntero_previo->puntero_siguiente <- puntero_nuevo;
puntero_nuevo->puntero_siguiente <- puntero_actual;
FinSi
FinSubProceso

Mostrar reporte
SubProceso mostrar_reporte(puntero_inicio)
Definir informacion_venta como venta;
Definir informacion_previa como venta;
Si puntero_actual <> NULO Hacer
informacion_previa <- puntero_actual->dato;
puntero_actual <- puntero_actual->puntero_siguiente;
Mientras puntero_actual <> NULO Hacer
informacion_venta <- puntero_actual->dato;
Si informacion_venta.codigo_producto = informacion_previa.codigo_producto Hacer
informacion_previa.cantidad <- informacion_previa.cantidad +
informacion_venta.cantidad;
Sino
Escribir informacion_previa.codigo_producto,
informacion_previa.descripcion, informacion_previa.cantidad;
informacion_previa <- informacion_venta;
FinSi
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Escribir informacion_previa.codigo_producto, informacion_previa.descripcion,
informacion_previa.cantidad;
FinSi
FinSubProceso