Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Duda con ejercicio en grafos

Java - Duda con ejercicio en grafos

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 9
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

Duda con ejercicio en grafos

Publicado por Alexander (5 intervenciones) el 07/07/2019 02:02:31
Buenas tardes.

Tengo dudas con respecto a este ejercicio, alguno podria explicarme como resolverlo, me gustaria un asesoramiento, el enunciado es el siguiente:

Se desea desarrollar una clase de listas enlazadas que genere un grafo fuertemente conexo en forma de estrella
como se muestra en la imagen. Cada nodo almacenará un entero como su valor. Los nodos de la estrella deberán
estar ordenados de menos a mayor comenzando por el nodo central de la estrella. Se desea que desarrolle la clase
Nodo y el método public void AgregarNodo( Nodo nuevo ) el cual agregue un nodo a la lista
manteniendo el orden.
IMG-20190706-WA0081
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
Imágen de perfil de Sebastian
Val: 282
Ha disminuido 1 puesto en Java (en relación al último mes)
Gráfica de Java

Duda con ejercicio en grafos

Publicado por Sebastian (91 intervenciones) el 07/07/2019 19:16:11
Tienes que crear dos clases, la clase Node<t> y Linkedlist<t>, la clases tiene que ser clases parametrizada.

En la clase Node debes crear dos variables de clase, una donde guardas el dato del nodo y el nodo siguiente que se inicializa en nulo.

Y en la clase Linkedlist creas una variable de clase donde asignas la cabeza de la lista, ahí guardas el primer nodo ingresado, que seria el 8 luego tienes que ir pegando los nodos a la cabeza, teniendo en cuenta si es mañor o menor.

Espero te dé una idea todo esto.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 9
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

Duda con ejercicio en grafos

Publicado por Alexander (5 intervenciones) el 07/07/2019 20:13:24
Hice lo siguiente siguiendo lo que me dices y me quede en la parte de insertar el elemento, no entendi como hacer esta parte y hacer que la lista se siga manteniendo ordenada.

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
public class Nodo<T> {
 
    private T dato;
    private Nodo<T> siguiente;
 
    public Nodo(){
        siguiente=null;
     }
 
    public Nodo(T p){
        siguiente=null;
        dato = p;
    }
 
    public Nodo(T t, Nodo<T> siguiente){
        this.siguiente=siguiente;
        dato = t;
    }
 
    public T getDato() {
        return dato;
    }
 
    public void setDato(T dato) {
        this.dato = dato;
    }
 
    public Nodo<T> getSiguiente() {
        return siguiente;
    }
 
    public void setSiguiente(Nodo<T> siguiente) {
        this.siguiente = siguiente;
    }
 
}
 
public class ListaDinamica<T> implements Iterable<T>{
 
    private Nodo<T> primero;
    private int tamanio;
 
    public ListaDinamica() {
        primero = null;
        tamanio = 0;
    }
 
    public boolean isEmpty() {
        return tamanio == 0;
    }
 
public agregarNodo(T nodo){
/*Este seria el metodo a realizar*/
}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Sebastian
Val: 282
Ha disminuido 1 puesto en Java (en relación al último mes)
Gráfica de Java

Duda con ejercicio en grafos

Publicado por Sebastian (91 intervenciones) el 08/07/2019 03:21:11
Listo, este código ingresa los datos a la lista y valida los casos posibles al ingresar un nuevo dato a la lista
Teniendo en cuenta que hay que mantener el orden de la lista y la estructura estrella de la imagen.

Casos a validar:
1) Si la lista esta en blanco
2) Si el dato ingresado es menor al de la cabeza de la lista
3) Si solo esta la cabeza de la lista
4) En el ultimo se recorre la lista buscando si el dato ingresado es menor al siguiente de la lista, si es igual, lo coloca en esa posición si no,
lo agrega al final de la 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
public void agregarNodo(T nodo){
  /*Este seria el metodo a realizar*/
    Nodo<T> nodoInfo= new Nodo<T>(nodo);
    if(primero==null){
      primero=nodoInfo;
    }else if(Integer.parseInt(primero.getDato().toString()) > Integer.parseInt(nodoInfo.getDato().toString())){
      Nodo<T> nodoAux=new Nodo<T>(primero.getDato());
      nodoAux.setSiguiente(new Nodo<T>(nodoInfo.getDato()));
      nodoAux.getSiguiente().setSiguiente(primero.getSiguiente());
      nodoInfo.setSiguiente(nodoAux);
      primero = nodoInfo;
      nodoAux = primero.getSiguiente().getSiguiente();
      while(nodoAux != null){
        if(Integer.parseInt(nodoAux.getDato().toString())== Integer.parseInt(primero.getSiguiente().getDato().toString())){
          nodoAux.setDato(primero.getDato());
        }
        nodoAux = nodoAux.getSiguiente();
      }
 
    }else if(primero.getSiguiente() == null){
      Nodo<T> nodoAux=new Nodo<T>(primero.getDato());
      nodoInfo.setSiguiente(nodoAux);
      primero.setSiguiente(nodoInfo);
      nodoInfo.getSiguiente().setSiguiente(null);
    }else{
      Nodo<T> nodoAux=primero;
      while(nodoAux.getSiguiente() != null){
        if(Integer.parseInt(nodoAux.getSiguiente().getDato().toString()) > Integer.parseInt(nodoInfo.getDato().toString())){
          nodoInfo.setSiguiente(new Nodo(primero.getDato()));
          nodoInfo.getSiguiente().setSiguiente(nodoAux.getSiguiente());
          nodoAux.setSiguiente(nodoInfo);
          nodoInfo = null;
          break;
        }
        nodoAux = nodoAux.getSiguiente();
      }
      if(nodoInfo!=null){
        nodoAux.setSiguiente(nodoInfo);
        nodoInfo.setSiguiente(new Nodo(primero.getDato()));
        nodoInfo.getSiguiente().setSiguiente(null);
      }
    }
    tamanio++;
  }

Espero te ayude.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 9
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

Duda con ejercicio en grafos

Publicado por Alexander (5 intervenciones) el 08/07/2019 03:29:26
Muchisimas gracias por tu ayuda y por ser tan amable.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar