Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » ¿Como almaceno los nombres de los juegos y muestro la cantidad de juegos que según la cantidad?

Java - ¿Como almaceno los nombres de los juegos y muestro la cantidad de juegos que según la cantidad?

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 21
Ha aumentado su posición en 22 puestos en Java (en relación al último mes)
Gráfica de Java

¿Como almaceno los nombres de los juegos y muestro la cantidad de juegos que según la cantidad?

Publicado por Iván Andrés (12 intervenciones) el 07/06/2021 23:37:04
Buenas tardes, me han dejado un taller de listas enlazadas circulares en java, ya casi lo termino, solo que no se como hacer el punto 1 y 8, si alguien me podría ayudar, estaría muy agradecido.

ENUNCIADO:
Una compañía de juegos infantiles desea hacer un programa que por medio de un menú de opciones permita realizar lo siguiente:

1)Crear una lista circular para almacenar los nombres de los juegos.

2)Insertar elementos a la lista: a. Comienzo de la lista / b. Final de la lista / c. Dada una referencia.

3)Mostrar los juegos registrados en la lista.

4)Mostrar la cantidad de juegos registrados.

5)Editar un juego registrado en la lista.

6)Eliminar un juego registrado.

7)Buscar un juego determinado.

8)Mostrar la cantidad de juegos que, según la cantidad de letras de su nombre, sea inferior a 5.

9)Salir

CLASE NODO

.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package Clases;
 
public class Nodo {
    protected int info;
    protected Nodo sig;
 
    public Nodo(){
        this.info=0;
        this.sig=null;
    }
 
    public int getInfo() {
        return info;
    }
 
    public void setInfo(int info) {
        this.info = info;
    }
 
    public Nodo getSig() {
        return sig;
    }
 
    public void setSig(Nodo sig) {
        this.sig = sig;
    }
 
 
}

CLASE LISTA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package Clases;
 
public class Lista {
    private Nodo CAB;
    private Nodo ultimo;
 
    public Lista(){
        CAB=null;
        ultimo=null;
    }
 
    //Metodo para verificar si la lista esta vacia
    public boolean esVacia(){
        return CAB==null;
    }
 
 
 
 
 
    //Metodo para almacenar un juego
 
    public void AlmacenarJuego (int dato) {
        Nodo nuevo = new Nodo ();
 
 
 
    }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    //Metodo para agregar un nodo al comienzo de la lista
    public void agregarIncio(int dato){
        Nodo nuevo=new Nodo();
        nuevo.info=dato;
        if(esVacia()){
            CAB=nuevo;
            ultimo=nuevo;
            ultimo.sig=CAB;
        }else{
            nuevo.sig=CAB;
            CAB=nuevo;
            ultimo.sig=CAB;
        }
    }//cierre del metodo
 
    //Metodo para insertar al final
    public void agregarFinal(int dato){
        Nodo nuevo=new Nodo();
        nuevo.info=dato;
        if(esVacia()){
            CAB=nuevo;
            ultimo=nuevo;
            ultimo.sig=CAB;
        }else{
            ultimo.sig=nuevo;
            nuevo.sig=CAB;
            ultimo=nuevo;
        }
    }//Cierre del metodo
 
    //Agregar un nodo dado un valor de referencia
    public void AgregarPorReferencia(int ref,int dato){
        Nodo nuevo=new Nodo();
        //nuevo.setInfo(dato);
        nuevo.info=dato;
        if(!esVacia()){
            if(Buscar(ref)){
                Nodo aux=CAB;
                while(aux.info!=ref){
                    aux=aux.sig;
                }
                if(aux==ultimo){
                    aux.sig=nuevo;
                    nuevo.sig=CAB;
                    ultimo=nuevo;
                }else{
                    //Crear un nodo de respaldo
                    Nodo siguiente=aux.sig;
                    aux.sig=nuevo;
                    nuevo.sig=siguiente;
                }
            }
        }
    }//Cierre del metodo
 
