Push: apilar
Pop: des-apilar
Estas operaciones se realizan sobre un único extremo llamado cima.
Se agrega un dato retirado siempre el último que se colocó en la pila.
Esta pila tiene 4 elementos, para la implementación de la clase haremos uso una variable entera tope que se encargara de decirnos en que posición del Array esta el elemento de la cima, en este caso tope=3 porque en el Array donde ingresamos los datos desde la posición 0.
IMPLEMENTACIÓN DE PILAS
Teniendo en cuenta que las inserciones y eliminaciones en una pila se hacen siempre por un extremo, lo que se considera primer elemento de la lista, en una realidad el último electo de la pila.
public class Pila{
int tope=-1;
int vec[];
Pila(int max){
vec=new int [max];
}
public boolean llena(){
if (tope==vec.length-1)
return true;
else
return false;
}
public boolean vacia(){
if (tope==-1)
return true;
else
return false;
}
public void push(int dato){
if (llena()== true)
System.out.println("Overflow");
else
if (tope==-1){
tope=0;
vec[tope]=dato;
}
else{
tope++;
vec[tope]=dato;
}
}
public int pop(){
int aux;
if (vacia()==true){
System.out.println("La pila esta vacia");
return -1;
}
else{
aux=vec[tope];
tope--;
}
return aux;
}
public void Imprime_Datos(){ if(vacia()==true){
System.out.println("La pila esta vacia, ingrese datos primero:");
}
else
for(int Contador=0;Contador<vec.length;Contador++)
System.out.println("Los valores de la pila son:"+vec[Contador]);
}
COLAS
Es una estructura de datos 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 extremo a este. Tipo de estructura también se le conoce como FIFO debido que el primer elemento en entrar será también el primero en salir.
El tipo de estructura llamado cola representa la idea que tiene de fila en la vida real; como por ejemplo la cola para subir en el camión está compuesta por elementos "Personas que disponen de 2 extremos que son: comienzo y fin. por el comienzo se extraerá un elemento cuando haya comprad0 el boleto a su viaje y si llega una nueva persona con intensión de usar el autobús tendrá que colocarse al final y esperar a que todos los elementos situados antes que el suban al autobús.
IMPLEMENTACION:
Crear: se crea la cola vacía.
Encolar (añadir, entrar, push): se añade un elemento a la cola. Se añade al final de esta.
Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primero elemento que entró.
IMPLEMENTACION DE COLAS
public void inserta(Elemento x) {
Nodo Nuevo;
Nuevo = new Nodo(x, null);
if (NodoCabeza == null) {
NodoCabeza = Nuevo;
} else {
NodoFinal.Siguiente = Nuevo;
}
NodoFinal = Nuevo;
}
public Elemento cabeza() throws IllegalArgumentException {
if (NodoCabeza == null) {
throw new IllegalArgumentException();
} else {
return NodoCabeza.Info;
}
}
public Cola() {
// Devuelve una Cola vacía
NodoCabeza = null;
NodoFinal = null;
}
TIPOS DE COLAS
Simples
Dobles
Circulares
DIFERENCIA ENTRE PILAS Y COLAS
PILAS. Ultimo elemento que se insertó en la lista.
COLAS. Primer elemento que se insertó en la lista.
COLAS SIMPLES: tienen un problema ya que las eliminaciones solo pueden realizarse por un extremo, puede llegar un momento el posicionado F sea igual al máximo numero de elementos en la cola siendo que al frente de la misma existan lugares vacíos y al insertar un nuevo elemento nos mandara un error de cola llena. Para solucionar el problema de desperdicio de memoria se implementaron las colas circulares, en las cuales existe un posicionado de último elemento al primero de la cola.
DIFERENCIA ENTRE LISTAS Y PILAS
Ciclo
Control de posiciones.
EJEMPLO: NODOS LISTAS ENLASADAS PILAS COLAS
Clases
1. Una clase vehículo
2. Una clase nodo
3. Una clase lista
4. Una clase cola
Este programa es para que todos aquellos que tengan un móvil en calidad de ilegal accedan a registrarse y posterior a imprimir los datos de sus registros guardados.
El objetivo es para darle facilidad a cada usuario que acceda mediante este programa.
Realización o Procedimiento para construir el programa:
Para el formulario:
1. Siete j label1 y coloco los siguientes datos en cada uno; propietario, tipo de movilidad, N° de chasis, N° de motor, año o modelo del móvil, color y costo de impuesto.
2. jTextField1 le cambio la variable de cada uno por txtpropietario, txttipo, etc.
3. jButton1 cambio las variables por btnregistrar clik derecho y busco eventos (ActionPerformed[……..]) y luego realizo el siguiente código para ingresar y mostrar datos
Variables declaradas como globales.
(En el siguiente….)
public class PROYECTOVEHICULOView extends FrameView {
Lista lista = new Lista();
Cola cola = new Cola();
Vehiculo vehiculo;
Vehiculo vehiculo2;
Vehiculo vehiculo3;
int pos=0;
int fila=0;
int x=0;
El código como en el campo local dentro el botón registrar:
(En el siguiente………).
private void btnregistrarActionPerformed(java.awt.event.ActionEvent evt) {
try{ String pro = txtpropietario.getText();
String tip = (String)item.getSelectedItem();//revisar mucho ojo
String chas = txtchasis.getText();
String mot = txtmotor.getText();
int mod = Integer.parseInt(txtmodelo.getText());
String col = txtcolor.getText();
double cosv = Double.parseDouble(txtcosto.getText());
double cos = Double.parseDouble(txtcosto.getText());
JOptionPane.showMessageDialog(null,"\nPROPIETARIO : "+ txtpropietario.getText()
// +"\nTIPO DE MOVIL : "+txttipo.getText()
+"\nN° CHASIS : "+txtchasis.getText()
+"\nN° MOTOR : "+txtmotor.getText()
+"\nMODELO : "+txtmodelo.getText()
+"\nCOLOR : "+txtcolor.getText()
+"\nCOSTO : "+txtcosto.getText()
+"\n\n ¡¡¡ ESTOS SON LOS DATOS A GUARDARSE !!!");
lista.IncertFrente(new Vehiculo( pro, tip, chas, mot, mod, col, cosv, cos));
vehiculo = (Vehiculo)lista.DelFrente();
tabla1.setValueAt(pro,fila,0);
tabla1.setValueAt(tip,fila,1);
tabla1.setValueAt(chas,fila,2);
tabla1.setValueAt(mot,fila,3);
tabla1.setValueAt(mod,fila,4);
tabla1.setValueAt(col,fila,5);
tabla1.setValueAt(vehiculo.getCostoV(),fila,6);
fila++;
if(pro.equals("") ||tip.equals("") ||chas.equals("") ||mot.equals("") ||mod == 0 ||col.equals("") ||cosv == 0.0){
tabla3.setValueAt(pro,x,0);
tabla3.setValueAt(tip,x,1);
tabla3.setValueAt(chas,x,2);
tabla3.setValueAt(mot,x,3);
tabla3.setValueAt(mod,x,4);
tabla3.setValueAt(col,x,5);
tabla3.setValueAt(vehiculo.getCostoV(),x,6);
tabla3.setValueAt(("REGISTRO INCOMPLETO !!!"),x,7);
x++;
}
cola.IncertarFrente(new Vehiculo(pro, tip, chas, mot, mod, col, cosv, cos));
vehiculo2 = (Vehiculo)cola.DelFrente();
if(!pro.equals("")
&&!tip.equals("")
&&!chas.equals("")
&&!mot.equals("")
&&mod != 0
&&!col.equals("")
&&cosv != 0.0){
tabla2.setValueAt(pro,pos,0);
tabla2.setValueAt(tip,pos,1);
tabla2.setValueAt(chas,pos,2);
tabla2.setValueAt(mot,pos,3);
tabla2.setValueAt(mod,pos,4);
tabla2.setValueAt(col,pos,5);
tabla2.setValueAt(vehiculo.getCostoV(),pos,6);
tabla2.setValueAt(vehiculo2.getCosto(),pos,7);
pos++;
}
String Limpiar="";
txtpropietario.setText(Limpiar);
// item.setText(Limpiar);
txtchasis.setText(Limpiar);
txtmotor.setText(Limpiar);
txtmodelo.setText(Limpiar);
txtcolor.setText(Limpiar);
txtcosto.setText(Limpiar);
Vehiculo v=new Vehiculo();
} catch (Exeption ex);
JOptionPane.ShowMesageDialog(null,”modelo y costo solo aceptan caracteres de tipo entero y no de cadena”);
}
Y de igual manera para el botón salir (System.exit(0)).
4. jTable1 clik derecho busco contenido de la tabla, columnas e introduzco en cada celda, los siete datos donde mostrará en cada celda los datos ingresados, realizo para cada tabla lo mismo.
5. Un j label1 para el logo tipo del programa.
Clases del programa
1. clase vehículo
import javax.swing.JOptionPane;
public class Vehiculo {
private String propietario;
private String tipo;
private String chasis;
private String motor;
private int modelo;
private String color;
private double costo;
private double costovehiculo;
public Vehiculo(){
propietario=tipo=chasis=motor=color="";
modelo=0;
costo=0.0;
costovehiculo=0.0;
}
public Vehiculo(String pro,String ti, String chas,String mot,int mod, String col,double cos,double cosv){
propietario=pro;tipo=ti;chasis=chas;motor=mot;color=col;
modelo=mod;
costo=cos;
costovehiculo = cosv;
}
public void mensaje(){
JOptionPane.showMessageDialog(null,"SEÑOR USUARIO DEBE REGISTRARSE CUIDADOSAMENTE ");
}
public String getVehiculo(){
return propietario+tipo+chasis+motor+color+ modelo+costo;
}
public void setPropietario(String pro){
propietario=pro;
}
public void setTipo(String ti){
tipo=ti;
}
public void setChasis(String chas){
chasis=chas;
}
public void setMotor(String mot){
motor=mot;
}
public void setModelo(int mod){
modelo=mod;
}
public void setColor(String col){
color=col;
}
public void setCosto(double cos){
costo = cos;
}
public void setCostoV(double cosv){
costovehiculo = cosv;
}
public double getCosto(){
int model;
int añoactual=2011;
model=añoactual-modelo;
if(model >= 1 && model <= 5){
costo += costo * 0.30;
}
if(model >= 6 && model <= 10){
costo += costo * 0.35;
}
if(model > 10){
costo += costo * 0.5;
}
return costo;
}
public double getCostoV(){
return costovehiculo;
}
public String getPropietario(){
return propietario;
}
public String getTipo(){
return tipo;
}
public String getChasis(){
return chasis;
}
public String getMotor(){
return motor;
}
public int getModelo(){
return modelo;
}
public String getColor(){
return color;
}
}
2. Clase nodo
public class Nodo extends Vehiculo {
public Object datos;
public Nodo sgte;
public Nodo anterior;
public Nodo(){
datos = sgte=anterior=null;
}
public Nodo(Object obj){
datos=obj;sgte=anterior=null;
}
public Nodo(Object obj, Nodo sig){
datos=obj;sgte=sig;
}
public void Setdatos(Object dat){datos= dat;}
public void Setanterior(Nodo ant){anterior=ant;}
public void Sgte(Nodo sg){sgte=sg;}
public Nodo GetSgte(){return sgte;}
public Nodo Getanterior(){return anterior;}
public Object Getdatos(){return datos;}
}
3. clase lista
public class Lista {
private Nodo prim;
private Nodo ult;
private String nombre;
private Nodo Actual;
private String[] Lista;
public Lista(){
prim=ult=null;
nombre="";
}
public Lista(String n){
prim=ult=null;
nombre=n;
}
public boolean ListaVacia(){return prim==null;}
public String getNombre(){return nombre;}
public Nodo getPrimero(){return prim;}
public Nodo getUltimo(){return ult;}
public void Imprimir (int max) {
for (int n = 0 ; n <= max ; n++ ) {
System.out.println(n + ".- " + Lista[n]);
}
}
public void IncertFrente(Object obj){
if (ListaVacia())
// System.out.println("la lista esta vacia");
prim=ult=new Nodo(obj);
else
prim=new Nodo(obj,prim);
}
public void IncertAtras(Object obj){
if (ListaVacia())
// System.out.println("la lista esta vacia");
prim=ult=new Nodo(obj);
else
ult=ult.sgte=new Nodo(obj);
}
public Object DelFrente(){
Object datoAremover=null;
if (ListaVacia())
System.out.println("la lista esta vacia");
datoAremover = prim.datos;
if(prim.equals(ult))
prim=ult=null;
else
prim=prim.sgte;
return datoAremover;
}
public Object DelAtraz(){
Object datoAremover=null;
if (ListaVacia()){
System.out.println("la lista esta vacia");}
datoAremover = ult.datos;
if(prim.equals(ult)){
prim=ult=null;
} else{
Nodo Actual=prim;
while (Actual.sgte !=ult)
Actual=Actual.sgte;
ult=Actual;
Actual.sgte=null;
}
return datoAremover;
}
public Object getElementoN(int posicion){
if(ListaVacia()){
return null;
}
else{
Nodo actual=prim;
int cont=1;
while ((actual !=null)&&(cont<posicion)){
actual=actual.sgte;
cont++;
}
if ((actual !=null)&&(cont==posicion)){
return actual.datos;}
else{
return null;
}
}
}
public void IncertartElementoN(int posicion,Object obj){
Nodo nuevo;
Nodo actual;
if(ListaVacia()){
return;
}
else{
actual=prim;
int cont=1;
while ((actual !=null)&&(cont<posicion-1)){
actual=actual.sgte;
cont++;
}
if ((actual !=null)&&(cont==posicion-1)){
nuevo=new Nodo(obj,actual.sgte);
actual.sgte=nuevo;
}
}
}
public Object DeletElementoN(int posicion){
Object datoAremover;
Nodo actual;
if (ListaVacia()==true){
return null;
}
else{
if(posicion==1){
datoAremover=prim.sgte;
return datoAremover;
} else{
actual=prim;
int cont = 1;
while ((Actual.sgte !=null)&&(cont<posicion-1)){
actual=actual.sgte;
cont++;
}
if((Actual.sgte !=null)&&(cont==posicion-1)){
datoAremover=actual.sgte.datos;
actual.sgte=actual.sgte.sgte;
return datoAremover;
}
}
return null;
}
}
}
4. Clase cola
public class Cola {
private Lista listaCola;
public Cola(){
listaCola = new Lista("cola");
}
public void IncertarFrente(Object objeto){
listaCola.IncertFrente(objeto);
}
public Object DelFrente(){
return listaCola.DelFrente();
}
public boolean estaVacia(){
return listaCola.ListaVacia();
}
}
LISTAS ENLAZADAS DOBLES
Listas doblemente enlazadas.
Las listas doblemente enlazadas consisten en datos y enlaces tanto al elemento siguiente como al elemento anterior. Con lo que se consiguen dos grandes ventajas, primero la lista se puede leer en cualquier dirección, la segunda es que se pueden leer los enlaces hacia delante como hacia atrás, con lo que si un enlace resulta no valido se puede reconstruir utilizando el otro enlace.
Como en las listas simplemente enlazadas, las doblemente enlazadas pueden contener una función que almacene cada elemento en una posición específica de la lista a medida que esta se construye, en lugar de colocar cada elemento al final de la lista.
Una lista doblemente enlazada es una lista lineal en la que cada nodo tiene 2 enlaces un nodo llamado siguiente y otro nodo llamado anterior.-
LAS OPERACIONES SOBRE ESTE TIPO DE LISTAS SON LAS SIGUIENTES
Añadir un elemento a una lista doblemente enlazada vacía.
Insertar un elemento en la primera posición de la lista.
Insertar un elemento en la última posición en la lista.
Insertar un elemento a continuación d4e un nodo cualquiera de una lista.
Buscar o localizar elementos.
Borrado de elementos.
a) Eliminar único elemento de una lista doblemente enlazada.
b) Eliminar el primer elemento de la lista doblemente enlazada.
c) Eliminar el último elemento de una liara doblemente enlazada.
d) Eliminar un elemento intermedio de una lista doblemente enlazada.
BUSCAR O LOCALIZAR ELEMENTOS
Para recorrer una lista se procederá de un modo parecido al que se usa con las listas lineales, pero se tiene que tener encuentra que la lista no siempre tiene que estar en uno de sus extremos.-
LOS PASOS DE LA BUSQUEDA SON LOS SIGUIENTES
Retroceder hasta el comienzo de la lista, asignar el valor de la lista---anterior mientras lista anterior no sea NULL. WHILE (anterior! = NULL o -999).-
Se abre un ciclo en donde al menos la condición debe de ser que el índice no sea NULL.(ciclos pasos repetitivos).
Dentro del bucle (ciclo) asignaremos a la lista el valor del nodo siguiente al actual.
LISTAS LIGADAS CIRCULARES
Es una lista lineal en la que el último nodo apunta al primero.
Las listas circulares editan excepciones en las operaciones que se realicen sobre ellas, en algunas listas circulares se añade un nodo especial de tipo cabecera, de ese modo se evita que la lista este vacía., esto significa que una lista enlazada circular es muy similar a una lista ligada simple en lo que varía es que el ultimo elemento apunta a su siguiente como el primero.-
ESTRUCTURAS NO LINEALES
INTRODUCCION DE ARBOLES
Hasta el momento solo hemos visto estructuras lineales estáticas y dinámicas de datos, es decir a un elemento, al analizar la estructura árbol se introduce el concepto de estructura de ramificación entre nodos.-
Un árbol consiste en un conjunto de nodos y un conjunto de aristas, de forma que:
Se distingue un nodo llamado raíz
A cada nodo h, excepto la raíz, le llega una arista de otro nodo p (p padre de h, h uno de los hijos de p)
Para cada nodo hay un camino (secuencia de aristas) único desde la raíz.
Las listas ligadas ofrecen grandes ventajas de flexibilidad sobre la representación contigua de las estructuras de datos, pero adolecen de una característica débil que son las listas secuenciales, ósea están arregladas de modo que se necesitan mover por ellas solo una posición a la vez. Las aplicaciones se basan en problemas de recuperación de información
DEFINICION DE ARBOLES BINARIOS
Un árbol binario en donde cada nodo puede tener como máximo 2 sub árboles y siempre es necesario distinguir entre el sub árbol izquierdo y el sub árbol derecho formalmente un árbol binario T se define como un conjunto de finitos de elementos llamados nodos, de forma que:a) T es vacío (en cuyo caso se llama árbol nulo o árbol vacío).
b) T tiene un nodo distinguido llamado R, que en este caso es la raíz de T, y los restantes nodos de T forman un par ordenado de árboles binarios disjuntos llamados T1 Y T2.-
Cada nodo puede tener como máximo solo 2 hijos.
REPRESENTACION DE ARBOL
En particular, el siguiente diagrama representa un árbol binario T de la forma que sigue:
a) T 11 nodos representados por la letra de la A a la L excluyendo la letra i.
b) La raíz del árbol T es el nodo A, se encuentra en la parte superior del programa.-
c) Una línea hacia abajo ya sea izquierda o derecha señala un sucesor izquierdo o derecho.-
TERMINOLOGIA DE ARBOLES BINARIOS
PADRE: suponga que n que es un nodo de T como un sucesor izquierdo si un sucesor derecho S2 entonces n se llama padre de S1 Y S2 cada nodo n de un árbol binario T excepto la raíz, tiene un único padre llamado n.
HIJO: analógicamente si n es el padre de S1 Y S2, entonces S1 es el hijo izquierdo y S2 es el hijo derecho.-
HERMANOS: S1 Y S2 se dicen que son hermanos ya que son hijos del mismo padre.-
DESCENDIENTE Y ANTECESOR: si un nodo L se dice descendiente de un nodo n y n se dice antecesor de L si existe una sucesión de hijos desde n hasta L, en particular L puede ser descendiente izquierda de n dependiendo si pertenece al subárbol izquierdo o derecho de n
RECORRIDO DE UN ARBOL BINARIO
Se denomina recorrido de un árbol el proceso que permite acceder una sola vez a cada uno de los nodos del árbol. Cuando un árbol se recorre, el conjunto completo de nodos se examina.
Existen muchos modos para recorrer un árbol binario. Por ejemplo existen seis diferentes recorridos generales en un árbol binario simétricos dos a dos.
Los algoritmos de recorrido de un árbol binario representan tres tipos de actividades comunes:
• Visitar el nodo raíz
• Recorrer el subárbol izquierdo
• Recorrer el subárbol derecho
o Pre-Orden
o In-Orden
o Post-Orden
RECORRIDO PRE-ORDEN
Pre-Orden (raíz-izq-der)
Pre-Orden: A-B-D-E-C-F-G
1- Visitar el nodo raíz
2- Recorrer el subárbol derecho en pre-orden
3- Recorrer el subárbol derecho en pre-orden
RECORRIDO IN-ORDEN
In-Orden (izq-raíz-der)
In-Orden: D-B-E-A-F-C-G
1- Recorrer el subárbol izquierdo en in-orden
2- Visitar la raíz
3- Recorrer el subárbol derecho en in-orden
RECORRER POST-ORDEN
Post-Orden (izq-der-raíz)
Post-Orden: D-E-B-F-G-C-A
1- Recorrer el subárbol derecho en post-orden
2- Recorrer el subárbol derecho en postorden
3- Visitar la raíz
IMPLEMENTACION
Clase NODO
public class Nodo {
private Nodo pd;
private Object dato;
private Nodo pi;
public Nodo(Object dato){
this.dato=dato;
pd=null;
pi=null;
}
public Object getDato() {return dato;}
public void setDato(Object dato) {this.dato = dato;}
public Nodo getPd() {return pd;}
public void setPd(Nodo pd) {this.pd = pd;}
public Nodo getPi() {return pi;}
public void setPi(Nodo pi) {this.pi = pi;}
}
CLASE ARBOL
public class Arbol {
private Nodo Raiz;
public Arbol(){ Raiz=null;}
// insertar(Raiz, Raiz, x)
public boolean arbolVacio(){return Raiz == null;}
public void insertar(Nodo ant, Nodo p, Nodo x){
if (p != null){
if (Integer.parseInt(x.getDato().toString()) > Integer.parseInt(p.getDato().toString())) {
insertar(p, p.getPd(), x);
}else{
insertar(p, p.getPi(), x);
}
}else{
if (arbolVacio()){
Raiz = x;
}else{
if (Integer.parseInt(x.getDato().toString()) > Integer.parseInt(ant.getDato().toString())) {
ant.setPd(x);
}else {
ant.setPi(x);
}
}
}
}
public void imprimir(Nodo p){
if(p != null){
imprimir(p.getPi());
System.out.print(p.getDato()+"; ");
imprimir(p.getPd());
}
}
public Nodo getRaiz() {
return Raiz;
}
public void setRaiz(Nodo raiz) {
Raiz = raiz;
}
public void eliminar(Nodo ant, Nodo p){
if(esNodoHoja(p)){
eliminarNodoHoja(ant, p);
}else{
if (esNodoCon2SubArboles(p)){
eliminarNodoCon2SubArboles(ant, p);
}else{
eliminarNodoCon1SubArnol(ant, p);
}
}
}
public void eliminarNodoHoja(Nodo ant, Nodo p){
if (Raiz != p){
if(ant.getPd() == p){
ant.setPd(null);
}else{
ant.setPi(null);
}
}else{
Raiz = null;
}
}
public void eliminarNodoCon1SubArnol(Nodo ant, Nodo p){
if (Raiz == p){
if(p.getPd() != null){
Raiz = Raiz.getPd();
}else{
Raiz = Raiz.getPi();
}
}else{
if ( ant.getPd() == p){
if(p.getPd() != null){
ant.setPd(p.getPd());
}else{
ant.setPd(p.getPi());
}
}else{
if(p.getPd() != null){
ant.setPi(p.getPd());
}else{
ant.setPi(p.getPi());
}
}
}
}
public boolean esNodoHoja(Nodo p){return (p.getPi() == null && p.getPd() == null);}
public boolean esNodoCon2SubArboles(Nodo p){return (p.getPi() != null && p.getPd() != null);}
CLASEARBOLAPLICACION
import java.io.*;
import java.io.InputStreamReader;
public class ArbolAplicacion {
Arbol miArbol;
BufferedReader entrada;
public ArbolAplicacion(){
miArbol = new Arbol();
entrada = new BufferedReader(new InputStreamReader(System.in));
}
public void generar()throws Exception{
// Nodo p = miArbol.getRaiz();
char op='s';
while(op !='n' && op!='N'){
System.out.println(" Ingrese elemento");
Object elem = entrada.readLine();
Nodo x = new Nodo(elem);
miArbol.insertar(miArbol.getRaiz(), miArbol.getRaiz(), x);
System.out.println(" Continuar enter/ n");
String opcion=entrada.readLine();
opcion=opcion.equals("")?"a":opcion;
op = opcion.charAt(0);
}
}
public void eliminarNodo()throws Exception{
// Nodo p = miArbol.getRaiz();
char op='s';
while(op !='n' && op!='N'){
System.out.println(" Ingrese elemento");
Object elem = entrada.readLine();
Nodo x=new Nodo(elem);
// Buscar
buscarEnElArbol(miArbol.getRaiz(), miArbol.getRaiz(), x);
System.out.println(" Continuar enter/ n");
String opcion=entrada.readLine();
opcion=opcion.equals("")?"a":opcion;
op = opcion.charAt(0);
}
}
public void buscarEnElArbol(Nodo ant, Nodo p, Nodo x){
if(p!=null){
if(Integer.parseInt(x.getDato().toString())==Integer.parseInt(p.getDato().toString())){
miArbol.eliminar(ant, p);
}else{
if(Integer.parseInt(x.getDato().toString())>Integer.parseInt(p.getDato().toString())){
buscarEnElArbol(p,p.getPd(),x);
}else{
buscarEnElArbol(p,p.getPi(),x);
}
}
}
}
public void imprimirArbol(){
System.out.println("=====================");
System.out.println("Elementos del arbol");
miArbol.imprimir(miArbol.getRaiz()) ;
System.out.println("");
System.out.println("=====================");}
public void mostrarOpciones(){
System.out.println("=================");
System.out.println(" Opciones de Arbol");
System.out.println("1- Generar");
System.out.println("2- Eliminar");
System.out.println("3- Imprimir");
System.out.println("Ingrese su opciones:"); }
public void menu()throws Exception{
int op = 9;
do{
switch (op) {
case 1: generar(); break;
case 2: eliminarNodo(); break;
case 3: imprimirArbol(); break;}
mostrarOpciones();
String opc = entrada.readLine();
opc = opc.equals("")?"9":opc;
op=Integer.parseInt(opc);
}while(op!=0);
}
public static void main(String[] args)throws Exception {
ArbolAplicacion mi=new ArbolAplicacion();
mi.menu();
}
}
CLASE PRINCIPAL
public class Principal {
public static void main(String[] args) throws Exception {
ArbolAplicacion miA=new ArbolAplicacion();
miA.menu();
GRAFOS
Un grafo como un conjunto finito de puntos (nodos, vértices), algunos conectados por líneas (llamadas aristas).
Un gráfico dirigido es un conjunto finito de puntos, algunos de los cuales están conectados mediante flechas, éstas determinan la orientación de las aristas.
APLICASIONES
public class DibujarPoligonos extends JFrame {
// establecer cadena de barra de título y dimensiones de la ventana
public DibujarPoligonos()
{
super( "Dibujo de polígonos" );
setSize( 275, 230 );
setVisible( true );
}
// dibujar polígonos y polilíneas
public void paint( Graphics g ) {
super.paint( g ); // llamar al método paint de la superclase
int valoresX[] = { 20, 40, 50, 30, 20, 15 };
int valoresY[] = { 50, 50, 60, 80, 80, 60 };
Polygon poligono1 = new Polygon( valoresX, valoresY, 6 );
g.drawPolygon( poligono1 );
int valoresX2[] = { 70, 90, 100, 80, 70, 65, 60 };
int valoresY2[] = { 100, 100, 110, 110, 130, 110, 90 };
g.drawPolyline( valoresX2, valoresY2, 7 );
int valoresX3[] = { 120, 140, 150, 190 };
int valoresY3[] = { 40, 70, 80, 60 };
g.fillPolygon( valoresX3, valoresY3, 4);
Polygon poligono2 = new Polygon();
poligono2.addPoint( 165, 135 );
poligono2.addPoint( 175, 150 );
poligono2.addPoint( 270, 200 );
poligono2.addPoint( 200, 220 );
poligono2.addPoint( 130, 180 );
g.fillPolygon( poligono2 );
} // fin del método paint
// ejecutar la aplicación
public static void main( String args[] ) {
DibujarPoligonos aplicacion = new DibujarPoligonos();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}
