Colas

COLAS

Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.
Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazada.

EJEMPLO 1:

package colasoperaciones;
import java.util.*;
public class Cola {
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);
ColaGenerica obj = new ColaGenerica();
int op;
int num;
do{
menu();
op = leer.nextInt();
switch(op){
case 1:
System.out.println( "Numero a insertar" );
num = leer.nextInt();
if(obj.inscola(num)){
System.out.println( "fre"+obj.fre+"fin"+obj.fin+"aux"+obj.max );
System.out.println( "El numero "+num+" se inserto en la cola ["+obj.dret+"]" );
System.out.println();
}
else{
System.out.println( "Cola llena" );
}
break;
case 2:
if(obj.retcola()){
System.out.println( "El dato retirado fue: "+obj.dret );
}
else{
System.out.println( "Cola vacia" );
}
break;
//case 3:
// if(obj.fre==-1; obj.fin==-1){
//System.out.println( "Cola vacia" );
//}
//else {
// for(int i=obj.fre; i++){
// System.out.print(obj.c[i]+" ");
}
break;
}
while(op != 4);
}
public static void menu(){
System.out.println( "\t Menu para colas \n" );
System.out.println( "1.- Insertar" );
System.out.println( "2.- Retirar" );
System.out.println( "3.- Estado" );
System.out.println( "4.- Fin" );
System.out.println( "\n Selecciona" );
}
}

EJEMPLO 2:

package colasoperaciones;
class ColaGenerica
{
public int max;
protected Object dret;
public Object c[];
public int fre = -1;
public int fin = -1;
public ColaGenerica()
{
max=20;
c=new Object [max];
}
public ColaGenerica(int n)
{ max=n;
c=new Object [max];
}
public boolean colallena(int fin,int max)
{
boolean llena;
if (fin==max-1)
llena=true;
else
llena=false;
return llena;
}
public boolean colavacia(int fre)
{
boolean vacia;
if (fre==-1)
vacia=true;
else
vacia=false;
return vacia;
}
public boolean inscola(Object dato)
{
if (fin==max-1)
return false;
fin++;
c[fin] = dato;
if (fin==0)
fre=0;
return true;
}
public boolean retcola()
{
if (fre ==-1)
return false;
dret=c[fre];
if (fre==fin)
{
fre=-1;
fin=-1;
}
else
fre++;
return true;
}
}

EJEMPLO 3:

package cola;
import java.io.*;
//Declaramos la clase calculatorTest
public class ejecutar_cola{
//Declaramos el metodo principal
public static void main (String args[])throws IOException {
BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in));
int Espacios = 0;
char Resp, op;
String aux;
//--- Imprimir Menu ---- \\
System.out.println("\n :: XROM RELOADED :: 19/07/07 \n");
System.out.print("\t Cuantos espacios quiere en la Cola (entre 3 y 30 recomendable)? :");
Espacios = Integer.parseInt(entrada.readLine());
ejecutar_cola x = new ejecutar_cola(Espacios);
//--- Imprimir Menu ---- \\
System.out.println("\n\n\t ------------ //-------- Menu Cola Simple --------\\\\------------ \n ");
do {
System.out.println("\n\n1.- Imprimir Cola"); // Mostrar
System.out.println("2.- Agregar Elemento a la Cola"); // Push
System.out.println("3.- Quitar Elemento de la Cola"); // Pop
System.out.print("\n\n Elija una Opcion : ");
aux = entrada.readLine();
op = aux.charAt(0);
//---- Elegir opcion ---\\
switch (op) {
case '1':
x.Imprimir();
break;
case '2':
Ejecutar.Push();
break;
case '3':
Ejecutar.Pop();
break;
default:
System.out.println("opcion fuera de rango !!");
} // Fin del switch
System.out.print("Desea hacer otra operacion ?? S / N ");
aux = entrada.readLine();
Resp = aux.charAt(0);
} while (Resp == 'S' Resp == 's');
} // Fin del metodo main
} // Fin de la calse

Pilas

PILAS

Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.
Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarla.

EJEMPLO 1:

package pila;
import java.io.*;

public class Pila{
public static BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
public static final int MAX_LENGTH = 5;
public static String Pila[] = new String[MAX_LENGTH];
public static int cima = -1;


public static void main(String args[])throws IOException{

Menu();
}
public static void Menu()throws IOException{
System.out.println("\n\n\t\t\t=========Menu Manejo Pila=============");
System.out.println("\t\t\t= =");
System.out.println("\t\t\t= 1- Insertar elemento =");
System.out.println("\t\t\t= 2- Eliminar elemento =");
System.out.println("\t\t\t= 3- Buscar elemento =");
System.out.println("\t\t\t= 4- Imprimir pila =");
System.out.println("\t\t\t= 5- Actualizar valor en pila =");
System.out.println("\t\t\t= 6- Salir =");
System.out.println("\t\t\t======================================");
System.out.print("\t\t\tOpcion: ");
int op = Integer.parseInt(entrada.readLine());
Opciones(op);

}
public static void Opciones(int op)throws IOException{
switch(op){
case 1: Insertar();
break;
case 2: Eliminar();
break;
case 3: Buscar();
break;
case 4: Imprimir();
break;
case 5: Actualizar();
break;
case 6: System.exit(1);
break;
default:Menu();
break;
}
}
public static void Insertar()throws IOException{

System.out.print("\nDigite algo para la pila: ");
String dato = entrada.readLine();
Crear(dato);
}
public static void Crear(String dato)throws IOException{
if ((Pila.length-1)==cima){
System.out.println("Capacidad de la pila al limite\n\n\n");
Imprimir();
}else{
++cima;
}
Agregar(dato);
}
public static void Agregar(String dato)throws IOException{
Pila[cima]=dato;
Menu();
}
public static void Imprimir()throws IOException{
for(int i=Pila.length-1;i>=0;i--){
System.out.println(Pila[i]);
}
Menu();
}
public static void Eliminar()throws IOException{
if(cima== -1){
System.out.println("\n\n\nNo se puede eliminar, pila vacia !!!" );
}else{
Pila[cima] = null;
--cima;
}
Menu();
}
public static void Buscar()throws IOException{
System.out.println("\n\n\nDigite la cadena a buscar: ");
String cad = entrada.readLine();
for(int i=0;iif(cad.equals(Pila[i])){
System.out.println("Elemento encontrado,posicion "+i);
break;
}else{
System.out.println("Elemento no encontrado :(");
}
}
Menu();
}
public static void Actualizar()throws IOException{
System.out.print("Digite el nombre del valor que desea actualizar: ");
String actual = entrada.readLine();
System.out.print("Digite el nombre del nuevo valor: ");
String nuevo = entrada.readLine();
for(int i=0;iif(actual.equals(Pila[i])){
Pila[i]=nuevo;
break;
}else{
System.out.println("Elemento no encontrado :(");
}
}
Menu();
}
}

EJEMPLO 2:

package bolitas;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
public class Bolita {
private int x;
private int y;
private JPanel panel;
private Color color;
public Bolita(Color col, JPanel panel2) {
color = col;
panel = panel2;
}
public void modPos(int x_, int y_){
x = x_;
y = y_;
}
public void paint (Graphics g){
g = panel.getGraphics();
g.setColor(color);
g.fillOval(x,y,20,20);
}
public void setXORMode( Graphics g ){
g = panel.getGraphics();
g.fillOval(x,y,20,20);
g.clearRect(x, y, 20, 20);
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
}



package bolitas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.WindowConstants;
import javax.swing.SwingUtilities;
public class InterfazPilaDeBolitas extends javax.swing.JFrame implements ActionListener{
private static final long serialVersionUID = 1L;
private JButton apilar;
private static JPanel panel;
private JButton desapilar;
private PilaDeBolitas p;
private static Graphics g=null;
{
//Set Look & Feel
try {
javax.swing.UIManager.setLookAndFeel(javax.swing.UIManager.getSystemLookAndFeelClassName());
} catch(Exception e) {
e.printStackTrace();
}
}
public void paint(Graphics g) {
super.paint(g);
p.paint(g);
}
/**
* Auto-generated main method to display this JFrame
*/
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
InterfazPilaDeBolitas inst = new InterfazPilaDeBolitas();
inst.setLocationRelativeTo(null);
inst.setVisible(true);
}
});
}
public InterfazPilaDeBolitas() {
super();
initGUI();
p= new PilaDeBolitas();
}
private void initGUI() {
try {
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
getContentPane().setLayout(null);
{
apilar = new JButton();
getContentPane().add(apilar);
apilar.setText("Apilar");
apilar.setBounds(56, 230, 167, 43);
apilar.addActionListener(this);
}
{
desapilar = new JButton();
getContentPane().add(desapilar);
desapilar.setText("Desapilar");
desapilar.setBounds(340, 230, 167, 43);
desapilar.addActionListener(this);
}
{
panel = new JPanel();
getContentPane().add(panel);
panel.setBounds(41, 28, 467, 168);
}
pack();
this.setSize(566, 335);
} catch (Exception e) {
e.printStackTrace();
}
}
public void actionPerformed(ActionEvent v) {
if(v.getSource()==apilar){
try{
Bolita b = new Bolita(Color.red, panel);
p.apilar(b);
b.paint(g);
}
catch(PilaDeBolitas.OverFlowException e2){
JOptionPane.showMessageDialog(null, "La pila ya se lleno", "OverFlowException",JOptionPane.WARNING_MESSAGE);
try{
panel.paint(g);
}catch(Exception e){
}
}
}
else if (v.getSource()==desapilar) {
try{
Bolita r = p.desapilar();
r.setXORMode(g);
}
catch(Exception e2){
JOptionPane.showMessageDialog(null, "La pila esta vacia", "OverFlowException",JOptionPane.WARNING_MESSAGE);
try{
panel.repaint();
}catch(Exception e){
}
}
}
}
}

package bolitas;
import java.awt.*;
public class PilaDeBolitas {
private static final long serialVersionUID = 1L;
public static final int MAX = 10;
public class UnderFlowException extends Exception{
private static final long serialVersionUID = -9026952799388596808L;
}
public class OverFlowException extends Exception{
private static final long serialVersionUID = -5485402241073047658L;
}
// Atributos
private Bolita [] bolitas; // Arreglo que contiene los elementos
private int tope;
public int getTope() {
return tope;
}
public void paint(Graphics g) {
for(int i = 0; i < tope; i++){
bolitas[i].paint(g);
}
}
public void setXORMode(Graphics g) {
for(int i = 0; i < tope; i++){
bolitas[i].setXORMode(g);
}
}
public Bolita getTopeBolita(){
return bolitas[getTope()];
}
public PilaDeBolitas(){
//super("SUPER PAINT",false,false,false,false);
bolitas = new Bolita [MAX];
tope = 0;
}
public void apilar(Bolita b) throws OverFlowException{
if(tope + 1 >= MAX){
throw new OverFlowException();
}
if(tope==-1){
tope = 0;
}
bolitas[tope] = b;
tope++;
b.modPos(tope * 20 + 40, 100);
}
public Bolita desapilar() throws UnderFlowException {
if(tope + 1 < 0){
throw new UnderFlowException();
}
Bolita c;
tope--;
c = bolitas[tope];
while(c.getX()==-40){
c.modPos(-(tope*20+40),100);
break;
}
return c;
}
}

EJEMPLO 3:

package piladinero;
import java.io.*;
public class Dineroc {
public static void main(String[] args) throws IOException{
int b200,b100,b50,b20,b10,m5,m2,m1,n,r;
String cad="";
InputStreamReader dsf;
BufferedReader buffer;
dsf=new InputStreamReader(System.in);
buffer=new BufferedReader(dsf);
System.out.print("INGRESE CANTIDAD DE DINERO:");
cad=buffer.readLine();
n=Integer.parseInt(cad);
b200=n/200;
r=n%200;
b100=r/100;
r=r%100;
b50=r/50;
r=r%50;
b20=r/20;
r=r%20;
b10=r/10;
r=r%10;
m5=r/5;
r=r%5;
m2=r/2;
r=r%2;
m1=r/1;
r=r%1;
System.out.println("Billete de 200 :"+b200);
System.out.println("Billete de 100:"+b100);
System.out.println("Billete de 50:"+b50);
System.out.println("Billete de 20 :"+b20);
System.out.println("Billete de 10:"+b10);
System.out.println("moneda de 5:"+m5);
System.out.println("moneda de 2:"+m2);
System.out.println("moneda de 1:"+m1);
}
}

Listas

Lista (estructura de datos)


En Ciencias de la Computación, una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior y/o posterior. El principal beneficio de las listas enlazadas respecto a los array convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.
Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminación de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto está previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares.
Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales como Lisp y Scheme tiene estructuras de datos ya construidas, junto con operaciones para acceder a las listas enlazadas. Lenguajes imperativos u orientados a objetos tales como C o C++ y Java, respectivamente, disponen de referencias para crear listas enlazadas.

Operaciones con listas simples en java

package listas;
//operaciones para listas simples
public class ListaImplements {
class Nodo{
//variables
public String dato;
public Nodo enlace;
Nodo (String n){
dato=n;//inicializacion
enlace=null;
}
}
Nodo inicio;
public void Lista(){
inicio=null;
}
public boolean vacia(){//cuando esta vacia
return(inicio==null);
}
public int Tamaño(){//saber el tamaño
int n=0;
Nodo temporal=inicio;
while(temporal!=null){
n++;
temporal=temporal.enlace;
}
return n;
}
public boolean Buscar(String elemento){//para buscar un elemento en la lista
Nodo temporal=inicio;
while(temporal!=null){
if(elemento.equals(temporal.dato))
return true;
else
temporal=temporal.enlace;
}
return false;
}
public void Insertar(String elemento){//insert un elemento en la lista
Nodo n=new Nodo(elemento);
}
public String Eliminar(){//eliminar un elemento en la lista
String temporal=inicio.dato;
inicio=inicio.enlace;
return temporal;
}
public static void main (String args[])
{
ListaImplements x= new ListaImplements();
}
}

EJEMPLO DE LISTAS ENLAZADAS

package listasenlazadas;

class Nodo {
//variables a itilizar
int dato;
Nodo enlace;
public Nodo(int a){
//inicializar variables
dato=a;
enlace=null;
}
}
class Lista{
private Nodo inicio;
public Lista(){
inicio=null;
}
public Lista Insertarcabeza(int a){//insertar arriba
Nodo nuevo=new Nodo(a);
nuevo.enlace=inicio;
inicio=nuevo;
return this;
}
public void Visualizar(){//ver que hay en cada uno de los nodos
Nodo actual;
actual=inicio;
while(actual!=null){
System.out.print(actual.dato+"");
actual=actual.enlace;
}
}
public Nodo Buscar(int dat){//buscar un dato
Nodo i;
try{
for(i=inicio;i!=null;i=i.enlace){
if(dat==i.dato)
return i;
}
catch(Exception e)()
return null;
}
}
}

