Practica3 Domino

UAEH
Escuela Superior de Tizayuca
Ingeniería en Computación
4º semestre
Asignatura: Estructuras de datos
Profesor: M. en C. Israel Acuña Galván

Marco teórico (20%)
Número de práctica: 3
Evaluación (20%)
Nombre de la práctica: Listas Análisis y discusión de
resultados (30%)
Grupo: 1 Conclusiones (20%)
Integrantes del equipo Bibliografía (10%)
 Manuel Cruz Ángel Uriel TOTAL REPORTE
 Marín Juárez Ángel Jesús

 Malthus Evangelista Eliud Vladimir TOTAL DESARROLLO
Fecha de entrega
29 de marzo del 2022 TOTAL

OBJETIVO.
 Asimilar el concepto de lista por medio de su programación y el uso de las colecciones en Java
Objetivos específicos
 Aplicar una pila para resolver un problema de programación
 Crear una interfaz gráfica de usuario para aplicar manejar una pila
MARCO TEÓRICO.
Una lista es una colección o secuencia de elementos dispuestos uno detrás de otro, en la que
cada elemento se conecta al siguiente elemento por un enlace o puntero La idea básica
consiste en construir una lista cuyos elementos llamados nodos se componen de dos partes o
campos la primera parte o campo contiene la información y es, por consiguiente, un valor de
un tipo genérico denominado Dato Tipo Elemento y la segunda parte o campo es un puntero
denominado enlace que apunta al siguiente elemento de la lista
Listas simplemente enlazadas
pueden dividir en cuatro categorías Cada nodo elemento contiene un único enlace que conecta
ese nodo al nodo siguiente o nodo sucesor La lista es eficiente en recorridos directos adelante
Listas doblemente enlazadas Cada nodo contiene dos enlaces uno a su nodo predecesor y el
otro a su nodo sucesor tanto en recorrido directo adelante como en recorrido inverso atrás
Lista circular simplemente enlazada Una lista enlazada simplemente en la que el último
elemento cola se enlaza al primer elemento cabeza de tal modo que la lista puede ser recorrida
de modo circular
Lista doblemente enlazada doblemente enlazada en la que el último elemento se enlaza al
primer elemento y viceversa Esta lista se puede recorrer de modo circular tanto en dirección
directa como inversa Una lista enlazada requiere unos controles para la gestión de los
elementos contenidos en ellas
Estos controles se manifiestan en forma de operaciones que tendrán las siguientes funciones:
Declaración de los tipos nodo y puntero a nodo Inicialización o creación. Insertar elementos en
una lista Eliminar elementos de una lista. Buscar elementos de una lista comprobar la
existencia de elementos en una lista Recorrer una lista enlazada visitar cada nodo de la lista
Las operaciones en listas en java son insertar elemento obtener el valor de la lista y devolver
el resultado de la lista del elemento correspondiente a la lista y hacer la eliminación
DESARROLLO.
Programa de consola
Main
package apliacion.u;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
1/27
public class ApliacionU extends Application {
@Override
public void start(Stage stage) throws Exception {
Parent root = FXMLLoader.load(getClass().getResource("FXMLDocument.fxml"));
Scene scene = new Scene(root);
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {

Scanner ent = new Scanner(System.in);
Int opc;
int pos;
int lugar;
Domino juego = new Domino ();
LinkedList<fichaDomino> fichas;
fichas = juego.obtenFichas();
System.out.println(fichas);
do{
System.out.println("1, intercambiar ficha");

System.out.println("2, girar ficha");
System.out.println("3 Calcular puntos y terminar juego");
opc = ent.nextInt();
switch (opc){
case 1:
System.out.println("Ingresa la ficha que deseas mover:");
pos = ent.nextInt();
System.out.println("A que posicion deseas moverla:");
lugar = ent.nextInt();
fichas.add(lugar,fichas.remove(pos));
System.out.println(fichas);
break;
case 2:
System.out.println("Que ficha deseas girar:");
pos = ent.nextInt();
fichas.get(pos).girar();
2/27
//
// System.out.println(fichas);
// break;
//
// case 3:
// juego calcula Puntos(fichas);
// break;
// }
// } while (opc =3);
launch(args);
}
Class domino
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
public class Domino {

LinkedList<fichaDomino> fichasTotal = new LinkedList<>();
LinkedList<fichaDomino> fichaJuego = new LinkedList<>();
fichaDomino aux;
public Domino(){
fichaDomino ficha;
for(int i = 1;i<=6;i++){
for(int j = 1;j<=6;j++){
if(fichasTotal.size()<28){
ficha = new fichaDomino(i,j);
fichasTotal.add(ficha);
}
else
i = 7;
}
}
}
public LinkedList<fichaDomino> obtenFichas(){

int k = 0;
int l;
while(k <5){
3/27
l = (int) (Math.random()* fichasTotal.size());
aux = fichasTotal.get(l);
fichaJuego.add(aux);
fichasTotal.remove(l);
k++;
}
return fichaJuego;
}
public int calculaPuntos(LinkedList<fichaDomino> juego){

int puntos = 0;
for(int i = 0;i< fichaJuego.size()-1;i++){
if(juego.get(i).getDer() == juego.get(i+1).getIzq())
puntos+= 1;
}
return puntos;
}
}
Class ficha
public class fichaDomino {
private int der;
private int izq;
private int aux;
public fichaDomino(int izq, int der){

this.izq = izq;
this.der = der;
}
public int getDer() {

return der;
}
public int getIzq() {

return izq;
}
public void girar(){

aux = der;
der = izq;
izq = aux;
}
4/27
@Override
public String toString() {
return " " + izq+"|"+der+" ";
}
}
Interfaz
import javafx.fxml.FXML;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.image.Image;
import javafx.scene.text.Text;
import java.util.LinkedList;
public class FXMLDocumentController {
Domino juego = new Domino();

LinkedList<fichaDomino> fichas;
public FXMLDocumentController(){
fichas = juego.obtenFichas();
}
@FXML
Canvas canv1;
@FXML
Canvas canv2;
@FXML
Canvas canv3;
@FXML
Canvas canv4;
@FXML
Canvas canv5;
@FXML
TextField pos;
@FXML
5/27
TextField lugar;
@FXML
TextField ficha;
@FXML
Label puntaje;
@FXML
public void moverFicha(){
int posicion;
int lug;
try{
posicion = Integer.parseInt(pos.getText());
lug = Integer.parseInt(lugar.getText());
fichas.add(lug,fichas.remove(posicion));
recargarImg();
puntaje.setText("Puntos: "+juego.calculaPuntos(fichas));
}
catch(Exception e){
System.out.println("Valores no validos");
}
}
@FXML
public void girarFicha(){
int fic;
try{
fic = Integer.parseInt(ficha.getText());
fichas.get(fic).girar();
recargarImg();
puntaje.setText("Puntos: "+juego.calculaPuntos(fichas));
}
catch (Exception e){
System.out.println("Valores no validos");
}
}
@FXML
public void Salir(){
System.exit(0);
}
@FXML
public void initialize(){
recargarImg();
}
6/27
public void recargarImg(){
fichaDomino aux;
GraphicsContext gc;
for(int i = 0;i< fichas.size();i++){
aux = fichas.get(i);
switch (i){
case 0:
gc = canv1.getGraphicsContext2D();
if(aux.getIzq() == 1){
if(aux.getDer() == 1){
Image prueba = new Image("file:imagenes/1-1.png");
gc.drawImage(prueba,0,0);
}
}
}
}
}
}
}
}
}
7/27
}
}
}
}
}
}
}
}
}
}
}
}
}
8/27
}
}
}
}
}
}
}
}
}
}
}
}
}
9/27
}
}
}
}
}
}
}
break;
case 1:
}
}
}
}
10/27
}
}
}
}
}
}
}
}
}
}
}
}
}
11/27
}
}
}
}
}
}
}
}
}
}
}
}
12/27
}
}
}if(aux.getDer() == 5){
}
}
}
}
}
}
}
}
}
}
break;
case 2:
13/27
}
}
}
}
}
}
}
}
}
}
}
}
14/27
}
}
}
}
}
}
}
}
}
}
}
}
15/27
}
}
}
}
}
}
}
}
}
}
}
}
16/27
}
}
}
}
}
break;
case 3:
}
}
}
}
}
}
}
17/27
}
}
}
}
}
}
}
}
}
}
}
}
18/27
}
}
}
}
}
}
}
}
}
}
}
}
19/27
}
}
}
}
}
}
}
}
}
}
break;
case 4:
}
}
20/27
}
}
}
}
}
}
}
}
}
}
}
}
}
21/27
}
}
}
}
}
}
}
}
}
}
}
}
}
22/27
}
}
}
}
}
}
}
}
}
}
}
23/27
}
}
break;
}
}
}
}
EVALUACIÓN.
1) ¿Qué hace el método addAll de la clase LionkedList?
R= implementa la lógica para trabajar con listas genéricas, es decir podemos insertar y extraer
elementos de cualquier parte de la lista mediante un programa para llamar los principales métodos de la
clase linkedList
importé java.util.LinkedList;
LinkedList<String> lista1 = new LinkedList<String>();
2) ¿Cuál es la diferencia entre el método indexOf y lastIndexOf de la clase linkedList?
R= que el método indexOf devuelve el índice de la primera aparición del elemento especificado en esta
lista, o -1 si esta lista no contiene el elemento y el método lastIndexOf devuelve el índice de
la última aparición del elemento especificado en esta lista, o -1 si esta lista no contiene el elemento
3) ¿Es posible convertir un objeto de la clase LinkedList a un objeto de la clase Array?
R= si por medio de:

Obtener LinkedList
Convierta la matriz LinkedList en Object usando el método toArray()
Convierta la matriz de objetos en la matriz de tipo deseada utilizando el método Arrays.copyOf()
Devuelve la impresión de la matriz
4) ¿Con qué método se reemplaza un elemento de una lista utilizando la posición?
R= clear elimina todos los elementos

Set (posición x) Sustituye el elemento que se encuentra en la posición indicada por el objeto x
Devuelve el elemento sustituido
Contains(x) comprueba si la colección contiene al objeto x Devuelve true o false
24/27
ANÁLISIS Y DISCUSIÓN DE RESULTADOS.
Como se puede observar se está haciendo la visualización de la practica listas que tiene que ver con crear
una clase llamada ficha domino y hacer su interfaz gráfica con los métodos correspondientes a
continuación se muestra el resultado de consola funcionando correctamente a todas las opciones que
pregunta cómo nos explicó el maestro en las clases vistas durante todas las clases, pero copila
correctamente En la interfaz tuvimos algunas complicaciones ya que no se nos muestran nuestras
imágenes de nuestra carpeta no se enlazan en la interfaz tuvimos ese problema, pero los resultados del
código están correctos solo tuvimos ese problema qué no nos detectan las imágenes los resultados fueron
pocos esperados ya que nos faltó en la interfaz gráfica porque en lo demás funciono correctamente, pero
intentaremos seguir mejorando aún más en los métodos correspondientes
25/27
CONCLUSIONES.
conocimiento de la implementación de las listas

