Estructura de datos java, eliminar nodo, insertar nodo, imprimir

En el siguiente Ejercicio se pretende crear un listado de estudiantes (Curso) utilizando memoria dinámica, específicamente mediante la estructura de datos lista lineal simple, es decir que solo tiene un único enlace. Para el ejercicio se tienen diferentes clases:
1. Estudiante con 3 atributos: nombre, cédula, y edad.
2. Nodo la cual va a contener 2 atributos: Estudiante y siguiente (referencia al nodo siguiente)
3. Lista, es un clase la cual contiene los apuntadores inicio y fin y los métodos de inserción, impresión y eliminación.
4. Clase principal la cual realizará la invocación a la clase lista y demás para verificar su utilización. 

A continuación se presenta el código de la clase Estudiante:

package prylistassimple;

public class Estudiante {
    
    private String nombre;
    private String cedula;
    private int edad;

    public Estudiante() {
    }

    public Estudiante(String nombre, String cedula, int edad) {
        this.nombre = nombre;
        this.edad = edad;
        this.cedula=cedula;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
  
    public String getCedula() {
        return cedula;
    }

    public void setCedula(String cedula) {
        this.cedula = cedula;
    }    
}

No se olviden de consultar por palabras claves! Ejemplo de Estructura de datos en java, tutorial de estructura de datos

Búsqueda personalizada

A continuación se presenta el código de la clase Nodo:

package prylistassimple;

public class Nodo {
    private Estudiante alumno;
    private Nodo siguiente;

    public Nodo(Estudiante alumno) {
        this.alumno = alumno;
        siguiente=null;
    }

    public Nodo(Estudiante alumno, Nodo siguiente) {
        this.alumno = alumno;
        this.siguiente = siguiente;
    }

    public Estudiante getAlumno() {
        return alumno;
    }

    public void setAlumno(Estudiante alumno) {
        this.alumno = alumno;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
  
}

A continuación se presenta el código de la clase lista:

package prylistassimple;


public class Lista {

    Nodo inicio;
    Nodo fin;

    public Lista() {
        inicio = null;
        fin = null;
    }

    public void agregarNodoAlInicio(Estudiante obj) {
        Nodo nuevo = new Nodo(obj, inicio);
        inicio = nuevo;
        if (fin == null) {
            fin = nuevo;
        }
    }

    public void agregarNodoAlFinal(Estudiante obj) {
        Nodo nuevo = new Nodo(obj);
        // nuevo.setSiguiente(null);
        if (fin != null) {
            fin.setSiguiente(nuevo);
            fin = nuevo;
        } else {
            fin = nuevo;
            inicio = nuevo;
        }
    }

    public void recorreLista() {
        Nodo aux = inicio;
        int cont=1;
        while (aux != null) {
            System.out.println(cont +". "+aux.getAlumno().getNombre()+ "-"+aux.getAlumno().getCedula());
            cont++;
            aux = aux.getSiguiente();
        }

    }

    public void eliminarInicio() {

        if (inicio != fin) {
            Nodo aux = inicio;
            inicio = inicio.getSiguiente();
            aux = null;
        } else {
            inicio = null;
            fin = null;
        }

    }

    public boolean eliminarNodo(String cedula) {

        if (inicio != null) {//Vericación que existan nodos en la lista

            if (inicio == fin && inicio.getAlumno().getCedula().compareTo(cedula) == 0) { //Si solo existe un único nodo
                inicio = fin = null;
                return true;
            } else if (inicio.getAlumno().getCedula().compareTo(cedula) == 0) { //Si la cedula se encuentra en el primer nodo
                inicio=inicio.getSiguiente(); //Apuntamos el inicio al siguiente nodo
                return true;
            } else {
                //necesitamos dos Nodos 
                Nodo anterior = inicio; //anterior apuntando al inicio
                Nodo temporal = inicio.getSiguiente(); //temporal al siguiente nodo del anterior
                //Debemos recorrer todos los nodos de la lista hasta encontrar una cedula o hasta el final (temporal sea null)
                while (temporal != null && temporal.getAlumno().getCedula().compareTo(cedula) != 0) {
                    anterior=anterior.getSiguiente(); //desplazamos al siguiente nodo
                    temporal=temporal.getSiguiente(); // desplazamos al siguiente nodo de la lista
                }
                //Cuando llegue a este punto pudo ser si encontró una cédula o llegó al fin
                //preguntamos si fue diferente de null (es decir que halló un nodo) 
                //el proceso es eliminar el nodo donde está el temporal
                //Por lo tanto se requiere enlazar el anterior con el enlace siguiente del temporal
                if (temporal != null) {
                    anterior.setSiguiente(temporal.getSiguiente());
                    if (temporal == fin) { // puede darse el caso que el temporal sea el último nodo por lo que debemos referenciar
                        fin = anterior;        // el nuevo fin hacia el anterior
                    }
                    return true;
                }

                return false;
            }

        }return false;

    }

}

A continuación se presenta el código de la clase Principal:

public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        Lista coleccion=new Lista();
        
        Estudiante alumnoA=new Estudiante("Juan","12345", 20);
        coleccion.agregarNodoAlInicio(alumnoA);
        coleccion.agregarNodoAlFinal(new Estudiante("Santiago","1234321", 11));
        coleccion.agregarNodoAlInicio(new Estudiante("Anabel","09876", 50));
        System.out.println("Imprimir los elementos agregados hasta el momento");
        coleccion.recorreLista();
        System.out.println("Eliminar inicio");
        coleccion.eliminarInicio();
        coleccion.recorreLista();
        coleccion.agregarNodoAlFinal(new Estudiante("Alberto","7765",80));
        System.out.println("Imprimir lista");
        coleccion.recorreLista();
        
