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