En el desarrollo de nuestra practica de listas aprendimos el
enlazadas que nos facilita la representación eficiente de los datos de los elementos y el uso de variables
La idea básica es que cada componente de la lista incluya un puntero que indique donde puede
encontrarse el siguiente componente por lo que el orden relativo de estos puede ser fácilmente alterado
modificando los punteros lo que permite, a su vez, añadir o suprimir elementos de la lista y usando las
librerías correspondientes LinkedList para un mejor funcionamiento
BIBLIOGRAFÍA.
2017, LinkedList en Java

 Charwin.R(2017) linkedList en java de
https://www.tutorialcup.com/es/Java/lista-enlazada-en-java.htm
 Anónimo (2015) método indexOf y lastIndexOf de
https://es.myservername.com/linked-list-java-linked-list-implementation-java-examples
 Oscar.C(2019) elementos de reemplazamiento en listas enlazadas en java
https://es.acervolima.com/reemplazar-un-elemento-de-arraylist-usando-java-listiterator/
 https://www.delftstack.com/es/howto/java/how-to-convert-list-to-an-array-in-java/
26/27

Practica3 Domino

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Practica3 Domino

Cargado por

Copyright:

Formatos disponibles

UAEH

Escuela Superior de Tizayuca

Asignatura: Estructuras de datos

Profesor: M. en C. Israel Acuña Galván

Grupo: 1 Conclusiones (20%)

Integrantes del equipo Bibliografía (10%)

 Manuel Cruz Ángel Uriel TOTAL REPORTE

 Marín Juárez Ángel Jesús

29 de marzo del 2022 TOTAL

Scene scene = new Scene(root);

public static void main(String[] args) {

Domino juego = new Domino ();

System.out.println("1, intercambiar ficha");

public class Domino {

public LinkedList<fichaDomino> obtenFichas(){

public int calculaPuntos(LinkedList<fichaDomino> juego){

public fichaDomino(int izq, int der){

public int getDer() {

public int getIzq() {

public void girar(){

public class FXMLDocumentController {

Domino juego = new Domino();

1) ¿Qué hace el método addAll de la clase LionkedList?

2) ¿Cuál es la diferencia entre el método indexOf y lastIndexOf de la clase linkedList?

3) ¿Es posible convertir un objeto de la clase LinkedList a un objeto de la clase Array?

R= si por medio de:

4) ¿Con qué método se reemplaza un elemento de una lista utilizando la posición?

R= clear elimina todos los elementos

conocimiento de la implementación de las listas

2017, LinkedList en Java

También podría gustarte