Arboles B+

ARBOL B+

son estructuras de datos de árbol que se encuentran comúnmente en las implementaciones de bases de datos y sistemas de archivos. Los árboles B mantienen los datos ordenados y las inserciones y eliminaciones se realizan en tiempo logarítmico amortizado.

CARACTERISTICAS=

B-árbol es un árbol de búsqueda que puede estar vacío o aquel cuyos nodos pueden tener varios hijos, existiendo una relación de orden entre ellos, tal como muestra el dibujo .
Un arbol-B de orden M (el máximo número de hijos que puede tener cada nodo) es un arbol que satisface las siguientes propiedades:
Cada nodo tiene como máximo M hijos.
Cada nodo (excepto raiz y hojas) tiene como mínimo M/2 hijos.
La raiz tiene al menos 2 hijos si no es un nodo hoja.
Todos los nodos hoja aparecen al mismo nivel,y no tienen hijos.
Un nodo no hoja con k hijos contiene k-1 elementos almacenados.
Los hijos que cuelgan de la raíz (r1, · · · rm) tienen que cumplir ciertas condiciones :
El primero tiene valor menor que r1.
El segundo tiene valor mayor que r1 y menor que r2 etc.
El último hijo tiene mayor que rm .

OPERACIONES=

Búsqueda

La búsqueda es similar a la de los árboles binarios. Se empieza en la raíz, y se recorre el árbol hacia abajo, escogiendo el sub-nodo de acuerdo a la posición relativa del valor buscado respecto a los valores de cada nodo. Típicamente se utiliza la búsqueda binaria para determinar esta posición relativa.

procedimiento=

Situarse en el nodo raíz.
(*). Comprobar si contiene la clave a buscar.
. Encontrada fin de procedimiento .
. No encontrada:
Si es hoja no existe la clave.
En otro caso el nodo actual es el hijo que corresponde:
. La clave a buscar k <> ki y k <>
Inserción

Todas las inserciones se hacen en los nodos hoja.
Realizando una búsqueda en el árbol, se halla el nodo hoja en el cual debería ubicarse el nuevo elemento.
Si el nodo hoja tiene menos elementos que el máximo número de elementos legales, entonces hay lugar para uno más. Inserte el nuevo elemento en el nodo, respetando el orden de los elementos.
De otra forma, el nodo debe ser dividido en dos nodos. La división se realiza de la siguiente manera:
Se escoge el valor medio entre los elementos del nodo y el nuevo elemento.
Los valores menores que el valor medio se colocan en el nuevo nodo izquierdo, y los valores mayores que el valor medio se colocan en el nuevo nodo derecho; el valor medio actúa como valor separador.
El valor separador se debe colocar en el nodo padre, lo que puede provocar que el padre sea dividido en dos, y así sucesivamente.
Si las divisiones de nodos suben hasta la raíz, se crea una nueva raíz con un único elemento como valor separador, y dos hijos. Es por esto por lo que la cota inferior del tamaño de los nodos no se aplica a la raíz. El máximo número de elementos por nodo es U-1. Así que debe ser posible dividir el número máximo de elementos U-1 en dos nodos legales. Si este número fuera impar, entonces U=2L, y cada uno de los nuevos nodos tendrían (U-2)/2 = L-1 elementos, y por lo tanto serían nodos legales. Si U-1 fuera par, U=2L-1, así que habría 2L-2 elementos en el nodo. La mitad de este número es L-1, que es el número mínimo de elementos permitidos por nodo.
Un algoritmo mejorado admite una sola pasada por el árbol desde la raiz,hasta el nodo donde la inserción tenga lugar,dividiendo todos los nodos que estén llenos encontrados a su paso.Esto evita la necesidad de volver a cargar en memoria los nodos padres,que pueden ser caros si los nodos se encuentran en una memoria secundaria.Sin embargo,para usar este algoritmo mejorado, debemos ser capaces de enviar un elemento al nodo padre y dividir el resto U-2 elementos en 2 nodos legales,sin añadir un nuevo elemento.Esto requiere que U=2L en lugar de U=L-1,lo que explica por qué algunos libros de texto imponen este requisito en la definicion de árboles-B.

Eliminación

La eliminación de un elemento es directa si no se requiere corrección para garantizar sus propiedades. Hay dos estrategias populares para eliminar un nodo de un árbol B.
localizar y eliminar el elemento, y luego corregir, o
hacer una única pasada de arriba a abajo por el árbol, pero cada vez que se visita un nodo, reestructurar el árbol para que cuando se encuentre el elemento a ser borrado, pueda eliminarse sin necesidad de continuar reestructurando
Se pueden dar dos problemas al eliminar elementos: primero, el elemento puede ser un separador de un nodo interno. Segundo, puede suceder que al borrar el elemento número de elementos del nodo quede debajo de la cota mínima. Estos problemas se tratan a continuación en orden.

Ejemplo

Prueba_Arboles
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

public class PruebaArbol extends JFrame {

Container c=getContentPane();
private JMenuBar menu;
private JMenu i1,i2;
private JMenuItem construye,mostrar,alt,hoj,anc,salir,creditos,nuevo,inor,pos,pre;
private int dato=0,nodos=0;
Arbol arbol;
String aux="R",fila=" ",columna="\n\n",cadena=new String();
private TextArea most;

public PruebaArbol(String cogollo)
{
super(cogollo);
c.setLayout(new FlowLayout());
menu = new JMenuBar();
i1 = new JMenu("ARCHIVO");
i2 = new JMenu("PROCESOS");
nuevo=new JMenuItem("NUEVO PROYECTO");
salir=new JMenuItem("SALIR");
construye=new JMenuItem("CONSTRUIR ARBOL");
mostrar=new JMenuItem("MOSTRAR ARBOL");
alt=new JMenuItem("ALTURA DEL ARBOL");
hoj=new JMenuItem("HOJAS DEL ARBOL");
anc=new JMenuItem("ANCESTROS DEL ARBOL");
inor=new JMenuItem("INORDEN");
pre=new JMenuItem("PREORDEN");
pos=new JMenuItem("POSORDEN");
creditos=new JMenuItem("CREDITOS");
i1.add(nuevo);
i1.add(construye);
i1.add(mostrar);
i1.add(creditos);
i1.add(salir);
i2.add(alt);
i2.add(hoj);
i2.add(anc);
i2.add(inor);
i2.add(pos);
i2.add(pre);


nuevo.addActionListener(new manejaEventos());
salir.addActionListener(new manejaEventos());
mostrar.addActionListener(new manejaEventos());
construye.addActionListener(new manejaEventos());
alt.addActionListener(new manejaEventos());
anc.addActionListener(new manejaEventos());
hoj.addActionListener(new manejaEventos());
inor.addActionListener(new manejaEventos());
pre.addActionListener(new manejaEventos());
pos.addActionListener(new manejaEventos());
creditos.addActionListener(new manejaEventos());
menu.add(i1);
menu.add(i2);
c.setBackground(new Color(128,0,255));
setJMenuBar(menu);

setSize( 1024 , 768 );
setVisible( true );

}


class manejaEventos implements ActionListener
{
public void actionPerformed(ActionEvent e)
{

if(e.getSource()==construye){


arbol=new Arbol();
int valor=0;
nodos=Integer.parseInt( JOptionPane.showInputDialog(null,"ingrese el numero de nodos para el arbol") );
for (int i=1;i<=nodos;i++){ dato=Integer.parseInt( JOptionPane.showInputDialog(null,"ingrese el dato a insertar en el arbol") ); arbol.insertarNodo(dato); } }//end construye if(e.getSource()==pre){ JOptionPane.showMessageDialog(null,"Preorden : "+arbol.preorden()); }//end preorden if(e.getSource()==inor){ JOptionPane.showMessageDialog(null,"Inorden : "+arbol.inorden()); }//end inorden if(e.getSource()==pos){ JOptionPane.showMessageDialog(null,"Posorden : "+arbol.posorden()); }//end posorden if(e.getSource()==alt){ JOptionPane.showMessageDialog(null,"Altura : "+arbol.altura(arbol.retornaraiz())); }//end altura if(e.getSource()==hoj){ JOptionPane.showMessageDialog(null,"Hojas : "+arbol.hojas(arbol.retornaraiz())); }//end hojas if(e.getSource()==anc){ int db=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el dato cuyos ancestros desea conocer")); JOptionPane.showMessageDialog(null,"Ancestro : "+arbol.ancestros(arbol.retornaraiz(),db)); }//end ancestros if(e.getSource()==mostrar){ mostrarArbol(arbol.retornaraiz(),aux); c.removeAll(); c.add(most); c.setBackground(Color.WHITE); c.repaint(); }//end mostrar if(e.getSource()==nuevo){ c.removeAll(); arbol=new Arbol(); cadena=new String(); most=new TextArea(); dato=0;nodos=0; aux="R";fila=" ";columna="\n\n"; c.setBackground(Color.WHITE); }//end nuevo if(e.getSource()==creditos){ c.removeAll(); JLabel cred=new JLabel("ESTE PROGRAMA FUE DISEÑADO POR JUAN RICARDO COGOLLO OYOLA"); cred.setBounds(200,200,510,200); cred.setFont(new Font("EuropeExt", Font.BOLD + Font.ITALIC, 14)); cred.setForeground(Color.DARK_GRAY); c.setBackground(Color.white); c.add(cred); c.repaint(); } if(e.getSource()==salir){ System.exit(0); }//end salir }} public static void main(String[] args) { PruebaArbol ventana = new PruebaArbol("ARBOLES BINARIOS DE BUSQUEDA"); ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } void pintar(int d,String h){ cadena=cadena+columna+fila+h+" : "+String.valueOf(d); most = new TextArea("",200,300,0); most.setBounds(20,200,700,500); most.append(cadena); most.setEditable(false); } void mostrarArbol(NodoArbol R,String hijo){ String h=hijo; if(R!=null){ pintar(R.retornadato(),h); if(R.li!=null){ aux="Izq"; fila=fila+" "; mostrarArbol(R.li,aux); int n=fila.length(); fila=fila.substring(10); } if(R.ld!=null){ aux="Der"; fila=fila+" "; mostrarArbol(R.ld,aux); int n=fila.length(); fila=fila.substring(10); } } }//end windows }

Algoritmo programa arbolles

ALGORITMO Y DIAGRAMA DE CLASES DE ARBOLES

Insertar(Arbol, N, Elemento)
Si N<25
Arbol[N] -> a
N -> N + 1
OrdMon(Arbol, N)
Salir
//Fin de la condición//
Imprimir "Árbol Lleno..."
Salir
OrdMon(Arbol, Total)
ConstMon(Arbol, Total)
Mientras Total > 1
Total -> Total - 1
Burbuja(0, Total)
RecMon(Total, 0)
//Fin del ciclo//
Salir
ConstMon(Arbol, Total)
v -> (Total/2) - 1
Mientras v ≥ 0
RecMon(Arbol, Total, v)
v -> v - 1
//Fin del ciclo//
Salir
----
RecMon(Arbol, Total, v)
w -> 2*v+1
Mientras w < Total
Si (w+1) < Total
Si Arbol[w+1] > Arbol[w]
w++
//Fin de la condición//
Fin de la condición
Si Arbol[v] ≥ Arbol[w]
Salir
//Fin de la condición//
Burbuja(Arbol, v, w)
v -> w
w -> 2*v+1
//Fin del ciclo//
Salir
----
Burbuja(Arbol, v, w)
t -> Arbol[v]
Arbol[v] -> Arbol[w]
Arbol[w] -> t
Salir

**Busqueda(Arbol, N, Elemento)**
Si N ≠ 0
OrdMon(Arbol, N)
i ->
Mientras i < N;i++)
Si Arbol[i] = Elemento
Imprimir "Elemento Encontrado..."
Salir
//Fin de la condición//
i -> i + 1
//Fin del ciclo//
Imprimir "El Elemento no esta en el Árbol..."
Salir
//Fin de la condición//
Imprimir "Árbol Vació..."
Salir

Eliminar(Arbol, N, Elemento)
Si N ≠ 0
OrdMon(Arbol, N)
i ->
Mientras I < N
Si Arbol[i] = Elemento
j -> i + 1
Mientras j < N
t -> Arbol[i]
Arbol[i] -> Arbol[j]
Arbol[j] -> t
j -> j + 1
//Fin del ciclo//
N -> n - 1
Imprimir "Elemento Eliminado..."
Salir
//Fin de la condición//
i -> i + 1
//Fin del ciclo//
Fin de la condición
Imprimir "Arbol Vacio... Imposible Eliminar..."

Recorrido(Arbol, N)
Si N ≠ 0
i ->
Mientras i < N
Imprimir Arbol[i]
i -> i + 1
//Fin del ciclo//
Salir
//Fin de la condición//
Imprimir "Arbol Vacio..."
Salir
Salir

ARBOLES EN CLASE

UN ARBOL TIENE:

1. Longitud: Cantidad de aristas; se cuenta desde la raiz a un nodo al q se hace referencia.
2. Tamaño: Cantidad de nodos.
3. Profundidad: Se da desde la raiz al nodo referido.
4. Altura: Se cuenta desde la raiz hasta el ultimo nodo mas profundo.
5. Rrcorridos:

-Preorden---->raiz, izquierdo, derecho.

-Inorden---->izquierdo, raiz, derecho.

-Postorden--->izquierdo, derecho,raiz.

ARBOLES BINARIOS

Conjunto finito que tiene las siguientes caracteristicas:

• grado
• recorrido
• recorrido a lo ancho

ARBOL DE AQUILIBRIO

FE=hijos subderecho-hijos subizquierdo

ARBOL DE BUSQUEDAD

• crear
• insertar
• eliminar
• busquedad

IMPLEMENTACION DE ARBOLES

•Representación basada en cursores a los hijos
–Representación de árboles en base a vectores
•Cada componente del vector guarda un nodo con:
–el elementoque contiene
–Los índices donde se encuentran sus hijos (izqy der)
–Booleano indicando si la componente del vector estáen uso o no
•El árbol estaráformado por el índice donde se encuentra la raíz del árbol, y el vector que almacena los nodos
–Árbol vacíose representarácon valor 0como índice de la raiz

EJEMPLO1:

class NodoArbol{
NodoArbol li,ld;
int dato;
public NodoArbol(int d){
dato=d;
li=ld=null;
}
public synchronized void insertar(int d){
if(dif(li==null){
li=new NodoArbol(d);
}
else{
li.insertar(d);
}
}
if(d>dato){
if(ld==null){
ld=new NodoArbol(d);
}
else{
ld.insertar(d);
}
}
}//fin insertar
public int retornadato(){
return(dato);
}//end retornadato
}
public class Arbol {
private NodoArbol raiz;
public Arbol() {
raiz=null;
}
public NodoArbol retornaraiz(){
return(raiz);
}
public synchronized void insertarNodo(int d){
if(raiz==null){
raiz=new NodoArbol(d);
//primero=raiz;
}
else{
raiz.insertar(d);
}
}//fin insertarNodo
public synchronized String preorden(){
String pre=ayudantepreorden(raiz);
return(pre);
}
private String ayudantepreorden(NodoArbol nodo){
String cadena=new String();
if(nodo!=null){
//return;
//System.out.print(nodo.dato+" ");
cadena=cadena+String.valueOf(nodo.dato+" ");
cadena=cadena+ayudantepreorden(nodo.li);
cadena=cadena+ayudantepreorden(nodo.ld);
}
else{
cadena="";
}
return(cadena);
}
public synchronized String inorden(){
String inor=ayudanteinorden(raiz);
return(inor);
}
private String ayudanteinorden(NodoArbol nodo){
String cadena=new String();
if(nodo!=null){
// return;
cadena=cadena+ayudanteinorden(nodo.li);
cadena=cadena+nodo.dato+" ";
cadena=cadena+ayudanteinorden(nodo.ld);
}
else{cadena="";}
return(cadena);
}
public synchronized String posorden(){
String pos=ayudanteposorden(raiz);
return(pos);
}
private String ayudanteposorden(NodoArbol nodo){
String cadena=new String();
if(nodo!=null){
cadena=cadena+ayudanteposorden(nodo.li);
cadena=cadena+ayudanteposorden(nodo.ld);
cadena=cadena+nodo.dato+" ";
}
else{cadena="";}
return(cadena);
}
public synchronized int altura(NodoArbol R){
NodoArbol p=R;
int altizq=p.li==null ? 1:1+altura(p.li);
int altder=p.ld==null ? 1:1+altura(p.ld);
return(Math.max(altizq,altder));
}//end altura
public synchronized int hojas(NodoArbol R){
NodoArbol p=R;
int hojas=0;
if(p.li==null & p.ld==null){
hojas=1;
}
else{
if(p.li!=null){
hojas=hojas+hojas(p.li);
}
if(p.ld!=null){
hojas=hojas+hojas(p.ld);
}
}
return(hojas);
}//end hojas
public synchronized String ancestros(NodoArbol R,int d){
NodoArbol p=R;
String h=new String();
if (p.dato==d){
return(String.valueOf(" --> "+d));
}//end if
if (d>p.dato){
h=h+" --> "+p.dato+ancestros(p.ld,d);
}
else{
h=h+" --> "+p.dato+ancestros(p.li,d);
}
return(h);
}
}

import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class PruebaArbol extends JFrame {
Container c=getContentPane();
private JMenuBar menu;
private JMenu i1,i2;
private JMenuItem construye,mostrar,alt,hoj,anc,salir,creditos,nuevo,inor,pos,pre;
private int dato=0,nodos=0;
Arbol arbol;
String aux="R",fila=" ",columna="\n\n",cadena=new String();
private TextArea most;
public PruebaArbol(String cogollo)
{
super(cogollo);
c.setLayout(new FlowLayout());
menu = new JMenuBar();
i1 = new JMenu("ARCHIVO");
i2 = new JMenu("PROCESOS");
nuevo=new JMenuItem("NUEVO PROYECTO");
salir=new JMenuItem("SALIR");
construye=new JMenuItem("CONSTRUIR ARBOL");
mostrar=new JMenuItem("MOSTRAR ARBOL");
alt=new JMenuItem("ALTURA DEL ARBOL");
hoj=new JMenuItem("HOJAS DEL ARBOL");
anc=new JMenuItem("ANCESTROS DEL ARBOL");
inor=new JMenuItem("INORDEN");
pre=new JMenuItem("PREORDEN");
pos=new JMenuItem("POSORDEN");
creditos=new JMenuItem("CREDITOS");
i1.add(nuevo);
i1.add(construye);
i1.add(mostrar);
i1.add(creditos);
i1.add(salir);
i2.add(alt);
i2.add(hoj);
i2.add(anc);
i2.add(inor);
i2.add(pos);
i2.add(pre);
nuevo.addActionListener(new manejaEventos());
salir.addActionListener(new manejaEventos());
mostrar.addActionListener(new manejaEventos());
construye.addActionListener(new manejaEventos());
alt.addActionListener(new manejaEventos());
anc.addActionListener(new manejaEventos());
hoj.addActionListener(new manejaEventos());
inor.addActionListener(new manejaEventos());
pre.addActionListener(new manejaEventos());
pos.addActionListener(new manejaEventos());
creditos.addActionListener(new manejaEventos());
menu.add(i1);
menu.add(i2);
c.setBackground(new Color(128,0,255));
setJMenuBar(menu);
setSize( 1024 , 768 );
setVisible( true );
}
class manejaEventos implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==construye){
arbol=new Arbol();
int valor=0;
nodos=Integer.parseInt( JOptionPane.showInputDialog(null,"ingrese el numero de nodos para el arbol") );
for (int i=1;i<=nodos;i++){
dato=Integer.parseInt( JOptionPane.showInputDialog(null,"ingrese el dato a insertar en el arbol") );
arbol.insertarNodo(dato);
}
}//end construye
if(e.getSource()==pre){
JOptionPane.showMessageDialog(null,"Preorden : "+arbol.preorden());
}//end preorden
if(e.getSource()==inor){
JOptionPane.showMessageDialog(null,"Inorden : "+arbol.inorden());
}//end inorden
if(e.getSource()==pos){
JOptionPane.showMessageDialog(null,"Posorden : "+arbol.posorden());
}//end posorden
if(e.getSource()==alt){
JOptionPane.showMessageDialog(null,"Altura : "+arbol.altura(arbol.retornaraiz()));
}//end altura
if(e.getSource()==hoj){
JOptionPane.showMessageDialog(null,"Hojas : "+arbol.hojas(arbol.retornaraiz()));
}//end hojas
if(e.getSource()==anc){
int db=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el dato cuyos ancestros desea conocer"));
JOptionPane.showMessageDialog(null,"Ancestro : "+arbol.ancestros(arbol.retornaraiz(),db));
}//end ancestros
if(e.getSource()==mostrar){
mostrarArbol(arbol.retornaraiz(),aux);
c.removeAll();
c.add(most);
c.setBackground(Color.WHITE);
c.repaint();
}//end mostrar
if(e.getSource()==nuevo){
c.removeAll();
arbol=new Arbol();
cadena=new String();
most=new TextArea();
dato=0;nodos=0;
aux="R";fila=" ";columna="\n\n";
c.setBackground(Color.WHITE);
}//end nuevo
if(e.getSource()==creditos){
c.removeAll();
JLabel cred=new JLabel("ESTE PROGRAMA FUE DISEÑADO POR JUAN RICARDO COGOLLO OYOLA");
cred.setBounds(200,200,510,200);
cred.setFont(new Font("EuropeExt", Font.BOLD + Font.ITALIC, 14));
cred.setForeground(Color.DARK_GRAY);
c.setBackground(Color.white);
c.add(cred);
c.repaint();
}
if(e.getSource()==salir){
System.exit(0);
}//end salir
}}
public static void main(String[] args) {
PruebaArbol ventana = new PruebaArbol("ARBOLES BINARIOS DE BUSQUEDA");
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
void pintar(int d,String h){
cadena=cadena+columna+fila+h+" : "+String.valueOf(d);
most = new TextArea("",200,300,0);
most.setBounds(20,200,700,500);
most.append(cadena);
most.setEditable(false);
}
void mostrarArbol(NodoArbol R,String hijo){
String h=hijo;
if(R!=null){
pintar(R.retornadato(),h);
if(R.li!=null){
aux="Izq";
fila=fila+" ";
mostrarArbol(R.li,aux);
int n=fila.length();
fila=fila.substring(10);
}
if(R.ld!=null){
aux="Der";
fila=fila+" ";
mostrarArbol(R.ld,aux);
int n=fila.length();
fila=fila.substring(10);
}
}
}//end windows
}

