12_Programacion_Dinamica
-
Upload
alexis-sovero-camacuari -
Category
Documents
-
view
221 -
download
0
description
Transcript of 12_Programacion_Dinamica
Company
LOGO
Programación Dinámica
Algoritmos y Estructuras de Datos
Agenda
1. Punteros
2. Estructuras autoreferenciadas
3. Asignación dinámica de memoria
4. Listas enlazadas
Punteros
Su valor es una dirección de
memoria.
Las variables normales contienen un valor específico.
Los punteros almacenan la
dirección de una variable que tiene
un valor específico.
Sirven para simular parámetros por
referencia.
Punteros
Declarar punteros
Sintaxis Definir *mi_puntero como Entero;
Definición Declara un puntero hacia un Entero.
Se pueden definir punteros hacia cualquier tipo de dato.
Punteros y operadores
Operador de dirección (&)
Devuelve la dirección 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 dirección de un_numero
Punteros y operadores
Punteros y operadores
Operador de indirección(*)
Nos permite obtener el valor almacenado en la dirección que tiene asignada.
*un_puntero nos devolvería 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;
Parámetros por referencia
Estructuras de Datos Dinámicas: Crecen o se contraen durante la ejecución
Listas enlazadas
• Inserciones y eliminaciones sin restricciones.
Pilas
• Inserciones y eliminaciones sólo en la parte superior.
Colas
• Inserciones en la parte posterior y eliminaciones en la parte superior.
Árboles binarios
• Búsqueda y ordenamiento de alta velocidad y eliminación de duplicados eficiente
Estructura auto-referenciada
Contienen un puntero a otra
estructura
Esta otra estructura es del
mismo tipo.
Pueden enlazarse
mutuamente.
Lo que permite formas
estructuras de datos.
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 vínculo entre un nodo y otro.
puntero_siguiente apunta hacia un dato del tipo nodo.
Asignación dinámica de
memoria
Definición Obtiene y libera memoria durante la ejecución del programa.
Función reservar()
Reserva memoria para un puntero.
Definir *puntero_nodo como nodo;
reservar(puntero_nodo);
Función liberar()
Libera la memoria reservada por la función reservar.
liberar(puntero_nodo);
Listas enlazadas
Colección lineal de estructuras auto-referenciadas, llamadas nodos, conectadas
por enlaces mediante punteros.
Se acceden mediante
un puntero al primer elemento de la lista.
Los siguientes nodos se
acceden a través de
los enlaces.
El último elemento
tiene como enlace un puntero NULO.
Listas enlazadas
A diferencia de un vector, soporta un
número indeterminado de elementos.
A diferencia de un vector, es fácil
mantenerla ordenada.
Existen varios tipos: Simples, dobles, circulares, etc.
Nosotros trabajaremos con LISTAS
ENLAZADAS SIMPLES
Comienzan con un puntero al primer nodo,
terminan en puntero nulo y se recorren en
una dirección
Un problema
Diseñe un algoritmo que permita
manipular una lista de caracteres.
Debe permitir ingresar caracteres en la lista
en orden alfabético.
Debe permitir eliminar cualquier carácter de la
lista.
Plan de acción
El usuario ingresa una opción
En caso la opción sea 1, se ejecuta el procedimiento de inserción
En caso la opción sea 2, se ejecuta el procedimiento de eliminación
• Sólo si la lista no está vacía
En caso la opción sea 3, se termina la ejecución del programa
Estructura jerárquica
Módulo Principal
Insertar carácter en
orden
Eliminar carácter
Verificar que lista esté
vacía
Mostrar contenido de
la lista
Definir Estructuras
Nodo en Lista Enlazada
Estructura nodo_lista
Definir caracter como
Caracter;
Definir *puntero_siguiente
como nodo_lista;
FinEstructura
Módulo Principal
Proceso principal
Definir *puntero_inicio como nodo_lista;
//Variables para opción 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
Reservar memoria para el nuevo nodo
Ubicar entre que nodos hay que colocar el nuevo elemento recién creado
En caso haya colocarlo en primera posición, hay que cambiar el valor del puntero al primer nodo.
En caso esté al medio, la inserción se realiza modificando las direcciones de los punteros.
Insertar elemento
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
La eliminación implica remover los enlaces al nodo a eliminar
Al eliminar, necesitamos liberar la memoria reservada para el nodo eliminado.
Si el carácter a eliminar está en la primera posición, es necesario cambiar el puntero al primer nodo.
Debemos informar al programa si el nodo a eliminar fue encontrado en la lista.
Eliminar elemento
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á vacía";
Sino
Mientras puntero_actual <> NULO Hacer
Escribir puntero_actual->caracter, "-->", Sin Saltar;
puntero_actual <- puntero_actual->puntero_siguiente;
FinMientras
Escribir "NULO";
FinSi
FinSubProceso