    public boolean Buscar(int ref){
        Nodo aux=CAB;
        boolean encontro=false;
        do{
            if(ref==aux.info){
                encontro=true;
            }else{
                aux=aux.sig;
            }
        }while(aux!=CAB && encontro!=true);
        return encontro;
    }//Cierre del metodo
 
    //Metodo para editar un valor dada una referencia
    public void editarPorReferencia(int ref,int dato){
        if(Buscar(ref)){
            Nodo aux=CAB;
            while(aux.info!=ref){
                aux=aux.sig;
            }
            aux.info=dato;
        }
    }//Cierre del metodo
 
    //Metodo para eliminar un nodo dada una referencia
    public void removerPorReferencia(int ref){
        if(Buscar(ref)){
            if(CAB.info==ref){ //Si se elimina el primer nodo
                CAB=CAB.sig;
                ultimo.sig=CAB;
            }else{
                Nodo aux=CAB;
                while(aux.sig.info!=ref){
                    aux=aux.sig;
                }
                if(aux.sig==ultimo){
                    aux.sig=CAB;
                    ultimo=aux;
                }else{
                    Nodo siguiente=aux.sig;
                    aux.sig=siguiente.sig;
                }
            }
        }
    }//Cierre del metodo
 
    //Metodo para listar
    public void mostrarLista(){
        if(!esVacia()){
            Nodo t=CAB;
            System.out.print("->");
            do{
                System.out.print(t.info + "->");
                t=t.sig;
            }while(t!=CAB);
            System.out.println("");
        }
    }//Cierre del metodo
 
}//Cierre de la clase


CODIGO PRINCIPAL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package compañiajuegos;
 
import Clases.*;
import java.util.*;
public class CompañiaJuegos {
 
    public static void main(String[] args) {
        Scanner teclado=new Scanner(System.in);
        int opc=0;int ref=0;
 
        //Crear la lista
        Lista listaCircular=new Lista();
        do{
            System.out.println("COMPAÑIA DE JUEGOS INFANTILES");
            System.out.println("1. Almacenar nombre de los juegos");
            System.out.println("2. Insertar al comienzo");
            System.out.println("3. Insertar al final");
            System.out.println("4. Insertar dada una referencia");
            System.out.println("5. Mostrar los juegos registrados");
            System.out.println("6. Editar juego registrado");
            System.out.println("7. Eliminar un juego registrado");
            System.out.println("8. Mostrar la cantidad de juegos que, según la cantidad de letras de su nombre, sea inferior a 5. ");
            System.out.println("9. Salir");
            System.out.println("Ingrese su opcion:");
            opc=teclado.nextInt();
            switch(opc){
 
                case 1:
                    System.out.println("Ingrese un juego:");
 
                    break;
 
 
 
 
 
 
 
 
 
 
 
 
 
                case 2:
                    System.out.println("Ingrese un juego:");
                    listaCircular.agregarIncio(teclado.nextInt());
                    break;
                case 3:
                    System.out.println("Ingrese un juego:");
                    listaCircular.agregarFinal(teclado.nextInt());
                    break;
                case 4:
                    System.out.println("Ingrese el juego de referencia:");
                    ref=teclado.nextInt();
                    System.out.println("Ingrese el juego:");
                    listaCircular.AgregarPorReferencia(ref, teclado.nextInt());
                    break;
                case 5:
                    System.out.println("Juegos registrados");
                    listaCircular.mostrarLista();
                    break;
 
                case 6:
                    System.out.println("Ingrese el juego a editar:");
                    ref=teclado.nextInt();
                    System.out.println("Ingrese el nuevo juego:");
                    listaCircular.editarPorReferencia(ref, teclado.nextInt());
                    break;
 
                case 7:
 
                    System.out.println("Ingrese el juego a eliminar:");
                    listaCircular.removerPorReferencia(teclado.nextInt());
 
                    break;
 
                case 8:
                    System.out.println("Juegos que la cantidad de letras de su nombre es inferior a 5");
                    break;
 
                case 9:
                    System.out.println("");
 
                    break;
            }//Cierre del switch
        }while(opc<9);
    }//Cierre del main
 
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder