MENU DE LISTAS LIGADAS DOBLES EN JAVA

ESTE ES LA TAREA DE PROGRAMACION JAVA DE MENU DE LISTAS LIGADAS DOBLES ESTOS SON LOS TRES ARCHIVOS QUE TIENEN QUE TENER:

EL 1° ARCHIVO SE LLAMARA NODOLISTAD ESTE ARCHIVO CONTIENE LOS CONSTRUCTORES DE LOS NODOS Y ASI QUEDATA EL PROGRAMA:

///////////////GENERA NODOS PARA LISTAS DOBLES////////////////////

class NodoListaD{
    ////3 campos
    Object info;
    NodoListaD Izq;/////////////asi se declara para apuntar a un dato igual a ellos
    NodoListaD Der;
   
    /////////////primer constructor/*/////////////////
    public NodoListaD(Object Dato){
        this.info = Dato;
        this.Izq = null;
        this.Der = null;
    }
   
    /////////////////segundo constructor///////////////
    public NodoListaD(NodoListaD Izq, Object Dato){
        this.Izq = Izq;
        this.info = Dato;
        this.Der = null;
    }
   
    //////////////////tercer constructor//////////////
    public NodoListaD(Object Dato, NodoListaD Der){
        this.Izq = null;
        this.info = Dato;
        this.Der = Der;
    }
   
    //////////////////cuarto constructor////////////////
    public  NodoListaD(NodoListaD Izq, Object Dato, NodoListaD Der){
        this.Izq = Izq;
        this.info = Dato;
        this.Der = Der;
    }
}

EL 2° ARCHIVO SE LLAMARA LISTAD ESTE ARCHIVO SON LAS FUNCIONES QUE CREARAN LOS NODOS CON LOS DIFERENTES CONSTRUCTORES:


///////////////////////////LISTA QUE MANIPULA A LOS PUNTEROSY METODOS /////////////

class ListaD{
    //////PUNTEROS
    public NodoListaD Primero,Ultimo,Nuevo,Aux,Pos,Ant;
   
    //////constructor
    public ListaD(){
        Primero = Ultimo = Nuevo = Aux = Pos = Ant = null;
    }
    ////////////////////////INSERTAR AL FRENTE//////////
    public void insertarAlFrente(Object dato){
        if(Primero==null){//////////1 caso(lista vacia)
        Primero = new NodoListaD(dato);
        Ultimo = Primero;
        }
        else{
            Nuevo = new NodoListaD(Ultimo, dato);
            Ultimo.Der = Nuevo;
            Ultimo = Nuevo;
        }despliegaLista();
    }
    ////////////////INSERTAR ATRAS//////////////
    public void insertarAtras(Object dato){
        if(Primero==null){
            Primero = new NodoListaD(dato);
            Ultimo = Primero;
        }
        else {
            Nuevo = new NodoListaD(dato,Primero);
            Primero.Izq=Nuevo;
            Primero = Nuevo;
        }despliegaLista();
    }
    /////////INSERTAR ANTES DE //////////
    public void insertarAntesDe(Object DatoB,Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{/////hay datos
            if(buscar(DatoB)== true){
                ///////EMPEZAR A REALIZAR EL METODO
                if(Aux==Primero){///caso 1
                Nuevo= new NodoListaD(DatoI,Primero);
                Primero.Izq = Nuevo;
                Primero=Nuevo;
                }
                else{//en caso de que no este al inicio de la lista
                    Nuevo = new NodoListaD(Ant,DatoI , Aux);
                    Aux.Izq = Nuevo;
                    Ant.Der=Nuevo;
                }
            }   
        }
        despliegaLista();
    }
    ////////////////INSERTAR     DESPUES DE///////////////
    public void insertarDespuesDe(Object DatoB, Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{///hay metodos
            if(buscar(DatoB)== true){
                //////EMPEZAR A REALIZAR EL METODO/////
                if(Aux==Ultimo){
                    Nuevo=new NodoListaD(Aux,DatoI);
                    Aux.Der=Nuevo;
                    Ultimo=Nuevo;
                }
                else{///en caso de que no este al inicio de la lista
                    Nuevo= new NodoListaD(Aux,DatoI,Aux.Der);
                    Aux.Der = Nuevo;
                    Pos = Aux.Der;
                    Pos.Izq =Aux.Der;
                }
               
            }
        }despliegaLista();
    }
    ///////////////METODO ELIMINAR NODO//////////////
    public void eliminarNodo(Object DatoB){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
            if(buscar(DatoB)==true){///hacer cuatro casos
                if(Primero==Ultimo){//// 1 caso
                    Primero=Ultimo=null;
                }
                else if(Aux==Primero){//2caso
                    Primero=Aux.Der;
                    Primero.Izq=Aux=null;
                }
                else if(Aux==Ultimo){//3 caso
                    Ultimo=Ant;
                    Ultimo.Der=Aux=null;
                }
                else{//4 caso
                    Ant.Der=Pos;
                    Pos.Izq=Ant;
                    Aux=null;
                }
            }
        }despliegaLista();
    }
    /////////////METODO PARA SUSTITUIR DATO///////////////
    public void modificaLista(Object DatoB,Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
            if(buscar(DatoB)==true){
                Aux.info=DatoI;
            }
        }despliegaLista();
    }
    //////////////////////////METODO BUSCAR/////////
    public boolean  buscar(Object DatoB){
        Aux = Primero;
        boolean bandera = false;
        while (Aux != null && bandera != true) {
            if(DatoB.equals(Aux.info)){// si encuentra el dato //la funcion .equals sirve para comparar el contenido de una direccion de memoria
                bandera = true;
            }
            else{//apunta al siguiente nodo
                Ant = Aux;
                Aux = Aux.Der;
                Pos = Aux.Der;
            }
        }
        if(bandera == true){
            return true;
        }
        else{
            System.out.println ("ese dato no existe");
            return false;
        }
    }
    ////////////////////DESPLEGAR LISTA DOBLE////////////////
    public  void despliegaLista(){
        Aux = Primero;
        System.out.println ("#########   LISTA COMPLETA   ###########");
        while (Aux != null) {
            System.out.println (Aux.info);
            Aux = Aux.Der;
        }
        System.out.println ("########################################");
    }
}


