programas sencillos usando estructura de datos en java (colas, pilas, listas)

 Colas


Cola que almacena 10 numeros en vectory realiza funciones de dar de altas numeros introducidos, eliminar, mostrar ,salir.



import java.io.*;

public class Colas {
    public static class ClaseColas {  // Declaracion de la clase de Colas
         static int max=10;  // Tamano maximo de la Cola
         static int cola[]= new int[max]; // Declaracion del arreglo
         static int frente, fin; // Indicadores de inicio y fin de la Cola
       
         ClaseColas() { // Constructor que inicializa el frente y el final de la Cola
        frente=0;   fin=0;
        System.out.println("Cola inicializada !!!");
         }
       
         public static void Insertar(int dato) {
        if(fin==max) { // Esta llena la Cola?
       System.out.println("\nCola llena !!!");
        return;
        }
        cola[fin++]=dato;
        System.out.println("Dato insertado !!!");
         }
       
         public static void Eliminar() {
        System.out.println("\n\n<<< ELIMINAR >>>");
        if(frente==fin) {  // Esta vacia la Cola?
        System.out.println("\nCola vacia !!!");
        return;
        }
             System.out.println("Elemento eliminado: "+cola[frente++]);
         }
       
         public static void Mostrar() {
        int i=0;
        System.out.println("\n\n<<< MOSTRAR >>>");
        if(frente==fin)  System.out.println("\nCola vacia !!!");
        for(i=frente; i<fin; i++) {
        System.out.println("cola["+i+"]="+" "+cola[i]);
        }
        System.out.println("\nFrente= "+frente);
        System.out.println("Final = "+fin);
        System.out.println("Max  = "+max);
         }
    }
 
    static ClaseColas Cola=new ClaseColas();  // Declaracion del objeto Cola
 
    // Funcion principal
    public static void main(String args[]) throws IOException {
   int op=0;
   do {
        System.out.println("\n\n<<< COLAS >>>");
        System.out.println("1.- Altas");
        System.out.println("2.- Eliminar");
        System.out.println("3.- Mostrar");
        System.out.println("0.- Salir");
        System.out.print("Opcion? ---> ");
        op=getInt();
     
        switch(op) {
        case 1 : Altas();              break;
        case 2 : Cola.Eliminar(); break;
        case 3 : Cola.Mostrar();  break;
        }
   }while(op!=0);
    }
 
    public static void Altas() throws IOException {
   int elemento=0;
   System.out.println("\n\n<<< ALTAS >>>");
   System.out.print("Elemento a insertar? ---> ");
   elemento=getInt();
   Cola.Insertar(elemento); // Invocar el metodo Insertar del objeto Cola
    }
 
    // Funcion para capturar una cadena desde el teclado
     public static String getString() throws IOException {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String s = br.readLine();
            return s;
        }  
     
        // Funcion para capturar un entero desde el teclado
        public static int getInt() throws IOException {
            String s = getString();
            return Integer.parseInt(s);
        }  
}
------------------------------------------------------------------------------------------------------------



Cola circular


Cola que almacena 5 numeros y muestra el primero y el ultimo


import java.io.*;

public class ColaCircular {
   public static class ClaseColaCircular { // Declaracion de la clase de la Cola Circular
  static int max=5; // Tamano maximo de la Cola Circular
  static int colacirc[]=new int[max]; // Declaracion del arreglo para almacenar la Cola Circular
  static int frente, fin; // Inidicadores del inicio y final de la Cola Circular

  ClaseColaCircular() { // Constructor que inicializa el frente y el final de la Cola Circular
  frente=-1;    fin=-1;
  System.out.println("Cola circular inicializada !!!");
  }
  
  public static void Mostrar() {
  int i=0;
  System.out.println("\n\n<<< MOSTRAR COLA CIRCULAR >>>");
  if(frente==-1) {
  System.out.println("\nCola Circular vacia !!!");
  }
  else {
  i=frente;
  do {
          System.out.println("colacircssss["+i+"]="+colacirc[i]);
          i++;
          if(i==max && frente>fin) i=0; // Reiniciar en cero (dar la vuelta)
      }while(i!=fin+1);
      }
  
  System.out.println("frente="+frente);
  System.out.println("fin="+fin);
 
 
  System.out.println("max="+max);
  }
    
  public static void Insertar(int dato) {
  if((fin==max-1 && frente==0) || (fin+1==frente)) {
  System.out.println("\nCola Circular llena !!!");
  return;
  }
  if(fin==max-1 && frente!=0) fin=0; else fin++;
  colacirc[fin]=dato;
  if(frente==-1) frente=0;
  }
  
  public static void Eliminar() {
  System.out.println("\n\n<<< ELIMINAR DATO >>>");
  
  if(frente==-1) {
  System.out.println("Cola Circular vacia !!!");
  return;
  }
  System.out.println("Dato eliminado = "+colacirc[frente]);//elimina en el vector
  if(frente==fin) {                                    //el primer fuente
  frente=-1;   fin=-1; //si frente igual a fin vacios mostrar -1
  return;
  }
  if(frente==max) frente=0; else frente++;
  }
   }
   
   // Declaracion del objeto ColaCircular
   static ClaseColaCircular ColaCircular=new ClaseColaCircular();
   
   // Funcion principal
   public static void main(String args[]) throws IOException {
      int op=0;
      do {
              System.out.println("\n\n<<< COLAS CIRCULARES >>>");
              System.out.println("1.- Insertar");
              System.out.println("2.- Eliminar");
              System.out.println("3.- Mostrar");
              System.out.println("0.- Salir");
              
              System.out.print("Opcion? ---> ");
              op=getInt();
              switch(op) {
             case 1 : Altas();                           break;
             case 2 : ColaCircular.Eliminar();  break;
             case 3 : ColaCircular.Mostrar();   break;
              }
      }while(op!=0);
   }
   
   public static void Altas() throws IOException {
  int dato;
  System.out.println("\n\n<<< ALTAS >>>");
  System.out.print("Dato a insertar? ---> ");
  dato=getInt();
  ColaCircular.Insertar(dato); //Invocar el metodo Insertar del objeto ColaCircular
   }
   
   // Funcion para capturar una cadena desde el teclado
       public static String getString() throws IOException {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String s = br.readLine();
            return s;
        }    
        
        // Funcion para capturar un entero desde el teclado
        public static int getInt() throws IOException {
            String s = getString();
            return Integer.parseInt(s);
        }    
}
------------------------------------------------------------------------------------------------------------


pila


pila que almacena 10 numeros con funciones pop, push,mostrar, salir.


import java.io.*;

public class Pilas {
public static class ClasePila {   // Declaracion de la clase de la Pila
private int max=10;   // Tamano maximo de la pila
private int pila[] = new int [max];   // Arreglo para almacenar la pila
private int top;  // Indica la cantidad de datos en la pila

public ClasePila() {   // Constructor
top=0;
System.out.println("Pila creada !!!");
}
        public void Push(int dato) {
       if(top==max)  // Esta llena la Pila?
       {
       System.out.println("Pila llena !!!");
       return;
       }
       for(int i=0; i<top; i++) {
       if(pila[i]==dato) { // Ya existe el dato?
       System.out.println("Duplicado !!!");
       return;
       }
       if(dato<pila[i]) {  // Alta al principio o intermedia
         for(int j=top;j>i;j--)
           pila[j]=pila[j-1];
         pila[i]=dato;  
         top++;
         System.out.println("Dato insertado al principio o intermedio !!!");
         return;
           }  
       }
       pila[top++]=dato; // Alta al final
       System.out.println("Dato insertado al final !!!");
       return;
   } 
   public void Pop(int dato) {   
   if(top==0) { // Esta vacia la Pila?
   System.out.println("Pila vacia !!!");
   return;
   }
   for(int i=0;i<top;i++) {
     if(pila[i]==dato) { 
       for(int j=i; j<top-1; j++)
          pila[j]=pila[j+1];
       top--;
       System.out.println("Dato eliminado !!!");
       return;
         }  
       }
       System.out.println("Dato inexistente !!!");
   }
   