package listasenlazadas;
public class Principal {
public static void main(String [] args){
Lista x=new Lista();
//datos de ejemplo
for(int i=0; i< n="i.Buscar(3);">

EJERCICIO

package listaligada;
import java.util.*;
public class ListaLigada {
public static void main (String args[]) {
Scanner leer = new Scanner(System.in);
ListaLigada x=new ListaLigada();
//variables a usar
int num;
int op;
LinkedList lista = new LinkedList(); //menu
do{
System.out.println( "\t Menú \t" );
System.out.println( "Operaciones con listas" );
System.out.println( "1.- Insertar al principio" );
System.out.println( "2.- Insertar al final" );
System.out.println( "3.- Borrar al principio" );
System.out.println( "4.- Borrar al final" );
System.out.println( "5.- Mostrar la lista" );
System.out.println( "6.- Borrar toda la lista" );
System.out.println( "7.- Salir" );
System.out.println( "\n" );
System.out.println( "Elija la operación que desee" );
op = leer.nextInt(); //coger la opcion
switch(op){
case 1:
System.out.println( "Inserte numero" );
//coger el numero y añadirlo a la lista de primeras
num = leer.nextInt();
lista.addFirst(num);
break;
case 2:
System.out.println( "Inserte numero" );
//anadir el numero a la lista
num = leer.nextInt();
lista.addLast(num);
break;
case 3:
System.out.println( "Se borrara el primer nodo" );
//remover de la lista
lista.removeFirst();
break;
case 4:
System.out.println( "Se borrara el nodo final" );
//remover nodo de el final de la lista
lista.removeLast();
break;
case 5:
System.out.println( "La lista es la siguiente" );
//tamaño de la lista
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
break;
case 6:
System.out.println( "Se borraran todos los elementos de la lista" );
lista.clear();
break;
case 7:
System.out.println( "Al rato" );
break;
}
}
while( op != 7 );
}
}

EJERCICIO 2

package ejemplolista;
import java.util.*;
public class ListaAlumnos{
//variables qeu necesitamos
private String nom;
int calif1;
int calif2;
int calif3;
static double prom;
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);
ListaAlumnos nodo = new ListaAlumnos();
int op;
ArrayList lista = new ArrayList(); //secuencia de lista
do{
System.out.println( "Ingrese el nombre del alumno:" );
nodo.nom = leer.next();
System.out.println( "Ingrese la primera calificación:" );
nodo.calif1 = leer.nextInt();
System.out.println( "Ingrese la segunda calificación:" );
nodo.calif2 = leer.nextInt();
System.out.println( "Ingrese la tercera calificación:" );
nodo.calif3 = leer.nextInt();
//lo qeu queda guardado
lista.add("Nombre del alumno:\n"+nodo.nom);
lista.add("Calificación 1:\n"+nodo.calif1);
lista.add("Calificación 2:\n"+nodo.calif2);
lista.add("Calificación 3\n"+nodo.calif3);
promedio(nodo.calif1, nodo.calif2, nodo.calif3);
lista.add("Su promedio es:\n"+prom);
System.out.println( "¿Desea ingresar otro alumno?" );
System.out.println( "1.-Si\t 2.-No" );
op = leer.nextInt();
}
while(op != 2);
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
}
private static double promedio(int calif1, int calif2, int calif3){ //como resolver el promedio
int suma = calif1 + calif2 + calif3;
prom = suma/3;
return prom;
}
}

EJERCICIO 3

package ejerciciodelistas;//Paquete
import java.awt.BorderLayout;//importacion de librerias
import java.awt.Frame;
import java.awt.Label;
import java.awt.List;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class Listas extends Frame{
List lista = new List(0,true);
Label text= new Label ("Maravillas que se pueden visitar en la localidad elegida");
public Listas(){
super("elegir intinerario");
lista.add("Bienvenido");
lista.add("foiano de val fortore");
lista.add("baselice");
lista.add("San bartolomeo en Galdo");
lista.add("San marco de los Cavoti");
lista.add("Montefalcone en val fortore");
lista.add("Pesco Sannita");
lista.add("Colle Sannita");
lista.add("Castelvetere en val fortore");
lista.add("castelfranco en miscano");
lista.add("ginestra de los schiavoni");
lista.add("San giorgio la molara");
lista.add("molinara");
lista.add("Pietrelcina");
lista.add("Fragneto Monforte");
lista.add("Circello");
lista.add("Campolattaro");
add(lista,BorderLayout.CENTER);
add(text,BorderLayout.SOUTH);
addWindowListener(new listeWindowListener());
//lista.addItemListener(new escuchaLista());
setSize(350,100);
setResizable(false);
show();
}
class listeWindowListener implements WindowListener{
public void windowActivated(WindowEvent e){//la ventana se ve en primer plano
}
public void windowClosed(WindowEvent e){//salir de el explor5ador
}
public void windowClosing(WindowEvent e){//seleccionaren la lista aql cerrar
String[]s=lista.getSelectedItems();
int i=0;
System.out.println("itinerario seleccionado");
try{
while(true){
System.out.println(s[i++]);
}
}
catch (ArrayIndexOutOfBoundsException er){
System.out.println("que lo pases bien ");
}
System.exit(0);
}
public void windowDeactivated(WindowEvent e){//eventos de windows
}
public void windowDeiconified(WindowEvent e){
}
public void windowIconified(WindowEvent e){
}
public void windowOpened(WindowEvent e){
}
class escuchaLista implements ItemListener{
public void itemStateChanged(ItemEvent e){
int Ãndice=((Integer) e.getItem()).intValue();
if (Ãndice==0) text.setText("Rocca de los Rettori, arco de Trajano, anfiteatro Romano, ciudad espectáculo");
if (Ãndice==1) text.setText("localidad San Giovanni, Campanario, via Roma, lago, fiesta S.Giovanni, fiesta del emigrante");
if (Ãndice==2) text.setText("óasis ds San Leonardo");
if (Ãndice==3) text.setText("casco histórico");
if (Ãndice==4) text.setText("casco histórico");
if (Ãndice==5) text.setText("casco histórico");
if (Ãndice==6) text.setText("casco histórico");
if (Ãndice==7) text.setText("casco histórico");
if (Ãndice==8) text.setText("casco histórico");
if (Ãndice==9) text.setText("Bosque");
if (Ãndice==10) text.setText("casco histórico");
if (Ãndice==11) text.setText("Lago de San Giorgio");
if (Ãndice==12) text.setText("casco histórico");
if (Ãndice==13) text.setText("Piana Romana, casco histórico, casas de Padre Ão");
if (Ãndice==14) text.setText("Encuentro internacional de globos, Palacio Ducal");
if (Ãndice==15) text.setText("casco histórico");
if (Ãndice==16) text.setText("Dique de Campolattaro");
}
}
}
public static void main(String [] args){
Listas x= new Listas();
}
}

OPERACIONES RECURSIVAS

package listas2;
import javax.swing.JOptionPane;

public class IntSLLNode {
private IntSLLNode next;
public int info;
public IntSLLNode(){
}
public IntSLLNode(int i){
this(i,null);
}
public IntSLLNode(int i, IntSLLNode n){
int info= i;
next=n;
}
public void addToHead(int i,Object head){
head=newIntSLLNode(i,head);
if(tail==null)
tail=head;
}
public void addToTail(int i){
if(isEmpaty()){
Tail.next=newIntsLLNode(i);
tail=tail.next;
}
head=tail=newIntSLLNode(i);
}
public int deleteFromTail(){
int i=Head.info;
if(Head==tail){
Head=tail=null;
}
else{
IntSLLNodetmp
for(tmp=head;tmp.next!=tail;tmp=tmp.next){
tail.tmp;
tail.next=null;
}
}
}
public void PrintAll(){
for(IntSLLNode.tmp=head;tmp!=null;tmp=tmp.next){
System.out.print(tmp.info+"");
}
}
public boolean isInList(int i){
IntSLLNode tmp;
for(tmp=head;tmp!=null && tmp.info1=i;tmp=tmp.next){
returntmp!=null;
}
}
public static void main (String args[])
{
IntSLLNode x= new IntSLLNode();
}



}