INDICEINTRODUCCIÓN...........................................................................................................................................2
METODOS.....................................................................................................................................................3
RESULTADOS.............................................................................................................................................15
CONCLUSIONES........................................................................................................................................18
BIBLIOGRAFÍA............................................................................................................................................19
1
INTRODUCCIÓN
Una de las aplicaciones más interesantes y potentes de la memoria dinámica y
los punteros son las estructuras dinámicas de datos. Las estructuras básicas
disponibles en C y C++ tienen una importante limitación: no pueden cambiar
de tamaño durante la ejecución. Los arreglos están compuestos por un
determinado número de elementos, número que se decide en la fase de diseño,
antes de que el programa ejecutable sea creado.
En muchas ocasiones se necesitan estructuras que puedan cambiar el tamaño
durante la ejecución del programa. Por supuesto, podemos hacer arrays
dinamicos, pero una vez creados, su tamaño también será fijo, y para hacer
que crezcan o disminuyan de tamaño, deberemos reconstruirlas desde el
principio.
Las estructuras dinámicas nos permiten crear estructuras de datos que se
adapten a las necesidades reales a las que suelen enfrentarse nuestros
programas. Pero no solo eso como veremos, también nos permitirán crear
estructuras de datos muy flexibles, ya sea en cuanto a orden, estructura
interna o las relaciones entre los elementos que las componen.
Las estructuras de datos están compuestas de otras pequeñas estructuras a las
que llamaremos nodos o elementos, que agrupan los datos con los que
trabajará nuestro programa y además uno o más punteros autoreferenciales, es
decir punteros a objetos del mismo tipo nodo.
2
METODOS
ESPECIFICACION : JUGADA
VARIABLES:
tiempo : inicio
tiempo : fin
Real : tiempojugada
Entero : x
Entero : y
Entero : numerojugada
Logico : perdio
OPERACIONES
ingresarCoordenadas () : No retorna Valor
FijarTiempoJugada () : no retorna valor
ConseguirTiempoJugada () : retorna valor real
obtenerX () : retorna valor entero
obtenerY() : retorna valor entero
FijarInicioJugada() : No retorna valor
FijarFinJugada() : No retorna valor
ConseguirPerdio() : retorna valor Logico
3
FijarPerdio() : No retorna valor
FijarNumeroJugada(entero:n) : No retorna valor
ConseguirNumeroJugada() : retorna valor entero
SIGNIFICADO
Algoritmos importantes:
procedimiento ingresarCoordenadas
escribir(" ingresar x: ")
leer(x)
escribir ("ingresar y:” )
leer(y)
fin ingresarCoordenadas
procedimiento FijarTiempoJugada
tiempojugada fin - inicio
fin FijarTiempoJugada
ESPECIFICACION : POSICION
VARIABLES:
num : caracter
Se_muestra: Logico
OPERACIONES
Mostrar () : no retorna valor
4
fijarNumero () : no retorna valor
conseguirNumero () : retorna valor caracter
fijarSe_muestra () : no retorna valor
conseguirSe_muestra() : retorna valor logico
SIGNIFICADO
ESPECIFICACION : NODOPUNTAJE
VARIABLES:
Cadena : jugador
Real : tiempo
OPERACIONES
mostrarPuntaje () : no retorna valor
FijarJugador (cadena: x) : no retorna valor
FijarTiempo (Real: x) : no retorna valor
ConseguirTiempo () : retorna valor real
SIGNIFICADO
Algoritmos importantes:
procedimiento mostrarPuntaje
escribir("Nombre : ", jugador)
escribir ("Tiempo: ”, tiempo )
5
fin mostrarPuntaje
ESPECIFICACION : LISTA_PUNTAJE
USA: NODOPUNTAJE
VARIABLES:
NODOPUNTAJE : p
LISTA_PUNTAJE : sgte
OPERACIONES
insertar(LISTA_PUNTAJE: raiz, NODOPUNTAJE: np) : no retorna
valor
visualizar(LISTA_PUNTAJE: raiz) : no retorna
valor
VerificarNuevoRecord(LISTA_PUNTAJE: raiz, NODOPUNTAJE: np) : retorna
valor lógico
SIGNIFICADO
Algoritmos importantes:
procedimiento insertar(LISTA_PUNTAJE: raiz, NODOPUNTAJE: np)
LISTA_PUNTAJE: n LISTA_PUNTAJE: q n.pnp
6
Si raiz=NULL entonces Raizn sino qraiz mientras (q.sgte no es NULL) hacer qq.sgte fin mientras q.sgten fin si n.sgteNULLfin mostrarPuntaje
procedimiento visualizar(LISTA_PUNTAJE: raiz) LISTA_PUNTAJE q
Qraiz Mientras (q es diferente de NULL) hacer q.p.mostrarPuntaje() qq.sgte fin mientrasfin visualizar
funcion VerificarNuevoRecord(LISTA_PUNTAJE: raíz , NODOPUNTAJE: np): logico Logico: nuevoRecord
LISTA_PUNTAJE: qnuevoRecord false
qraiz Mientras (q es diferente de NULL) hacer Si q.p.ConseguirTiempo() > np.ConseguirTiempo() entonces nuevoRecord verdadero
Fin si qq.sgte Fin mientras devolver nuevoRecord fin VerificarNuevoRecord
ESPECIFICACION : TERRENO
7
USA: POSICION
USA: JUGADA
VARIABLES:
POSICION : pos
JUGADA : jugada
TERRENO : abaj
TERRENO : sgte
TERRENO : arriba
TERRENO : ante
Entero : nn
OPERACIONES
TERRENO : no retorna valor
dameSig (TERRENO: nodo, entero: nn) : retorna valor
TERRENO
nodo_dev (TERRENO: raiz, entero: a, entero: b) : retorna valor
TERRENO
Mostrar(TERRENO: raiz, entero: nn, entero: x, entero: y) : retorna valor
lógico
ResolverJuego(TERRENO: raiz,entero: nn) : no retorna valor
MinasCercanas(TERRENO: raiz, entero: nn) : no retorna valor
registrarMinas(TERRENO: raiz, entero: nn, arreglos de entero:
posicion_minas)
: no retorna valor
Algoritmos importantes:
8
funcion dameSig (TERRENO: nodo, entero: nn): TERRENO devolver nodo.sgtefin dameSig
funcion nodo_dev (TERRENO: raiz, entero: a, entero: b) : TERRENO TERRENO: q Entero: i,j qraiz i0 j0 mientras i<a hacer q-q.abaj ii+1 fin mientras mientras j<b hacer qq.sgte jj+1 fin mientras devolver q fin nodo_dev
funcion Mostrar(TERRENO: raiz, entero: nn, entero: x, entero: y): logico entero: i,j logico: primerafila, perdio primerafila falso perdio falso i0
mientras i<=nn hacer j0 mientras j<=nn hacer Si i=0 entonces Si (j==0) entonces
Imprimir(" ") sino
Imprimir(" x",j)Fin si
Si j=0 entonces Imprimir ("y",i)
Si i=y y j=x y nodo_dev(raiz,i-1,j-1).pos.conseguirSe_muestra() es falso entonces
9
nodo_dev(raiz,i-1,j-1).pos.Mostrar()nodo_dev(raiz,i-1,j-1).pos.fijarSe_muestra(verdadero)Si nodo_dev(raiz,i-1,j-1).pos.conseguirNumero()='M' entonces perdio verdaderoFin si
Si nodo_dev(raiz,i-1,j-1).pos.conseguirSe_muestra() entonces nodo_dev(raiz,i-1,j-1).pos.Mostrar()
sino Imprimir (" @") Fin si jj+1 Fin mientras Imprimir salto de linea ii+1 Fin mientras devolver perdio fin mostrar
procedimiento ResolverJuego(TERRENO: raiz,entero: nn) entero i,j i0 mientras i<=nn hacer imprimir salto de linea j0 mientras j<=nn hacer Si i=0 entonces Si j=0 entonces
Imprimir(" ") Sino
Imprimir(" x",j) Fin si
Si j=0 entonces Imprimir("y",i)
Si no nodo_dev(raiz,i-1,j-1).pos.Mostrar() Fin si jj+1 Fin mientras
10
imprimir salto de linea ii+1 Fin mientras Fin ResolverJuego
procedimiento MinasCercanas(TERRENO: raiz, entero: nn) entero i,j,numero_de_minas TERRENO: nodo caracter n
numero_de_minas0 nodoNULL i0 mientras i<nn hacer Imprimir salto de linea j0 mientras j<nn hacer nodo nodo_dev(raiz,i,j) numero_de_minas 0 Si nodo.pos.conseguirNumero() es diferente 'M' entonces Si j es diferente nn-1 entonces Si nodo.sgte.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Si i es diferente nn-1 entonces Si nodo. abaj.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Si i es diferente 0 entonces Si nodo. arriba.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Si j es diferente 0 entonces Si nodo.ante.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
11
Si i es diferente 0 y j es diferente nn-1 entonces Si nodo. arriba. sgte.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Si j es diferente 0 y i es diferente nn-1 entonces Si nodo.abaj.ante.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Si j es diferente nn-1 y i es diferente nn-1 entonces Si nodo.abaj. sgte.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Si j es diferente 0 y i es diferente 0 entonces Si nodo. arriba. ante.pos.conseguirNumero() = 'M') entonces numero_de_minas numero_de_minas+1 Fin si Fin si
Seleccion (numero_de_minas) caso 0 :
n '0' case 1 :
n '1' case 2 :
n '2' case 3 :
n '3' case 4 :
n '4' case 5 :
n '5 case 6 :
n '6' case 7 :
n '7' case 8 :
12
n '8' Fin seleccion Nodo.pos.fijarNumero(n) Fin si jj+1 Fin mientras ii+1 Fin mientrasFin MinasCercanas
procedimiento registrarMinas(TERRENO: raiz, entero: nn, arreglos de entero: posicion_minas) TERRENO: n, q, y, auxNULL Entero: i, j, indice_minas0, posicion 0 Logico insertaMinafalso
i0 mientras i<nn hacer j0 mientras j<nn hacer ejecutar contructor de n Si posicion_minas[indice_minas] = posición entonces n.pos.fijarNumero('M') n.pos.fijarSe_muestra(falso) indice_minas indice_minas+1 posición posición+1 sino n.pos.fijarNumero('0') n.pos.fijarSe_muestra(falso) posición posición+1 Fin si
Si raiz=NULL entonces Raízn sino Si i=0 entonces qraiz mientras (q.sgte no sea NULL) hacer
qq.sgteFin mientras
q.sgten q.sgte.ante q
sino
13
Si j es diferente de 0 entonces { Aux.sgten
Fin si Aux.sgte.ante aux Fin si nodo_dev(raiz,i-1,j).abajn nodo_dev(raiz,i-1,j).abaj.arriba nodo_dev(raiz,i-1,j) auxn Fin si Fin si
n.abajNULL n.sgteNULL
Si i = 0 entonces n.arribaNULL Fin si
Si j = 0 entonces n.ante NULL Fin si
jj+1; Fin mientras n.sgte nodo_dev(raiz,i,0) ii+1 Fin mientras Fin registrarMinas
14
RESULTADOS
El menú de inicio con las opciones correspondientes
Al escoger la opción 1, nos aparece el terreno del buscaminas, con el numero de jugada 1 en la parte superior. Es necesario ir ingresando las coordenadas x e y para empezar a jugar
15
Aca se escogió las coordenadas x=1,y=1 ; vemos que apareció el número 3 que indica que a su alrededor hay 3 minas cerca (todas las contiguas en realidad)
Aca un ejemplo de un jugador que gano la jugada 28
16
Si perdemos en el juego, al “pisar una mina”, nos sale ese mensaje y su tiempo. En el presente caso perdimos en la sexta jugada
CONCLUSIONES
Las listas enlazadas poseen muchas ventajas sobre los vectores. Los elementos se pueden insertar en una lista indefinidamente mientras que un vector tarde o temprano se llenará ó necesitará ser redimensionado, una costosa operación que incluso puede no ser posible si la memoria se encuentra fragmentada.
Las listas doblemente enlazadas requieren más espacio por nodo y sus operaciones básicas resultan más costosas pero ofrecen una mayor facilidad para manipular ya que permiten el acceso secuencial a lista en ambas direcciones.
17
BIBLIOGRAFÍA
Luis Joyanes Aguilar e Ignacio Zahonero Martínez. " Programación en C. Metodología, estructura de datos y objetos. ".McGraw Hill.
N. WIRTH, “Algoritmos y estructuras de datos”. Prentice Hall, 1987.
Bowman, Charles F.,Algoritmos Y Estructuras De Datos: Aproximacion En C, Universidad Iberoamericana 2000
Programacion y estructuras de datos avanzadas, editorial universitaria ramon areces 2011..
18