   public void Mostrar() {
   System.out.println("\n\n<<< MOSTRAR LA PILA >>>");
   if(top==0) System.out.println("Pila vacia !!!");
   for(int i=0;i<top;i++)
        System.out.println("pila["+i+"]="+pila[i]);
   System.out.println("top="+top);  
   System.out.println("max="+max);
   }
    }    

    
    static ClasePila Pila=new ClasePila();  // Declaracion del objeto Pila
    
    // Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
  op=0;
 System.out.println("\n\n<<< PILAS >>>");
 System.out.println("1.-Push");
 System.out.println("2.-Pop");
 System.out.println("3.-Mostrar Pila");
 System.out.println("0.-Salir");
 
 //op=Integer.parseInt(JOptionPane.showInputDialog("Opcion? "));
 System.out.print("Opcion? ---> ");
 op=getInt();
     switch(op) {
    case 1 : Altas();                break;
    case 2 : Bajas();               break;
    case 3 : Pila.Mostrar();     break;
     }
}while(op!=0);
     }

     public static void Altas() throws IOException {
    int dato=0;
    System.out.println("\n\n<<< ALTAS >>>");
    System.out.print("\nAnote el dato que desea insertar ---> ");
    dato=getInt();
    Pila.Push(dato);  // Invocar el metodo Push del objeto Pila
     }
     
     public static void Bajas() throws IOException {
    int dato=0;
    System.out.println("\n\n<<< BAJAS >>>");
    System.out.print("\nAnote el dato que desea eliminar ---> ");
    dato=getInt();
    Pila.Pop(dato); // Invocar el metodo Pop del objeto Pila
     }
     
     // Funcion para capturar una cadena desde el teclado
      public static String getString() throws IOException {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String s = br.readLine();
            return s;
        }    
        
        // Funcion para capturar un entero desde el teclado
        public static int getInt() throws IOException {
            String s = getString();
            return Integer.parseInt(s);
        }
}
------------------------------------------------------------------------------------------------------------


Listas

import java.io.*;
public class Listas {
public static class ClaseListas { // Declaracion de la clase de Listas
static char dato[]=new char[100]; //Declaracion del arreglo para los datos de tipo char
static int sn[]=new int[100]; //Declaracion del arreglo para el indicador del sig. nodo
static int apui, top; // Apuntador inicial y Cantidad de datos en la Lista
ClaseListas() { // Constructor de la ClaseListas
apui=-1;
top=0;
System.out.println("Lista enlazada inicializada !!!");
System.out.println("apui="+apui);
System.out.println("top  ="+top);
}
public static void Mostrar() {
int i=0;
System.out.println("\n\n<<< MOSTRAR ESTRUCTURA >>>");
if(apui==-1) System.out.println("\nLista enlazada vacia !!!\n");
System.out.println("posicion  dato       sn");
System.out.println("---------------------------");
for(i=0;i<top;i++) {
System.out.println(i+"       |   "+dato[i]+"      |   "+sn[i]);
}
System.out.println("\napui="+apui);
System.out.println("top="+top);
}
public static void Insertar(char elemento) {
int i=0, ant=0;
if(apui==-1) { //Alta en Lista vacia
System.out.println("Insertar dato en lista vacia ...");
apui=top;
dato[top]=elemento;
sn[top]=-1;
top++;
return;
}
i=apui;
do {
   if(dato[i]==elemento) {
   System.out.println("Duplicado !!!");
   return;
   }
   if(elemento<dato[i]) {
   if(i==apui) { //Alta al principio
   System.out.println("Insertando el dato menor de todos ...");
   dato[top]=elemento;
   sn[top]=apui;
   apui=top;
   top++;
   return;
   } else {
   System.out.println("Alta intermedia ...");
   dato[top]=elemento;
   sn[top]=sn[ant];
   sn[ant]=top;
   top++;
   return;
   }
   }
   ant=i;
   i=sn[i];
}while(i!=-1);
System.out.println("Alta al final ...");
dato[top]=elemento;
sn[top]=-1;
sn[ant]=top;
top++;
return;
}
}
// Declaracion del objeto Lista
static ClaseListas Lista=new ClaseListas();
//Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
   System.out.println("\n\n<<< LISTAS ENLAZADAS >>>");
   System.out.println("1.- Altas");
   System.out.println("2.- Mostrar estructura");
   System.out.print("Opcion? ---> ");
   op=getInt();
   switch(op) {
   case 1 : Altas(); break;
   case 2 : Lista.Mostrar();  break;
   }
}while(op!=0);
}
public static void Altas() throws IOException {
char dato;
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("Dato a insertar ---> ");
dato=getChar();
Lista.Insertar(dato); //Invocar el metodo Insertar del objeto Lista
}
//Funcion para capturar una cadena desde el teclado
      public static String getString() throws IOException {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String s = br.readLine();
            return s;
        }  
     
        // Funcion para capturar un entero desde el teclado
        public static int getInt() throws IOException {
            String s = getString();
            return Integer.parseInt(s);
        }  
        //Funcion para capturar un caracter desde el teclado
        public static char getChar() throws IOException {
       String s=getString();
       return s.charAt(0);
        }
}
------------------------------------------------------------------------------------------------------------



Lista encadenada



import java.io.*;

public class Listas_Objetos {
public static class ClaseLista {
   public static class ClaseNodo {
    char dato;  // Dato del nodo (NO debe declararse "static")
    ClaseNodo sn;   // Apuntador al siguiente nodo (NO debe declararse "static")
   }
static ClaseNodo inicial;
public static void Inicializar() {
inicial=new ClaseNodo();
inicial=null;
}
public static void Eliminar(char d) throws IOException {
ClaseNodo i=inicial, anterior=i;
if(i==null) {
System.out.println("Lista vacia !!!");
getch();
return;
}
while(i!=null) {
if(d==i.dato) {
if(i==inicial) {
inicial=i.sn;
System.out.println("\nBaja al principio...");
getch();
return;
}
anterior.sn=i.sn;
System.out.println("\nBaja intermedia o al final ...");
getch();
return;
}
anterior=i;
i=i.sn;
}
System.out.println("\nNo existe ese dato !!!");
getch();
return;
}
public static void Insertar(char d) throws IOException {
ClaseNodo i=inicial, nuevo_nodo, anterior=i;
if(i==null) {
nuevo_nodo=new ClaseNodo();
nuevo_nodo.dato=d;
nuevo_nodo.sn=null;
inicial=nuevo_nodo;
System.out.println("\nAlta a lista vacia...");
getch();
return;
}
while(i!=null) {
if(d==i.dato) {
System.out.println("\nDuplicado !!!");
getch();
return;
}
if(d<i.dato) {
if(i==inicial) {
nuevo_nodo=new ClaseNodo();
nuevo_nodo.dato=d;
nuevo_nodo.sn=inicial;
inicial=nuevo_nodo;
System.out.println("\nAlta al principio...");
getch();
return;
}
nuevo_nodo=new ClaseNodo();
nuevo_nodo.dato=d;
nuevo_nodo.sn=anterior.sn;
anterior.sn=nuevo_nodo;
System.out.println("\nAlta intermedia...");
getch();
return;
}
anterior=i;
i=i.sn;
}
nuevo_nodo=new ClaseNodo();
nuevo_nodo.dato=d;
nuevo_nodo.sn=null;
anterior.sn=nuevo_nodo;
System.out.println("\nAlta al final...");
getch();
return;
}
public static void Recorrido() throws IOException {
ClaseNodo i=inicial;
clrscr();
System.out.println("\n<<< RECORRIDO DE UNA LISTA ENCADENADA >>>\n\n");
if(i==null) {
System.out.println("\nLista vacia");
}
while(i!=null) {
System.out.print(i.dato+"->");
i = i.sn;
}
System.out.println("null");
getch();
}
}
static ClaseLista Lista=new ClaseLista(); // Declaracion global del objeto Lista
public static void main(String args[]) throws IOException {
int op=0;
Lista.Inicializar(); // Inicializar la Lista Enlazada
do {
  clrscr();
  System.out.println("\n\n<<< LISTAS ENCADENADAS CON OBJETOS >>>");
  System.out.print("\n1.- Altas");
  System.out.print("\n2.- Bajas");
  System.out.print("\n3.- Recorrido");
  System.out.print("\n0.- Salir");
  System.out.print("\nOpcion? ---> ");
  op=getInt();
  
  switch(op) {
  case 1 : Altas();                 break;
  case 2 : Bajas();                break;
  case 3 : Lista.Recorrido(); break;
  }
  
}while(op!=0);
}
public static void Bajas() throws IOException {
char dato;
clrscr();
System.out.println("\n<<< BAJAS >>>");
System.out.print("\nAnote el dato a eliminar ---> ");
dato=getChar();
Lista.Eliminar(dato);
}
public static void Altas() throws IOException {
char dato;
clrscr();
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("\nAnote el dato a insertar ---> ");
dato=getChar();
Lista.Insertar(dato);
}
public static void clrscr() {
for(int i=0;i<26;i++)
 System.out.println(" ");
}

//Funcion para capturar una cadena desde el teclado
      public static String getString() throws IOException {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String s = br.readLine();
            return s;
        }    
        
        // Funcion para capturar un entero desde el teclado
        public static int getInt() throws IOException {
            String s = getString();
            return Integer.parseInt(s);
        }    

        //Funcion para capturar un caracter desde el teclado
        public static char getChar() throws IOException {
       String s=getString();
       return s.charAt(0);
        }

        // Rutina para hacer una pausa
        public static void getch() throws IOException {
       String s;
       System.out.print("\n<<< Oprima cualquier tecla para continuar >>>");
       s=getString();
       return;
        }
 }


------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------



Lista simple en java

primero hacer clase Nodo

class Nodo{ 
 int numero; 
 Nodo sgte; 
 Nodo(int x){ 
 numero = x; 
 sgte = null; 
 } 
}

despues hacer clase ListaSimple

class ListaSimple { 
 
 private Nodo primero; 
 private int numNodos; 
 
 ListaSimple(){ 
 primero = null; 
 numNodos = 0; 
 } 
 
 public void insertarNodo (int pos, int n){ 
 Nodo num = new Nodo (n); 
 if((pos > 0) && (pos <= (numNodos+1))){ 
 if(pos == 1){ 
 if(primero == null) 
 primero = num; 
 if(primero != null){ 
 num.sgte = primero; 
 primero = num; 
 } 
 numNodos++;     
 }else if(pos > 1){ 
 if(pos < (numNodos+1)){ 
 Nodo mov = primero; 
 int i; 
 for(i=2; i < pos; i++) 
 mov = mov.sgte; 
 num.sgte = mov.sgte; 
 mov.sgte = num; 
 } 
 
 if(pos == (numNodos+1)){ 
 Nodo mov = primero; 
 int i; 
 for(i=2; i < pos; i++) 
 mov = mov.sgte; 
 mov.sgte = num; 
 } 
 numNodos++; 
 } 
 }else 
 System.out.println("[Insertar]>Nodo no Existe"); 
 
 } 
 public void insertarCabezalista (int x){ 
 Nodo aux = new Nodo (x); 
 if(primero == null) 
 primero = aux; 
 else{ 
 aux.sgte = primero; 
 primero = aux; 
 } 
 numNodos++; 
 } 
 
 public void insertarFinalLista (int x){ 
 Nodo nuevo = new Nodo (x); 
 if (primero == null){ 
 primero = nuevo; 
 }else{ 
 Nodo aux = primero; 
 while(aux.sgte != null) 
 aux = aux.sgte; 
 aux.sgte = nuevo; 
 }     
 numNodos++; 
 } 
 
 public void eliminarNodoP (int pos){ 
 Nodo elim = primero;  
 if(elim == null) //Cuando la lista esta vacia. 
 System.out.println("[Eliminar]>Lista Vacia"); 
 else if((pos>0) && (pos<=numNodos)){ 
 if(pos == 1){ 
 if(numNodos == 1){ //Cuando se tiene que eliminar el primer Nodo(numNodos==1). 
 primero = null; 
 numNodos = 0; 
 } 
 if(numNodos > 1){ //Cuando se tiene que eliminar el primer Nodo(numNodos>1). 
 primero = elim.sgte; 
 numNodos--;     
 } 
 }else if(pos > 1){ //Cuando se tiene que eliminar un Nodo que no es el Primero. 
 int i; 
 for(i=2; (elim != null) && (i < pos); i++) 
 elim = elim.sgte; 
 elim.sgte = elim.sgte.sgte; 
 numNodos--; 
 } 
 
 }else 
 System.out.println("[Eliminar]>Nodo no Existe"); 
 
 } 
 
 public void eliminarTodo(){ 
 numNodos = 0; 
 primero = null; 
 } 
 
 public void eliminarPrimero(){ 
 Nodo prim = primero; 
 
 if(numNodos == 1) 
 primero = null; 
 else{ 
 primero = prim.sgte; 
 prim.sgte = prim.sgte.sgte;     
 } 
 
 System.out.println("Primero Nodo borrado con exito"); 
 numNodos--; 
 } 
 
 public void eliminarUltimoNodo(){ 
 if(primero != null) 
 primero = null; 
 else{ 
 Nodo aux = primero; 
 while(aux.sgte.sgte != null) 
 aux = aux.sgte; 
 aux.sgte = null; 
 }     
 } 
 
 public Nodo mostrarUltimoNodo(){ 
 if(primero != null){ 
 Nodo aux = primero; 
 while(aux.sgte != null) 
 aux = aux.sgte; 
 return aux; 
 } 
 return null; 
 } 
 
 public Nodo mostrarNodoAnterior(Nodo p){ 
 if(primero == p) 
 return null; 
 else{ 
 Nodo aux = primero; 
 while(aux.sgte != p) 
 aux = aux.sgte; 
 return aux; 
 } 
 } 
 
 public void reemplazarNodo(int pos, int n){ 
 int i; 
 if((pos0)){ 
 Nodo aux = primero; 
 for(i=1; (aux != null) && (i < pos); i++) 
 aux = aux.sgte; 
 aux.numero = n; 
 }else 
 System.out.println("[Reemplazar]>Nodo no Existe"); 
 } 
 
 public int contadorNodos (){ 
 return numNodos; 
 /* 
 Nodo count = primero; 
 int i=0; 
 while(count != null){ 
 count = count.sgte; 
 i++; 
 } 
 return i; 
 */ 
 } 
 
 public void mostrarLista(){ 
 Nodo aux = primero; 
 int i=1; 
 System.out.println("- Mostrar -"); 
 while(aux != null){ 
 System.out.println("Nodo Nº "+i+": "+aux.numero); 
 aux=aux.sgte; 
 i++; 
 } 
 } 
 
 public void mostrarListaInversa(){ 
 Nodo mov = primero; 
 int i, j; 
 //La idea fundamental es que siempre se muestre el ultimo Nodo 
 //Decrementando el limite en cada ciclo. 
 System.out.println("- Mostrar Inverso-"); 
 for(i=numNodos; i>0; i--){  
 for(j=1; j
 mov = mov.sgte; 
 } 
 System.out.println("Nodo Nº "+i+": "+mov.numero); 
 mov = primero; 
 } 
 
 } 
 