EL 3° ARCHIVO SE LLAMARA APPLISTAD ESTE ES EL MENU DE DONDE SE EJECUTARAN LAS FUNCIONES:



import java.util.Scanner;
class AppListaD{
    public static void main(String args[]){
        ListaD lista = new ListaD();
        Integer DatoB,DatoI;
        int opcion;
       
        //Inicializacion del teclado
        Scanner Teclado = new Scanner(System.in);
        do{
            System.out.println ("1) Insertar al frente");
            System.out.println ("2) Insertar al Atras");
            System.out.println ("3) Insertar Antes de");
            System.out.println ("4) Insertar Despues de");
            System.out.println ("5) Eliminar Dato");
            System.out.println ("6) Modificar Dato");
            System.out.println ("7) DesplegarLista");
            System.out.println ("8) Salir");
            opcion = Teclado.nextInt();
            switch (opcion) {
                case 1: System.out.println ("Que dato quieres insertar al frente de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarAlFrente(DatoI);
                        break;
                case 2: System.out.println ("Que dato quieres insertar Atras de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarAtras(DatoI);
                        break;
                case 3: System.out.println ("Que dato quieres insertar Antes de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        System.out.println ("Atras de que dato quieres insertar el :"+DatoI);
                        DatoB = new Integer(Teclado.nextInt());
                        lista.insertarAntesDe(DatoB,DatoI);
                        break;
                case 4: System.out.println ("Que dato quieres insertar Despues de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        System.out.println ("Despues de que dato quieres insertar el :"+DatoI);
                        DatoB = new Integer(Teclado.nextInt());
                        lista.insertarDespuesDe(DatoB,DatoI);
                        break;
                case 5: System.out.println ("Que dato quieres ELiminar de la Lista: ");
                        DatoB = new Integer(Teclado.nextInt());
                        lista.eliminarNodo(DatoB);
                        break;
                   case 6: System.out.println ("Que dato quieres buscar para sustituir: ");
                           DatoB = new Integer(Teclado.nextInt());
                           System.out.println ("Que dato quieres poner en el numero "+DatoB+":");
                           DatoI = new Integer(Teclado.nextInt());
                           lista.modificaLista(DatoB,DatoI);
                        break;
                   case 7: lista.despliegaLista();
                        break;
                case 8: System.out.println ("\tbye...\n");
                        break;                               
                default :System.out.println ("\topcion no valida intenta de nuevo\n");
            }
        }while (opcion != 8);
    }
}


BUENO AMIGOS COMENTEN PARA DECIR QUE LES PARESE ACEPTO NEGATIVAS, INSULTOS Y DEMAS AUNQUE LOS BORRARE PERO USTEDES COMENTEN HAHAHAHA AUNQUE SEA PARA AGRADECER......

RECONOCIMIENTO DE PROGRAMACION

HOLA DE NUEVO GENTE OTRA VEZ AQUI SOLO PARA COMPARTIR UNO DE MIS LOGROS QUE NO FUE SOLO MIO SINO DEL EQUIPO QUE PARTICIPAMOS EN EL SEGUNDO ENCUENTRO DE ESTUDIANTES REALIZADO POR EL CENTRO UNIVERSITARIO DE LOS VALLES MI EQUIPO ESTABA CONFORMADO POR RAMON BUENO HERNANDEZ, JUAN MANUEL HERNANDEZ QUINTERO Y SU SERVIDOR JOSE SALVADOR MUÑIZ ALCANTAR ESTE MISMO EL CAPITAN DEL EQUIPO LLAMADO "LOS BURROS SIN MECATE" QUE PARTICIPAMOS EN EL CONCURSO DE PROGRAMACION BASICA QUE CONSTABA DE REALIZAR LA MAYOR CANTIDAD DE PROGRAMAS INDICADOS POR LOS JUECES QUIENES CALIFICABAN EL TIEMPO Y EL PROGRAMA EN SU ESTRUCTURA Y SU FUNCIONAMIENTO DEL CUAL DESPUES DE TERMINAR LA COMPETENCIA LA RESOLUCION DE LOS JUECES FUE OTORGARNOS EL PRIMER LUGAR DEL CONCURSO A NUESTRO EQUIPO Y HASTA HACE UNAS SEMANAS NOS ENTREGRARON ESTOS RECONOSIMIENTOS Y ESE MISMO DIA DEL CONCURSO UNOS PREMIOS QUE LA VERDAD VALIERON LA PENA BUENO NO LES PLATICO MAS QUE AQUI ESTAN LOS RECONOCIMIENTOS COMENTEN POR FAVOR....

MENU DE LISTAS LIGADAS SIMPLES EN JAVA

BUENO AMIGOS DE LA CARRERA DE MECATRONICA Y A TODA LA GENTE QUE SE DIO LA OPORTUNIDAD DE LEER ESTO AQUI LES SUBO LA TAREA DE ESTA SEMANA DE PROGRAMACION QUE SON LAS LISTAS LIGADAS TERMINADOS TODOS LOS CASOS Y JALANDO A TODA MADRE BUENO JENTE DISFRUTENLO.......... Y POR FAVOR SI LO VAN A COPIAR Y PEGAR POR FAVOR DE PERDIDA COMENTEN Y AGRADESCAN QUE ME MATE HACIENDO ESTO HAHAHAHAHA NO ES CIERTO NO POR ALGO SOMOS EL #1 EN EL CONCURSO DE PROGRAMACION BASICA.

EL PRIMER ARCHIVO SE DEBE DE LLAMAR NODOLISTA Y ASI QUEDARA:

///clase (registro) que sirve para generar nodos de dos tipos de formas (2 constructores)

public class NodoLista {
    // 2 campos
    Object Info;
    NodoLista Liga;
   
    //PRIMER CONSTRUCTOR
    public NodoLista(Object dato){
        Info = dato;
        Liga = null;
    }
   
    //SEGUNDO CONSTRUCTOR
    public NodoLista(Object dato, NodoLista liga){
        Info = dato;
        this.Liga = liga;  /////el this solo es para decir que la primera "liga"
    }                          ////es global
}


ESTE ES EL ARCHIVO LLAMADO  LISTA , ES DONDE SE REALIZAN LAS FUNCIONES PARA EJECUTAR LOS CONSTRUCTORES, ASI DEBE DE QUEDAR:


//// clase que manipula a los punteros para manipular los nodos en la memoria

public class Lista{
    // declarar los punteros!!!
    NodoLista Primero, ultimo, aux, nuevo, ant, post;
   
    public Lista(){
        Primero = ultimo = aux = nuevo = ant = post = null;
    }
   
    public void insertarAlFrente(Object dato){
        if(Primero==null){// si la lista esta vacia
            Primero = new NodoLista(dato);
            ultimo=Primero;
        }
        else{////ya hay mas nodos en la lista
            nuevo = new NodoLista(dato);
            ultimo.Liga = nuevo;
            ultimo = nuevo;
        }despliegaLista();         
    }
   
    public void insertarAtras(Object dato){
        if(Primero==null){// si la lista esta vacia
            Primero = new NodoLista(dato);
            ultimo=Primero;
        }
        else{
            nuevo = new NodoLista(dato,Primero);
            Primero = nuevo;
        }despliegaLista();
    }   
   
    public void despliegaLista(){
        aux = Primero;
        System.out.println ("##########LISTA COMPLETA#########");
        while (aux != null) {
            System.out.println (aux.Info);
            aux = aux.Liga;
        }
        System.out.println ("##########LISTA COMPLETA#########");
    }
    /////////INSERTAR ANTES DE //////////
    public void insertarAntesDe(Object DatoB,Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{/////hay datos
            if(buscar(DatoB)== true){
                ///////EMPEZAR A REALIZAR EL METODO
                if(aux==Primero){///caso 1
                nuevo= new NodoLista(DatoI,Primero);
                Primero = nuevo;
                }
                else{//en caso de que no este al inicio de la lista
                    nuevo = new NodoLista(DatoI , aux);
                    ant.Liga = nuevo;
                }
            }   
        }
        despliegaLista();
    }
    //////////////INSERTAR DESPUES DE//////////////////
    public void insertarDespuesDe(Object DatoB, Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{///hay metodos
            if(buscar(DatoB)== true){
                //////EMPEZAR A REALIZAR EL METODO/////
                if(aux==Primero){
                    nuevo=new NodoLista(DatoI);
                    Primero.Liga=nuevo;
                }
                else{///en caso de que no este al inicio de la lista
                    nuevo= new NodoLista(DatoI, aux.Liga);
                    aux.Liga=nuevo;
                }
               
            }
        }despliegaLista();
    }
   
    ///////////////METODO ELIMINAR NODO//////////////
    public void eliminarNodo(Object DatoB){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
            if(buscar(DatoB)==true){///hacer cuatro casos
                if(Primero==ultimo){//// 1 caso
                    Primero=ultimo=null;
                }
                else if(aux==Primero){
                    Primero=aux.Liga;
                    aux=null;
                }
                else if(aux==ultimo){
                    ultimo=ant;
                    ultimo.Liga=null;
                    aux=null;
                }
                else{
                    ant.Liga=aux.Liga;
                    aux=null;
                }
            }
        }despliegaLista();
    }
   
    /////////////METODO PARA SUSTITUIR DATO///////////////
    public void modificaLista(Object DatoB,Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
            if(buscar(DatoB)==true){
                aux.Info=DatoI;
            }
        }despliegaLista();
    }
    //////////////////////////METODO BUSCAR/////////
    public boolean  buscar(Object DatoB){
        aux = Primero;
        boolean bandera = false;
        while (aux != null && bandera != true) {
            if(DatoB.equals(aux.Info)){// si encuentra el dato
                bandera = true;
            }
            else{//apunta al siguiente nodo
                ant = aux;
                aux = aux.Liga;
                post = aux.Liga;
            }
        }
        if(bandera == true){
            return true;
        }
        else{
            System.out.println ("ese dato no existe");
            return false;
        }
    }
   
}


ESO FUE EL ARCHIVO LISTA Y ESTE ES EL ARCHIVO APPLISTA , ES DONDE SE LLAMARAN A LAS FUNCIONES ASI DEBE DE QUEDAR:


import java.util.Scanner;
class AppLista{
    public static void main(String args[]){
        Lista lista = new Lista();
        Integer DatoB,DatoI;
        int opcion;
      
        //Inicializacion del teclado
        Scanner Teclado = new Scanner(System.in);
        do{
            System.out.println ("1) Insertar al frente");
            System.out.println ("2) Insertar al Atras");
            System.out.println ("3) Insertar Antes de");
            System.out.println ("4) Insertar Despues de");
            System.out.println ("5) Eliminar Dato");
            System.out.println ("6) Modificar Dato");
            System.out.println ("7) DesplegarLista");
            System.out.println ("8) Salir");
            opcion = Teclado.nextInt();
            switch (opcion) {
                case 1: System.out.println ("Que dato quieres insertar al frente de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarAlFrente(DatoI);
                        break;
                case 2: System.out.println ("Que dato quieres insertar Atras de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarAtras(DatoI);
                        break;
                case 3: System.out.println ("Que dato quieres insertar Antes de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        System.out.println ("Atras de que dato quieres insertar el :"+DatoI);
                        DatoB = new Integer(Teclado.nextInt());
                        lista.insertarAntesDe(DatoB,DatoI);
                        break;
                case 4: System.out.println ("Que dato quieres insertar Despues de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        System.out.println ("Despues de que dato quieres insertar el :"+DatoI);
                        DatoB = new Integer(Teclado.nextInt());
                        lista.insertarDespuesDe(DatoB,DatoI);
                        break;
                case 5: System.out.println ("Que dato quieres ELiminar de la Lista: ");
                        DatoB = new Integer(Teclado.nextInt());
                        lista.eliminarNodo(DatoB);
                        break;
                   case 6: System.out.println ("Que dato quieres buscar para sustituir: ");
                           DatoB = new Integer(Teclado.nextInt());
                           System.out.println ("Que dato quieres poner en el numero "+DatoB+":");
                           DatoI = new Integer(Teclado.nextInt());
                           lista.modificaLista(DatoB,DatoI);
                        break;
                   case 7: lista.despliegaLista();
                        break;
                case 8: System.out.println ("\tbye...\n");
                        break;                               
                default :System.out.println ("\topcion no valida intenta de nuevo\n");
            }
        }while (opcion != 8);
    }
}

ESO ES TODO COMPAÑEROS ASI QUE NO SEAN CABRAS Y COMENTEN DE PERDIDA PARA AGRADESER CABRONES!!!...