Arboles

ARBOLES

Definición:
Un Árbol Binario es un conjunto de finito de Elementos, de nombre Nodos de forma que:
El Árbol Binario es Vació si no tiene ningún elemento en el.
El Árbol Binario contiene un Nodo Raíz y los dos que parten de él, llamados Nodo Izquierdo y Nodo Derecho.
Los Árboles tiene 3 Recorridos Diferentes los cuales son:
Pre-Orden
In-Orden
Post-Orden
Pre-Orden
Definición:
El Recorrido “Pre-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en la Raíz, después viaje a través del Nodo Izquierdo y después a través del Nodo Derecho.
Detalle:
Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.
Algoritmo:
PreOrd(Arbol, Der, Izq, Pila, Raiz)
Temp → Raiz
Top →
Pila[Top] → Nulo
Si Raiz = Nulo
Imprimir “Árbol Vació…” y Salir
Repetir mientras Temp ≠ Nulo
Imprimir Arbol[Temp]
Si Der[Temp] ≠ Nulo
Top → Top + 1
Pila[Top] → Der[Temp]
Si Izq[Temp] ≠ Nulo
Temp → Izq[Temp]
Si no:
Temp → Pila[Top];
Top → Top - 1
Fin del ciclo
Salir

In-Orden
Definición:
El Recorrido “In-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en el Nodo Izquierdo después la Raíz y finalmente viaja a través del Nodo Derecho.
Detalle:
Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.
Algoritmo:
PreOrd(Arbol, Der, Izq, Pila, Raiz)
Temp → Raiz
Top →
Pila[Top] → Nulo
Si Raiz = Nulo
Imprmir “Arbol Vacio…” y Salir
Etiqueta:
Mientras Temp ≠ Nulo
Top → Top + 1
Pila[Top] → Temp
Temp → Izq[Temp]
Fin del ciclo
Temp → Pila[Top]
Top → Top - 1
Mientras Temp ≠ Nulo
Imprimir Arbol[Temp]
Si Der[Temp] ≠ Nulo
Temp → Der[Temp]
Ir a Etiqueta
Temp → Pila[Top]
Top → Top - 1
Fin del ciclo
Salir

In-Orden
Definición:
El Recorrido “In-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en el Nodo Izquierdo después el Nodo Derecho y finalmente viaja a través de la Raiz.
Detalle:
Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.
Algoritmo:
PostOrd(Arbol, Der, Izq, Pila, Raiz)
Temp → Raiz
Top →
Pila[Top] → Nulo
Si Raiz = Nulo
Imprimir “Arbol Vacio…” y Salir
Etiqueta:
Mientras Temp ≠ Nulo
Top → Top + 1
Pila[Top] → Temp
Si Der[Temp] ≠ Nulo
Top → Top + 1
Pila[Top] → - (Der[Temp])
Temp → Izq[Temp]
Temp → Pila[Top]
Top → Top - 1
Fin del ciclo
Mientras Temp ≥ 0
Imprimir Arbol[Temp]
Si Arbol[Temp] = Info[Raiz]
Salir
Temp → Pila[Top]
Top → Top - 1
Fin del ciclo
Si Temp < temp =" -(Temp)">

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();
}



}