 public Nodo retornaNodo (int pos){ 
 Nodo mov = primero; 
 int i; 
 if((pos  numNodos)) 
 pos = 1; 
 for(i=1; i
 mov = mov.sgte; 
 return mov; 
 } 
 
 public void eliminarNodoN (Nodo pos){ 
 Nodo elim = primero; 
 Nodo ult = mostrarUltimoNodo(); 
 
 if(elim == null) 
 System.out.println("Lista Vacia"); 
 else if(pos == elim){ 
 primero = primero.sgte; 
 }else{ 
 while(((pos != elim.sgte) && (elim != null))) 
 elim = elim.sgte; 
 if(elim.sgte != null) 
 elim.sgte = elim.sgte.sgte; 
 else 
 System.out.println("Nodo no Existe"); 
 } 
 numNodos--; 
 } 
 
 public void mostrarInvertidoR (Nodo f){ 
 if(f.sgte != null){     
 oAsc(f.sgte); 
 } 
 System.out.println(f.numero); 
 } 
 /* 
 public void oAsc (Nodo f){ 
 if(f.sgte != null){     
 if(f.numero > f.sgte.numero) 
 System.out.println("No ASC"); 
 else 
 oAsc(f.sgte); 
 }else 
 System.out.println("ASC"); 
 } 
 */ 
 public boolean oAsc (Nodo f){ 
 if(f.sgte != null){ 
 boolean status; 
 status = oAsc(f.sgte); 
 if(f.numero > f.sgte.numero) 
 return false; 
 else 
 return status; 
 }else 
 return true; 
 } 
 
 public void insertarNumListaOrd (int n){    // Considerando que una lista esta ordenada  
 Nodo num = new Nodo (n);                // en forma ASC agregue un Nodo manteniendo el orden 
 Nodo i = primero; 
 while((n > i.numero) && (i.sgte != null)) 
 i = i.sgte; 
 if(n <= primero.numero){ 
 num.sgte = primero; 
 primero = num; 
 numNodos++; 
 }else if (n <= i.numero){ 
 num.sgte = i; 
 mostrarNodoAnterior(i).sgte = num; 
 numNodos++;     
 }else{ 
 i.sgte = num; 
 numNodos++; 
 } 
 
 } 
 
 public void eliminarNodosR (){    // Eliminar los nodos que tengan numeros repetidos 
 Nodo i, j; 
 for(i = primero; i != null; i = i.sgte){ 
 for(j = i.sgte; j != null; j = j.sgte){ 
 if(i.numero == j.numero){ 
 mostrarNodoAnterior(j).sgte = j.sgte; 
 numNodos--; 
 } 
 } 
 } 
 } 
 
 
}

por ultimo esta principal clase EjemploListaSimple

public class EjemploListaSimple { 
 
 public static void main(String[] args) { 
 ListaSimple p = new ListaSimple(); 
 
 //p.insertarCabezalista(1); 
 //p.insertarCabezalista(5); 
 //p.insertarCabezalista(7); 
 //p.insertarFinalLista(6); 
 //p.insertarFinalLista(4); 
 p.insertarNodo(1,2); 
 p.insertarNodo(2,4); 
 p.insertarNodo(3,6); 
 p.insertarNodo(4,8); 
 
 System.out.println("Nodos Existentes: "+p.contadorNodos()); 
 p.mostrarLista(); 
 
 if(p.oAsc(p.retornaNodo(0))){ 
 p.insertarNumListaOrd(1); 
 p.insertarNumListaOrd(3); 
 p.insertarNumListaOrd(5); 
 p.insertarNumListaOrd(7); 
 p.insertarNumListaOrd(9); //metodo util sòlo si la lista esta ordenada ASC 
 } 
 //p.eliminarNodo(2); 
 
 if(p.oAsc(p.retornaNodo(0))) 
 System.out.println("ASC"); 
 if(!p.oAsc(p.retornaNodo(0)))     
 System.out.println("NO ASC"); 
 
 //p.eliminarNodoN(p.retornaNodo(1)); 
 
 p.eliminarNodosR(); 
 
 System.out.println("Nodos Existentes: "+p.contadorNodos()); 
 p.mostrarLista(); 
 p.mostrarListaInversa(); 
 } 
} 


DESCARGAR ABAJO LOS PROGRAMAS, COLAS, COLA CIRCULAR, PILA, LISTAS, LISTA ENCADENADA:







Cola lineal

El siguiente programa utiliza estructura de datos, lógica, y manejo de ventanas swing sencillas, usa la técnica FIFO, y metodos  gets y sets.
Hacer un programa en java que dado cualquir numero de paises se almacenen, y tenga funcion de agregar pais, eliminar pais, mostrar y salir.
Para que funcione recuerda que solo tienes que correr (Run) la clase principal que contiene el  public static void main(String []args)

Primera clase con metodos get y sets:

class pais{
private String nombre;
private String capital;
private int habitantes;

public pais(String n, String c, int h){
nombre=n;
capital=c;
habitantes=h;
}

public pais(){
}


public void setNombre(String n){
nombre=n;
}

public void setCapital(String c){
capital=c;
}

public void setHabitantes(int h){
habitantes=h;
}

public String getNombre(){
return nombre;
}

public String getCapital(){
return capital;
}

public int getHabitantes(){
return habitantes;
}
}



Segunda clase con la logica y estructura FIFO:


import javax.swing.*;
public class paises {
private pais p[];
private int i;

public void Imp(String Men){
JOptionPane.showMessageDialog(null, Men);
}

