INDICE

INTRODUCCIN.............................................................................................................. 2
METODOS....................................................................................................................... 3
RESULTADOS................................................................................................................. 15
CONCLUSIONES............................................................................................................ 18
BIBLIOGRAFA............................................................................................................... 19

INTRODUCCIN
Una de las aplicaciones ms interesantes y potentes de la memoria dinmica y
los punteros son las estructuras dinmicas de datos. Las estructuras bsicas
disponibles en C y C++ tienen una importante limitacin: no pueden cambiar
de tamao durante la ejecucin. Los arreglos estn compuestos por un
determinado nmero de elementos, nmero que se decide en la fase de diseo,
antes de que el programa ejecutable sea creado.
En muchas ocasiones se necesitan estructuras que puedan cambiar el tamao
durante la ejecucin del programa. Por supuesto, podemos hacer arrays
dinamicos, pero una vez creados, su tamao tambin ser fijo, y para hacer
que crezcan o disminuyan de tamao, deberemos reconstruirlas desde el
principio.
Las estructuras dinmicas 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, tambin nos permitirn 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 estn compuestas de otras pequeas estructuras a las
que llamaremos nodos o elementos, que agrupan los datos con los que
trabajar nuestro programa y adems uno o ms punteros autoreferenciales, es
decir punteros a objetos del mismo tipo nodo.

METODOS
ESPECIFICACION

JUGADA

tiempo

inicio

tiempo

fin

Real

tiempojugada

VARIABLES:

Entero

Entero

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

FijarPerdio()

: No retorna valor
3

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

Se_muestra :

caracter
Logico

OPERACIONES
Mostrar ()

: no retorna valor

fijarNumero ()

: no retorna valor

conseguirNumero ()
fijarSe_muestra ()

: retorna valor caracter

: no retorna valor
4

conseguirSe_muestra()

: retorna valor logico

SIGNIFICADO

ESPECIFICACION

NODOPUNTAJE

Cadena

jugador

Real

tiempo

VARIABLES:

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 )
fin mostrarPuntaje

ESPECIFICACION

LISTA_PUNTAJE

USA: NODOPUNTAJE

VARIABLES:
NODOPUNTAJE

LISTA_PUNTAJE

p
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

lgico

SIGNIFICADO

Algoritmos importantes:
procedimiento insertar(LISTA_PUNTAJE: raiz, NODOPUNTAJE: np)
LISTA_PUNTAJE: n
LISTA_PUNTAJE: q
n.pnp
Si raiz=NULL entonces
Raizn
sino
qraiz
mientras (q.sgte no es NULL) hacer
qq.sgte
fin mientras
6

q.sgten
fin si
n.sgteNULL

fin mostrarPuntaje

procedimiento visualizar(LISTA_PUNTAJE: raiz)

LISTA_PUNTAJE q
Qraiz
Mientras (q es diferente de NULL) hacer
q.p.mostrarPuntaje()
qq.sgte
fin mientras
fin visualizar
funcion VerificarNuevoRecord(LISTA_PUNTAJE: raz , NODOPUNTAJE: np):
logico
Logico: nuevoRecord
LISTA_PUNTAJE: q
nuevoRecord 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

USA: POSICION
USA: JUGADA

VARIABLES:
POSICION

pos

JUGADA

jugada

TERRENO

abaj

TERRENO

sgte

TERRENO

arriba

TERRENO

ante

Entero

nn

OPERACIONES
TERRENO
dameSig (TERRENO: nodo, entero: nn)

: no retorna valor
: 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
lgico
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:
funcion dameSig (TERRENO: nodo, entero: nn): TERRENO
devolver nodo.sgte
fin dameSig
funcion nodo_dev (TERRENO: raiz, entero: a, entero: b) : TERRENO
8

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 verdadero
Fin 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)

10

Si no
nodo_dev(raiz,i-1,j-1).pos.Mostrar()
Fin si
jj+1
Fin mientras
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
11

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
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)
12

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 :
n '8'
Fin seleccion
Nodo.pos.fijarNumero(n)
Fin si
jj+1
Fin mientras
ii+1
Fin mientras
Fin 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
13

Si posicion_minas[indice_minas] = posicin entonces

n.pos.fijarNumero('M')
n.pos.fijarSe_muestra(falso)
indice_minas indice_minas+1
posicin posicin+1
sino
n.pos.fijarNumero('0')
n.pos.fijarSe_muestra(falso)
posicin posicin+1
Fin si
Si raiz=NULL entonces
Razn
sino
Si i=0 entonces
qraiz
mientras (q.sgte no sea NULL) hacer
qq.sgte
Fin mientras
q.sgten
q.sgte.ante q
sino
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
14

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

15

RESULTADOS

El men de inicio con las opciones correspondientes

Al escoger la opcin 1, nos aparece el terreno del buscaminas, con el

numero de jugada 1 en la parte superior. Es necesario ir ingresando las
16

coordenadas x e y para empezar a jugar

Aca se escogi las coordenadas x=1,y=1 ; vemos que apareci el nmero 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

17

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 operacin
que incluso puede no ser posible si la memoria se encuentra fragmentada.
Las listas doblemente enlazadas requieren ms espacio por nodo y sus
operaciones bsicas resultan ms costosas pero ofrecen una mayor facilidad
para manipular ya que permiten el acceso secuencial a lista en ambas
direcciones.

18

BIBLIOGRAFA

Luis Joyanes Aguilar e Ignacio Zahonero Martnez. " Programacin en C.

Metodologa, 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.
.

19