Arbol binario de búsqueda Vehiculo ordensim(p.

hizq); return A;} public class Operaciones {

public class Arbol System.out.println("\nVehiculo"); // B //insertar Nnodos
{Nodo raiz; p.dato.mostrar(); public void ordenSim(Nodo p){ public Lista insertarN(Lista L) {
public Arbol() ordensim(p.hder);} if(p!=null){ System.out.println("Cantidad Nodos: ");
{raiz=null;} } ordenSim(p.hizq); int n = Leer.datoInt();
public void inicializar() public void Busqueda(Arbol A,String placa){ System.out.println(p.dato); Vehiculo v=null;
{raiz=null;} Nodo p = A.raiz; ordenSim(p.hder);} for (int c = 1; c <= n; c++) {
public boolean arbolVacio(){ while(p.clave.compareTo(placa)!=0 && p!=null){ } System.out.println("Vehiculo"+c+": ");
return raiz == null;} if(p.clave.compareTo(placa)>0) // C v = new Vehiculo();
public void insertar(String c , Vehiculo d){ {p=p.hizq;} public void busqueda(Arbol A, int cb){ v.leer();
Nodo nuevo=new Nodo(c,d); else Nodo p = A.raiz; L.insertar(v);
if(arbolVacio()){ {p=p.hder;} while(p.clave!=cb && p!=null){ }
raiz=nuevo;} } if (p.clave>cb) p=p.hizq; return L;
else{ if(p!=null){ else p=p.hder;} }
Nodo p= raiz ,q=null; System.out.println("NODO NO LOCALIZADO"); if (p==null) System.out.println("Nodo no //Mostrar
while(p!=null){ } encontrado"); public void mostrar(Lista L) {
q=p; else{System.out.println("Vehiculo = "); else System.out.println("DATO = "+p.dato);} //recorrer la lista
if(p.clave.compareTo(c)>0){ p.dato.mostrar();} public void Negativo(Nodo p){ Nodo p = L.primero;
p = p.hder;} } if(p!=null){ while (p.sig != null) {
else{ public void placaMarca(Nodo p,int modelo){ if(p.dato<0){ p.dato.mostrar();
p=p.hder;} if(p!=null){ Negativo(p.hizq); p = p.sig;
} if(p.dato.getModelo()==modelo){ Negativo(p.hder); }
if(q.clave.compareTo(c)>0){ System.out.println("\nVehiculo:"); System.out.println(p.dato);} }
q.hizq=nuevo;} System.out.println("Placa: "+p.clave); } //mostrar la placa del modelo mas reciente
else { System.out.println("Marca: "+p.dato.getMarca()); } public void reciente(Lista L) {
q.hder=nuevo;} } int g =0; Nodo p=L.primero;
}}} placaMarca (p.hizq, modelo); double sum = 0; int m=p.dato.getModelo();
public class Vehiculo{ placaMarca (p.hder, modelo);} public void prom (Arbol A){ while(p.sig!=null) {
private String marca; } calculo(A.raiz); if(p.dato.getModelo()>m)m=p.dato.getModelo();
private int modelo; public void contarMarca (Nodo p, String marca) { System.out.println("SUMA "+sum/g);} p=p.sig;
public Vehiculo(){ if(p!=null) { public void calculo(Nodo p){ }
marca=null; if(p.dato.getMarca().compareTo(marca)==0) if(p!= null){ p=L.primero;
modelo=0;} {contador++;} if(p.dato>0){ while(p.sig!=null) {
public Vehiculo(String vmarca, int vmodelo){ contarMarca (p.hizq, marca); sum = sum + p.dato; if(p.dato.getModelo()==m)System.out.println(p.da
marca=vmarca; contarMarca (p.hder, marca);} g=g+1;} to.getPlaca());
modelo=vmodelo;} } //visitar el subarbol izq p=p.sig;
public void leer(){ public void calculoModeloAntiguo (Nodo p) calculo(p.hizq); }
System.out.println("ingrese marca"); { //visitar el subarbol derecho
marca=Leer.dato(); if(p!=null){ calculo(p.hder);} }
System.out.println("ingrese modelo"); if(p.dato.getModelo()<antiguo){ } //Insertar un nodo al final de la lista
modelo=Leer.datoInt();} antiguo=p.dato.getModelo();} double mayNeg=-100000; public void insertarFin(Lista L, Vehiculo x) {
public void mostrar(){ calculoModeloAntiguo (p.hizq); public void mayorNegativo(Nodo p){ if(L.listaVacia()) {
System.out.println("MARCA = "+marca); calculoModeloAntiguo (p.hder);} if(p!=null){ //lista vacia
System.out.println("MODELO = "+modelo);} } if(p.dato<0) L.insertar(x);
public String getMarca(){ public void placaModeloAntiguo (Arbol A, Nodo p) {if(p.dato>mayNeg) }else {
return marca;} { {mayNeg=p.dato;} //Lista no vacia= recorrer la lista para obtener la
public int getModelo(){ calculoModeloAntiguo (A.raiz); } direccion del ultimo nodo
return modelo;} if (p!=null) { mayorNegativo(p.hizq); Nodo p=L.primero;
} if (p.dato.getModelo() == antiguo){ mayorNegativo(p.hder);} while(p.sig!=null)p=p.sig;
class Principal System.out.println("\nVehiculo: "); } L.insertar2(p, x);
{public static void main (String [] args) System.out.println("Placa: "+p.clave); }--------------------------------------- }
{Operaciones op = new Operaciones(); } LISTA ENLAZADA }
Arbol arbol = new Arbol(); placaModeloAntiguo(A, p.hizq); public class Lista { //eliminar un nodo con una placa dada (b)
arbol = op.insertarN(arbol); placaModeloAntiguo(A, p.hder);} Nodo primero; public void eliminarPlaca(Lista L, String b) {
System.out.println("Orden Simetrico: "); } public Lista() { if(b.compareTo(L.primero.dato.getPlaca())==0) {
op.ordensim(arbol.raiz); } primero=null; //caso 1
System.out.print("Introduzca la Placa "); public class Nodo { }public void inicializar() { L.eliminar();
String placa = Leer.dato(); Vehiculo dato; primero=null; }else {
op.Busqueda(arbol, placa); Nodo hizq; }public boolean listaVacia() { //caso 2:recorrer la lista hasta situarse en el nodo
System.out.print("Mostrar Placa y Marca de Nodo hder; return primero==null; anterioral que tiene placa b
Vehiculos de una Marca Dada: "); String clave; }public void insertar (Vehiculo x) { Nodo p=L.primero;
int modelo = Leer.datoInt(); public Nodo(){ Nodo nuevo=new Nodo (x); while((p!=null)&&(b.compareTo(p.sig.dato.getPlac
op.placaMarca(arbol.raiz, modelo); dato = null; nuevo.sig=primero; a())!=0)) {
System.out.print("Numero de Vehiculos dada hder = hizq=null; primero=nuevo; p=p.sig;
marca "); clave=null;} }public void eliminar() { }
String marca = Leer.dato(); public Nodo(String vc,Vehiculo vd){ if(!listaVacia()) { if(p==null) {
op.contarMarca(arbol.raiz, marca); hder= hizq = null; primero=primero.sig; System.out.println("Nodo no alcanzado");
System.out.println(" Vehiculo "+marca+" es = clave = vc; } }else {
"+op.contador); dato = vd; } L.eliminar2(p);
System.out.println("Modelo mas Antiguo: "); } public void insertar2(Nodo pos, Vehiculo x) { }
op.placaModeloAntiguo(arbol, arbol.raiz); } Nodo nuevo= new Nodo(x); }
} /* nuevo.sig=pos.sig; }
}public class Operaciones{ * A = Insertar N nodos pos.sig=nuevo; }public class Principal {
int contador =0; * B = Mostrar en orden Simetrico } public static void main(String[] args) {
int antiguo = 2018; * C = Buscar el nodo dada su clave public void eliminar2(Nodo pos) { Operaciones op=new Operaciones();
* D = Mostrar los datos negativos pos.sig=pos.sig.sig; Vehiculo ve=new Vehiculo();
public Arbol insertarN(Arbol A){ * E = Promdio de los positivos } Lista lis=new Lista();
System.out.println("ingrese e numero de nodos"); * F = Mayor de los negativos } lis=op.insertarN(lis);
int n = Leer.datoInt(); */ public class Nodo { op.mostrar(lis);
Vehiculo d; public class Operaciones Vehiculo dato; op.reciente(lis);
for(int i=1;i<=n;i++){ { // A Nodo sig; ve.leer();
System.out.println(" CLAVE -placa- "+i+" = "); public Arbol insertar(Arbol A){ public Nodo() { op.insertarFin(lis, ve);
String c=Leer.dato(); System.out.println(" No. de Nodos "); dato = null; op.mostrar(lis);
System.out.println("Vehiculo"+i+" = " ); int n = Leer.datoInt(); sig = null; System.out.println("Placa para eliminar: ");
d=new Vehiculo(); for(int i = 1; i <= n ; i++){ } String a=Leer.dato();
d.leer(); System.out.print("CLAVE "+i+" = "); public Nodo(Vehiculo vdato) { op.eliminarPlaca(lis, a);
A.insertar(c, d);} int c = Leer.datoInt(); dato = vdato; op.mostrar(lis);
return A;} System.out.print("DATO "+i+" = "); sig = null; }
public void ordensim (Nodo p) { double d = Leer.datoDouble(); } }
if (p!=null) { A.insertar(c, d);} }
/////CLASE NODO Nodo p = null; dato = null; public boolean grafoVacio() {
class Nodo String N; sig = ant = null; return nv == 0;
{int dato; OperCola opc = new OperCola(); }public Nodo(String d) { }
Nodo sig; Cola CERR = new Cola(); dato = d;
public Nodo() Cola ABI = new Cola(); sig = ant = null; public void insertarArista() {
{dato = 0; ABI.insertar(vin); }} System.out.print("Vertice origen=");
sig = null; while (!ABI.colaVacia()) { //CLASE GRAFOL int vo = Leer.datoInt();
} public Nodo(int d) N = ABI.ver(); class GrafoL { System.out.print("Vertice destino=");
{dato = d; CERR.insertar(N); NodoG graf; int vd = Leer.datoInt();
sig = null; ABI.eliminar(); public GrafoL() { mady[vo][vd] = 1;
}} r = g.localiza(N); graf = null; }
////CLASE PILA if (r != null) }public boolean grafoVacio() {
class PilaLista p = r.vec; return graf == null; public void insertarVertice() {
{Nodo CIMA; while (p != null) { }public void insertar(String x) { System.out.print("No. vertice=");
public PilaLista() if (!opc.pertenece(ABI, p.dato) && NodoG nuevo = new NodoG(x); int v = Leer.datoInt();
{CIMA = null; !opc.pertenece(CERR, p.dato)) if (grafoVacio()) System.out.print("Dato del Vertice=");
} public void inicializar() ABI.insertar(p.dato); graf = nuevo; String dt = Leer.dato();
{CIMA = null; p = p.sig;} else { vertice[v] = dt;
} public boolean pilaVacia() }opc.mostrar(CERR); NodoG p = graf; }
{return CIMA == null; }public void listaAdyacente(GrafoL g) { while (p.sigx != null)
} public Nodo ver() NodoG p = g.graf; p = p.sigx; public int posicion(String dt) {
{return CIMA; Nodo q; p.sigx = nuevo; int pos = 0;
} public void insertar (int x) while (p != null) { }String dt; for (int i = 1; i <= nv; ++i) {
{Nodo nuevo = new Nodo (x); System.out.println("Dato= " + p.datox); System.out.print("No. vecinos: "); if (dt.compareTo(vertice[i]) == 0)
nuevo.sig = CIMA; q = p.vec; int mv = Leer.datoInt(); pos = i;
CIMA = nuevo; while (q != null) { for (int i = 1; i <= mv; ++i) { }
} public void eliminar() System.out.println("Dato Vecino= " + q.dato); System.out.print("Dato Vecino " + i + " : "); return pos;
{if (!pilaVacia()) q = q.sig; dt = Leer.dato(); }
{CIMA=CIMA.sig; }p = p.sigx; nuevo.vec = insertarVec(nuevo.vec, dt); }
} }} }}} }} //CLASE OPERGRAFO
///CLASE OPERACIONES //CLASE OPERCOLA public Nodo insertarVec(Nodo qv, String y) { class OperGrafo {
class Operaciones class OperCola { Nodo novo = new Nodo(y); public Grafo insertarN(Grafo g) {
{public PilaLista insertarN (PilaLista p) public Cola insertarN(Cola p) { if (qv == null) System.out.print("No. vertices=");
{System.out.print("Numero de Datos: "); System.out.print("No. elementos: "); qv = novo; int n = Leer.datoInt();
int n = Leer.datoInt(); int n = Leer.datoInt(); else { g.asignaV(n);
int d; String dt; Nodo p = qv; for (int i = 1; i <= n; ++i) {
for (int c=1;c<=n;++c) for (int i = 1; i <= n; ++i) { while (p.sig != null) g.insertarVertice();
{System.out.print("Dato "+c+": "); System.out.print("Dato " + i + " : "); p = p.sig; }
d = Leer.datoInt(); dt = Leer.dato(); p.sig = novo;} System.out.print("No. de aristas=");
p.insertar(d); p.insertar(dt); return qv;} int na = Leer.datoInt();
} return p; }return p; public NodoG localiza(String db) { for (int i = 1; i <= na; ++i) {
}public PilaLista mostrar (PilaLista p) }public void mostrar(Cola p) { NodoG p = graf; g.insertarArista();
{PilaLista paux = new PilaLista(); Cola aux = new Cola(); while (p != null && p.datox.compareTo(db) != 0) }
Nodo d; String d; p = p.sigx; return g;
while (!p.pilaVacia()) while (!p.colaVacia()) { return p; }
{d=p.ver(); d = p.ver(); }}
System.out.println(d.dato); System.out.println(d); //CLASE COLA public void horizontal(Grafo g, String vin) {
p.eliminar(); p.eliminar(); class Cola { OperCola opc = new OperCola();
paux.insertar(d.dato); aux.insertar(d); Nodo frente, fin; Cola CERR = new Cola();
} while (!paux.pilaVacia()) }while (!aux.colaVacia()) { public Cola() { Cola ABI = new Cola();
{d=paux.ver(); d = aux.ver(); frente = fin = null; ABI.insertar(vin);
paux.eliminar(); aux.eliminar(); }public boolean colaVacia() { int f;
p.insertar(d.dato); p.insertar(d); return frente == null; String N;
}return p; }} }public String ver() { while (!ABI.colaVacia()) {
}} public boolean pertenece(Cola p, String x) { return frente.dato; N = ABI.ver();
///CLASE PRINCIPAL Cola aux = new Cola(); }public void insertar(String x) { f = g.posicion(N);
class Principal boolean sw = false; Nodo nuevo = new Nodo(x); CERR.insertar(N);
{public static void main (String [] args) String d; if (colaVacia()) ABI.eliminar();
{Operaciones op = new Operaciones(); while (!p.colaVacia()) { frente = fin = nuevo; for (int c = 1; c <= g.nv; ++c) {
PilaLista pila = new PilaLista(); d = p.ver(); else { if (g.mady[f][c] == 1)
pila = op.insertarN(pila); p.eliminar(); fin.sig = nuevo; if (!opc.pertenece(ABI, g.vertice[c]) &&
System.out.println("\nLa Pila Es: "); if (d.compareTo(x) == 0) nuevo.ant = fin; !opc.pertenece(CERR, g.vertice[c]))
op.mostrar(pila); sw = true; fin = nuevo; ABI.insertar(g.vertice[c]);
}}------------------------------------- aux.insertar(d); }} }
//PRINCIPAL }while (!aux.colaVacia()) { public void eliminar() { }
public class Principal { d = aux.ver(); if (fin == frente) opc.mostrar(CERR);
public static void main(String[] args) { aux.eliminar(); fin = frente = null; }
GrafoL g = new GrafoL(); p.insertar(d); else { }
OperGrafoL op = new OperGrafoL();5fnhmuyv }return sw; frente = frente.sig; //CLASE PRINCIPAL
g = op.insertarN(g); } frente.ant = null; public class Principal {
System.out.print("vertice inicial= "); } //CLASE NODOG } public static void main(String[] args) {
String vi = Leer.dato(); class NodoG { } Grafo g = new Grafo();
op.horizontal(g, vi); String datox; } OperGrafo op = new OperGrafo();
op.listaAdyacente(g); NodoG sigx; //CLASE GRAFO g = op.insertarN(g);
} Nodo vec; class Grafo { System.out.print("Vertice Inicial:");
} public NodoG() { int[][] mady; String vini = Leer.dato();
//CLASE OPERGRAFOL datox = null; String[] vertice; op.horizontal(g, vini);
class OperGrafoL { sigx = null; int nv; }
public GrafoL insertarN(GrafoL g) { vec = null; final int nel = 20; }
System.out.print("No. vertices: "); }public NodoG(String d) {
int n = Leer.datoInt(); datox = d; public Grafo() {
String dt; sigx = null; nv = 0;
for (int i = 1; i <= n; ++i) { vec = null; mady = new int[nel][nel];
System.out.print("Dato " + i + " : "); }} vertice = new String[nel];
dt = Leer.dato(); //CLASE NODO }
g.insertar(dt); class Nodo {
}return g; String dato; public void asignaV(int ne) {
}public void horizontal(GrafoL g, String vin) { Nodo sig, ant; nv = ne;
NodoG r; public Nodo() { }