    public paises(int tamano){
  p= new pais[tamano];
i=-1;
    }
 
    public boolean free(){
    return i==-1;
    }
 
    public boolean full(){
    return i==p.length-1;
    }

// Este método inserta al final de arreglo mientras este no este lleno
    public void AgregarPais(pais np){
if(!full()){
i++;
p[i]=np;
}
    }
 
    // Este método elimina el último país insertado
    public void EliminaPais(){
if(!free()){
ImpPais(p[i]);
i--;
Imp("País eliminado");
}
    }
 
    public void ImpPais(pais PI){
    Imp("Nombre: "+PI.getNombre()+"\n"+
    "Capital: "+PI.getCapital()+"\n"+    
    "Habitantes: "+PI.getHabitantes());
    }

// Imprime los paises del vector
public void Imprime(){
if(free())
Imp("no hay paises capturados");
else{
int R=0;
do
ImpPais(p[R++]);
while(R<=i);
}
}

}

Tercera clase:

import javax.swing.*;

public class principal {
  private static paises p;

  public static int LeeInt(String Men){
  return Integer.parseInt(JOptionPane.showInputDialog(Men));
  }

  public static String LeeCad(String Men){
  return JOptionPane.showInputDialog(Men);
  }

  public static void crearVector(){
    p=new paises(LeeInt("Dar numero paises que se controlan en el vector"));
  }

  public static pais capturaRegistro(){
    pais regNue=new pais();
    regNue.setNombre(LeeCad("Dar Nombre:"));
    regNue.setCapital(LeeCad("Dar Capital:"));
    regNue.setHabitantes(LeeInt("Dar No. habitantes:"));
    return regNue;
  }

  public static void addPais(){
    if(p.full())
      JOptionPane.showMessageDialog(null, "Vector Lleno...");
    else{
      pais a=capturaRegistro();
      p.AgregarPais(a);
      p.Imp("Registro almacenado...");
    }
  }

  public static void Elimina(){
  if(p.free())
  p.Imp("Vector vacio...");
  else
  p.EliminaPais();
  }

  public static void run(){
    int opc;
    crearVector();
    do{
      opc=Opcion();
      switch(opc){
        case 1: addPais(); break;
        case 2: Elimina(); break;
        case 3: p.Imprime(); break;
        //case 4: p.modificar(); break;
        //case 5: p.buscar(); break;
      }
    }while(opc!=4);
  }
 
  public static int Opcion(){
  String cad="Menu \n\n";
    cad=cad+"1.- Agregar Pais\n";
    cad=cad+"2.- Eliminar Pais\n";
    cad=cad+"3.- Listar Paises\n";
    //cad=cad+"4.- Modificar\n";
    //cad=cad+"5.- Buscar\n";
    cad=cad+"4.- Salir\n";
    return LeeInt(cad);
  }

    public static void main(String []args){
      run();
      System.exit(0);
    }

}  

DESCARGAR PROGRAMA COLA LINEAL:

No hay comentarios:

Publicar un comentario en la entrada