        String cedula=JOptionPane.showInputDialog("Ingrese la cédula del estudiante a eliminar");
        if(coleccion.eliminarNodo(cedula)){
            System.out.println("estudiante con cedula No. "+cedula+" borrado");
            System.out.println("Listado actual");
            coleccion.recorreLista();
                   
        }else{
            System.out.println("No existe estudiante con cedula No."+cedula);
        }
    }
    
}

Juego tres en raya en java, tic tac toe en java

A continuación se presenta el código fuente desarrollado en el lenguaje de programación java, el juego es conocido como tic-tac-toe o en otro lugares como tres en raya.

Lo primero que debemos realizar es un nuevo proyecto.
A continuación debemos crear la Clase Juego con sus respectivos métodos por ejemplo:

1. Imprimir el tablero
2. ComprobarEspacioDisponible
3. AgregarFichaTablero
4. gana
5. ConocerCoordenadas

Observe el código fuente del Juego TIC TAC TOE desarrollado en java.

package prytictactoe;

/**
 *
 * @author paulo.guerra.teran
 */
public class Juego {

    private final int ROWS = 3;
    private final int COLUMNS = 3;
    char[][] board = {{'1', '2', '3'}, {'4', '5', '6'}, {'7', '8', '9'}};

    private int x;
    private int y;

    public void imprimirTablero() {

        System.out.println("Tablero de juego");
        for (int i = 0; i < ROWS; i++) {

            for (int j = 0; j < COLUMNS; j++) {
                System.out.print("" + board[i][j] + "");
                if (j < COLUMNS - 1) {
                    System.out.print(" ║ ");
                }

            }
            System.out.println("");
            if (i < COLUMNS - 1) {
                System.out.println("═   ═   ═");
            }
        }

    }

    public void conocerCoordenadas(int valor) {

        switch (valor) {
            case 1:
                x = 0;
                y = 0;
                break;
            case 2:
                x = 0;
                y = 1;
                break;
            case 3:
                x = 0;
                y = 2;
                break;
            case 4:
                x = 1;
                y = 0;
                break;
            case 5:
                x = 1;
                y = 1;
                break;
            case 6:
                x = 1;
                y = 2;
                break;
            case 7:
                x = 2;
                y = 0;
                break;
            case 8:
                x = 2;
                y = 1;
                break;
            case 9:
                x = 2;
                y = 2;
                break;
            default:
                System.out.println("No existe una posición");

        }

    }

    public boolean comprobarEspacioDisponible(int valor) {

        conocerCoordenadas(valor);
        boolean disponible = true;

        if (board[x][y] == 'X' || board[x][y] == 'O') {
            return false;
        } else {
            return true;
        }

    }

    public void asignarFichaTablero(char ficha, int valor) {
        conocerCoordenadas(valor);
        board[x][y] = ficha;
    }

    public boolean gana(char ficha) {
        for (int i = 0; i < board.length; i++)//horizontales
        {
            int cont = 0; //contador para saber cuantas fichas iguales hay
            for (int j = 0; j < board.length; j++) {
                if (board[i][j]==ficha) {
                    cont++;
                }
            }
            if (cont == 3) {
                return true;
            }
        }

        for (int j = 0; j < board.length; j++)//verticales
        {
            int cont = 0; //contador para saber cuantas fichas iguales hay
            for (int i = 0; i < board.length; i++) {
                if (board[i][j]==ficha) {
                    cont++;
                }
            }
            if (cont == 3) {
                return true;
            }
        }

        //diagonal
        if ((board[0][0]==ficha) && (board[1][1]==ficha) && (board[2][2]==ficha)) {
            return true;
        }
        if ((board[0][2]==ficha) && (board[1][1]==ficha) && (board[2][0]==ficha)) {
            return true;
        }

        return false;

    }

}

Una ves que se tiene la lógica del juego mediante los métodos lo que debemos hacer es programar el programa principal el cual tiene el objetivo de realizar la invocaciones necesarias hacia los métodos de la clase. En esta sección se presenta el código que va a controlar los turnos y la parte de invocación para el control del juego. Si tienen alguna duda no duden en contactarme.

package prytictactoe;

import java.io.IOException;
import java.util.Scanner;

/**
 *
 * @author paulo.guerra.teran
 */
public class PryTICTACTOE {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
       
        Juego tictacInstance=new Juego();
        tictacInstance.imprimirTablero();
        
        Scanner opcion=new Scanner(System.in);
        int dato;
        boolean ganador=false;
        char ficha;
        for(int turno=1;turno<=9;turno++){
           boolean valido=true;
           ficha = (turno%2==0) ? 'X' : 'O';
            do{
                System.out.println("Seleccione una opcion (1-9): ");
                dato=opcion.nextInt();
                valido=tictacInstance.comprobarEspacioDisponible(dato);
           }while(!valido);  
           tictacInstance.asignarFichaTablero(ficha, dato);
           tictacInstance.imprimirTablero();
           if(turno>5)
               if(tictacInstance.gana(ficha)){
                    System.out.println("Ganó "+ficha);
                    ganador=true;
                    break;
               }
        }
        if(!ganador){
            System.out.println("Empate!");
        }
        
        
    }
    
}