1 /*

2 * To change this license header, choose License Headers in Project Properties.

3 * To change this template file, choose Tools | Templates
4 * and open the template in the editor.
5 */
6 package edd_proyecto2;
7
8 /**
9 *
10 * @author chiqu
11 */
12 import java.io.FileWriter;
13 import java.io.IOException;
14 import java.io.PrintWriter;
15 import javax.swing.JOptionPane;
16
17 public class Vehiculos_ArbolB {
18
19 //aqui si se toma todo como que fuera un arbol normal
20 String Primero;
21 String ReporteG1;
22 String ReporteG2;
23 String ReporteGTotal;
24 public Vehiculos_Rama raiz;
25 //String flechasarbolfilas = "";
26 private String flechasarbolfilas = "", flechasarbolcolumnas = "",
flechascontenido = "";
27
28 public Vehiculos_ArbolB() {
29
30 this.raiz = null;
31 }
32
33 public void insertar(String vehiculo_placa, String vehiculo_marca, String
vehiculo_modelo, String vehiculo_ano, String vehiculo_color, String
vehiculo_precio, String vehiculo_TipoTransmision) {
34 boolean existe = VerificarExistenciaDeIndice(false, raiz, vehiculo_placa);
35 if (existe == false) {
36 Vehiculos_NodoB nodo = new Vehiculos_NodoB(vehiculo_placa,
vehiculo_marca, vehiculo_modelo, vehiculo_ano, vehiculo_color,
vehiculo_precio, vehiculo_TipoTransmision);
37 if (raiz == null) {
38 raiz = new Vehiculos_Rama();
39 raiz.insertar(nodo);
40 } else {
41 if (raiz.isHoja()) {
42 raiz.insertar(nodo);
43 verificarcuenta(raiz, null);
44 } else {
45 insertar_recursivo(nodo, raiz, null);
46 }
47 }
48 }
49 }
50
51 public void insertar_recursivo(Vehiculos_NodoB nodo, Vehiculos_Rama rama,
Vehiculos_Rama anterior) {
52
53 if (rama.isHoja()) {
54 rama.insertar(nodo);
55 } else {
56 Vehiculos_NodoB temp = rama.getPrimero();
57 while (temp != null) {
58
59 if (nodo.getVehiculo_placa().compareTo(temp.getVehiculo_placa()) <
0) {
60 insertar_recursivo(nodo, temp.getIzquierda(), rama);
61 break;
62 } else if (temp.getSiguiente() == null) {
63 insertar_recursivo(nodo, temp.getDerecha(), rama);
64 break;
65 }
66 temp = temp.getSiguiente();
 67 }
68 }
69 //se verifica si la cuenta es menor a 5
70 //esto se hace porque el arbol es de grado 5
71 verificarcuenta(rama, anterior);
72 }
73
74 public void verificarcuenta(Vehiculos_Rama rama, Vehiculos_Rama anterior) {
75 if (rama.getCuenta() > 4) {
76 if (anterior != null) {
77 anterior.insertar(dividir(rama));
78 anterior.setHoja(false);
79 } else {
80 if (rama == raiz) {
81 Vehiculos_Rama nueva = new Vehiculos_Rama();
82 nueva.insertar(dividir(raiz));
83 raiz = nueva;
84 raiz.setHoja(false);
85 }
86 }
87 }
88
89 }
90
91 private Vehiculos_NodoB dividir(Vehiculos_Rama rama) {
92
93 Vehiculos_Rama padre = new Vehiculos_Rama();
94 Vehiculos_Rama izquierda = new Vehiculos_Rama();
95 Vehiculos_Rama derecha = new Vehiculos_Rama();
96 int n = 1;
97
98 Vehiculos_NodoB aux = rama.getPrimero();
99 while (aux != null) {
100 if (n < 3) {
101 Vehiculos_NodoB temp = new Vehiculos_NodoB(aux.getVehiculo_placa(),
aux.getVehiculo_marca(), aux.getVehiculo_modelo(),
aux.getVehiculo_ano(), aux.getVehiculo_color(),
aux.getVehiculo_precio(), aux.getVehiculo_TipoTransmision());
102 temp.setIzquierda(aux.getIzquierda());
103 temp.setDerecha(aux.getDerecha());
104
105 izquierda.insertar(temp);
106 if (temp.getIzquierda() != null || temp.getDerecha() != null) {
107 izquierda.setHoja(false);
108 }
109 } else if (n == 3) {
110 Vehiculos_NodoB temp = new Vehiculos_NodoB(aux.getVehiculo_placa(),
aux.getVehiculo_marca(), aux.getVehiculo_modelo(),
aux.getVehiculo_ano(), aux.getVehiculo_color(),
aux.getVehiculo_precio(), aux.getVehiculo_TipoTransmision());
111 padre.insertar(temp);
112 } else if (n < 6) {
113 Vehiculos_NodoB temp = new Vehiculos_NodoB(aux.getVehiculo_placa(),
aux.getVehiculo_marca(), aux.getVehiculo_modelo(),
aux.getVehiculo_ano(), aux.getVehiculo_color(),
aux.getVehiculo_precio(), aux.getVehiculo_TipoTransmision());
114 temp.setIzquierda(aux.getIzquierda());
115 temp.setDerecha(aux.getDerecha());
116 derecha.insertar(temp);
117 if (temp.getIzquierda() != null || temp.getDerecha() != null) {
118 derecha.setHoja(false);
119 }
120 }
121 n++;
122 aux = aux.getSiguiente();
123 }
124 padre.getPrimero().setDerecha(derecha);
125 padre.getPrimero().setIzquierda(izquierda);
126
127 return padre.getPrimero();
128 }
129
130 public void recorrer(String vehiculo_placa) {
131
132 recorrerrecursivo(raiz, vehiculo_placa);
133 }
134
135 public void recorrerrecursivo(Vehiculos_Rama rama, String placa) {
136
137 if (rama != null) {
138
139 Vehiculos_NodoB aux = rama.getPrimero();
140 while (aux != null) {
141
142 recorrerrecursivo(aux.getIzquierda(), placa);
143 if (aux.getVehiculo_placa().equals(placa)) {
144 System.out.print(aux.getVehiculo_placa() + " " +
aux.getVehiculo_marca() + "");
145 //System.out.println(placa);
146 }
147
148 if (aux.getSiguiente() == null) {
149 recorrerrecursivo(aux.getDerecha(), placa);
150 }
151 aux = aux.getSiguiente();
152 }
153 }
154
155 }
156
157 public boolean VerificarExistenciaDeIndice(boolean existe, Vehiculos_Rama rama,
String n) {
158
159 if (rama != null && existe == false) {
160
161 Vehiculos_NodoB aux = rama.getPrimero();
162 while (aux != null) {
163
164 if (existe) {
165 break;
166 }
167
168 existe = VerificarExistenciaDeIndice(existe, aux.getIzquierda(), n);
169
170 //aqui digo si existe o no
171 if (n.equals(aux.getVehiculo_placa())) {
172 return true;
173 }
174
175 if (aux.getSiguiente() == null) {
176 existe = VerificarExistenciaDeIndice(existe, aux.getDerecha(), n);
177 }
178 aux = aux.getSiguiente();
179 }
180
181 }
182
183 return existe;
184 }
185
186 public Vehiculos_NodoB buscarindice(String valor) {
187
188 return buscarindice_recursivo(valor, raiz, null);
189 }
190
191 private Vehiculos_NodoB buscarindice_recursivo(String placa, Vehiculos_Rama
rama, Vehiculos_NodoB aux) {
192 Primero = "";
193 if (rama != null && aux == null) {
194 Vehiculos_NodoB temp = rama.getPrimero();
195 String primeroPlaca = temp.getVehiculo_placa();
196 while (temp != null) {
197 if (aux != null) {
198 break;
199 }
200 aux = buscarindice_recursivo(placa, temp.getIzquierda(), aux);
201 //aqui digo si existe o no
202 if (placa.equals(temp.getVehiculo_placa())) {
203 Primero = primeroPlaca;
204 return temp;
205 }
206
207 if (temp.getSiguiente() == null) {
208 aux = buscarindice_recursivo(placa, temp.getDerecha(), aux);
209 }
210 temp = temp.getSiguiente();
211 }
212
213 }
214 return aux;
215 }
216
217 public void modificar(String valor, String vehiculo_marca, String
vehiculo_modelo, String vehiculo_ano, String vehiculo_color, String
vehiculo_precio, String vehiculo_TipoTransmision) {
218
219 modificar_recursivo(valor, vehiculo_marca, vehiculo_modelo, vehiculo_ano,
vehiculo_color, vehiculo_precio, vehiculo_TipoTransmision, raiz, null);
220 }
221
222 private Vehiculos_NodoB modificar_recursivo(String placa, String vehiculo_marca,
String vehiculo_modelo, String vehiculo_ano, String vehiculo_color, String
vehiculo_precio, String vehiculo_TipoTransmision, Vehiculos_Rama rama,
Vehiculos_NodoB aux) {
223
224 if (rama != null && aux == null) {
225 Vehiculos_NodoB temp = rama.getPrimero();
226 while (temp != null) {
227 if (aux != null) {
228 break;
229 }
230 aux = modificar_recursivo(placa, vehiculo_marca, vehiculo_modelo,
vehiculo_ano, vehiculo_color, vehiculo_precio,
vehiculo_TipoTransmision, temp.getIzquierda(), aux);
231 //aux = buscarindice_recursivo(placa, temp.getIzquierda(), aux);
232 //aqui digo si existe o no
233 if (placa.equals(temp.getVehiculo_placa())) {
234 temp.setVehiculo_marca(vehiculo_marca);
235 temp.setVehiculo_modelo(vehiculo_modelo);
236 temp.setVehiculo_ano(vehiculo_ano);
237 temp.setVehiculo_color(vehiculo_color);
238 temp.setVehiculo_precio(vehiculo_precio);
239 temp.setVehiculo_TipoTransmision(vehiculo_TipoTransmision);
240 JOptionPane.showMessageDialog(null, "Nodo Modificado (*ゝω・)ﾉ");
241 return null;
242 }
243
244 if (temp.getSiguiente() == null) {
245 aux = modificar_recursivo(placa, vehiculo_marca,
vehiculo_modelo, vehiculo_ano, vehiculo_color, vehiculo_precio,
vehiculo_TipoTransmision, temp.getDerecha(), aux);
246
247 }
248 temp = temp.getSiguiente();
249 }
250
251 }
252 //JOptionPane.showMessageDialog(null, "Nodo no modificado");
253 return null;
254 }
255
256 public void imprimir() {
257 ReporteG1 = "";
258 ReporteG2 = "";
259 ReporteGTotal = "";
260 String graph1 = "";
261 flechasarbolfilas = "";
262 flechasarbolcolumnas = "";
263 flechascontenido = "";
264 graph1 += "digraph G {\nrankdir=LT;\n \tgraph [pad=\"0.15\",
nodesep=\"0.15\", ranksep=\"1\"];\n";
265 graph1 += "subgraph cluster_1 {\n node[shape=record];\n";
266 //graph1 += imprimircontenido(filas.raiz, "", 0);
267 graph1 += flechascontenido;
268 graph1 += "}\n";
269 graph1 += "subgraph cluster_2 {\n node[shape=record, color=green];\n";
270 ReporteG1 += "node[shape=record, color=green];\n";
271 graph1 += imprimirArbolfilas(raiz, "", 0);
272 graph1 += flechasarbolfilas;
273 ReporteGTotal += ReporteG1 + "\n" + flechasarbolfilas;
274 graph1 += "}\n";
275 graph1 += "subgraph cluster_3 {\n node[shape=record];\n";
276 //graph1 += imprimirArbolcolumnas(columnas.raiz, "", 0);
277 graph1 += flechasarbolcolumnas;
278 graph1 += "}\n";
279
280 graph1 += "}";
281 try {
282
283 FileWriter fw;
284 PrintWriter pw;
285 fw = new FileWriter("ArbolB.dot");
286 pw = new PrintWriter(fw);
287
288 pw.print(graph1);
289 pw.close();
290 fw.close();
291
292 ProcessBuilder pbuilder;
293 //pbuilder = new ProcessBuilder( "dot", "-Tpng", "-o", direccionPng,
direccionDot );
294 String dirImagen = "ArbolB.png";
295 String dirDot = "ArbolB.dot";
296 pbuilder = new ProcessBuilder("dot.exe", "-Tpng", "-o", dirImagen,
dirDot);
297 pbuilder.redirectErrorStream(true);
298 //Ejecuta el proceso
299 pbuilder.start();
300
301 } catch (IOException e) {
302 System.out.println(e.getMessage());
303 }
304
305 }
306
307 private String imprimirArbolfilas(Vehiculos_Rama rama, String graph, int m) {
308 if (rama != null) {
309
310 Vehiculos_NodoB aux = rama.getPrimero();
311 int n = 0;
312 graph += "fila" + rama.getPrimero().getVehiculo_placa() +
"[label=\"<f0>|";
313 ReporteG1 += "fila" + rama.getPrimero().getVehiculo_placa() +
"[label=\"<f0>|";
314 while (aux != null) {
315 n++;
316 if (aux.getSiguiente() != null) {
317 graph += "<ff" + aux.getVehiculo_placa() + ">" +
aux.getVehiculo_placa() + "|<f" + n + ">|";
318 ReporteG1 += "<ff" + aux.getVehiculo_placa() + ">" +
aux.getVehiculo_placa() + "|<f" + n + ">|";
319 } else {
320 graph += "<ff" + aux.getVehiculo_placa() + ">" +
aux.getVehiculo_placa() + "|<f" + n + ">";
321 ReporteG1 += "<ff" + aux.getVehiculo_placa() + ">" +
aux.getVehiculo_placa() + "|<f" + n + ">";
322 }
323
324 if (aux.getDerecha() != null && aux.getSiguiente() == null) {
325 flechasarbolfilas += "fila" +
rama.getPrimero().getVehiculo_placa() + ":f" + n + "->fila" +
aux.getDerecha().getPrimero().getVehiculo_placa() + ":f0;\n";
326
327 }
328 if (aux.getIzquierda() != null) {
329 if (aux == rama.getPrimero()) {
330 flechasarbolfilas += "fila" +
rama.getPrimero().getVehiculo_placa() + ":f0->fila" +
aux.getIzquierda().getPrimero().getVehiculo_placa() +
":f0;\n";
331
332 } else {
333 flechasarbolfilas += "fila" +
rama.getPrimero().getVehiculo_placa() + ":f" + (n - 1) +
"->fila" +
aux.getIzquierda().getPrimero().getVehiculo_placa() +
":f0;\n";
334
335 }
336 }
337
338 aux = aux.getSiguiente();
339 }
340 graph += "\"];\n";
341 ReporteG1 += "\"];\n";
342
343 aux = rama.getPrimero();
344 while (aux != null) {
345
346 graph = imprimirArbolfilas(aux.getIzquierda(), graph, m + 1);
347 if (aux.getSiguiente() == null) {
348 graph = imprimirArbolfilas(aux.getDerecha(), graph, m + 1);
349 }
350 aux = aux.getSiguiente();
351 }
352
353 }
354 return graph;
355 }
356
357 private Vehiculos_Rama Subdividir(Vehiculos_NodoB Actual, Vehiculos_Rama
Ramaactual) {
358 if (Actual.getIzquierda() != null) {
359 Subdividir(Actual.getIzquierda().getPrimero(), Actual.getIzquierda());
360 }
361 if (Actual.getDerecha() != null) {
362 Subdividir(Actual.getDerecha().getPrimero(), Actual.getDerecha());
363 }
364 Vehiculos_Rama nueva = new Vehiculos_Rama();
365 if (Ramaactual.isHoja() == false) {
366
367 if (Actual.getIzquierda().getCuenta() != 2 ||
Actual.getDerecha().getCuenta() != 2) {
368
369 //Recorremos la izquierda
370 Vehiculos_NodoB recoizquierda = Actual.getIzquierda().getPrimero();
371 while (recoizquierda != null) {
372 nueva.insertar(recoizquierda);
373
374 recoizquierda.setSiguiente(recoizquierda.getSiguiente());
375 }
376 //Insertamos la raiz
377 Vehiculos_NodoB Raiznueva = new
Vehiculos_NodoB(Actual.getVehiculo_placa(),
Actual.getVehiculo_marca(), Actual.getVehiculo_modelo(),
Actual.getVehiculo_ano(), Actual.getVehiculo_color(),
Actual.getVehiculo_precio(), Actual.getVehiculo_TipoTransmision());
378 nueva.insertar(Raiznueva);
379 verificarcuenta(nueva, Ramaactual);
380 //insetamos la derecha
381 Vehiculos_NodoB recoderecha = Actual.getDerecha().getPrimero();
382 while (recoderecha != null) {
383 nueva.insertar(recoderecha);
384 verificarcuenta(nueva, Ramaactual);
385 recoderecha.setSiguiente(recoderecha.getSiguiente());
386 }
387
388 }
389 }
390
391 return nueva;
392 }
393
394 public boolean Eliminar(boolean existe, Vehiculos_Rama rama, String n) {
395
396 if (rama != null && existe == false) {
397
398 Vehiculos_NodoB aux = rama.getPrimero();
399 while (aux != null) {
400
401 if (existe) {
402 break;
403 }
404
405 existe = Eliminar(existe, aux.getIzquierda(), n);
406
407 //aqui digo si existe o no
408 System.out.println("antes del equals");
409 //nodo.getVehiculo_placa().compareTo(temp.getVehiculo_placa()) < 0
410 if (aux.getVehiculo_placa().compareTo(n) == 0) {
411 System.out.println("Estoy abajo equals");
412 // aqui haremos el eliminar
413 if (rama.isHoja() == true) {
414 if (aux == rama.getPrimero()) {
415 //Eliminamos el primero
416 aux.getSiguiente().setAnterior(null);
417 rama.setPrimero(aux.getSiguiente());
418 } else if (aux.getSiguiente() == null) {
419 //Eliminamos el ultimo
420 aux.getAnterior().setSiguiente(null);
421
422 } else {
423 //Eliminamos en medio
424 aux.getSiguiente().setAnterior(aux.getAnterior());
425 aux.getAnterior().setSiguiente(aux.getSiguiente());
426
427 }
428
429 } else {
430 System.out.println("No soy hoja");
431 if (aux.getIzquierda() != null) {
432 //Llamamos al metodo que busca el mas grande de la
izquierda
433 Vehiculos_NodoB Sustituto =
BuscarMasGrandeIzquirda(aux.getIzquierda(), null);
434 System.out.println("Soy el sustituto");
435 //Aqui seteamos los atributos
436 aux.setVehiculo_placa(Sustituto.getVehiculo_placa());
437 aux.setVehiculo_marca(Sustituto.getVehiculo_marca());
438 aux.setVehiculo_modelo(Sustituto.getVehiculo_modelo());
439 aux.setVehiculo_ano(Sustituto.getVehiculo_ano());
440 aux.setVehiculo_color(Sustituto.getVehiculo_color());
441 aux.setVehiculo_precio(Sustituto.getVehiculo_precio());
442
aux.setVehiculo_TipoTransmision(Sustituto.getVehiculo_Tipo
Transmision());
443 //
444
445 }
446 }
447 return true;
448 }
449
450 if (aux.siguiente == null) {
451 existe = Eliminar(existe, aux.getDerecha(), n);
452 }
453 aux = aux.siguiente;
454 }
455
456 }
457
458 return existe;
459 }
460
461 private Vehiculos_NodoB BuscarMasGrandeIzquirda(Vehiculos_Rama rama,
Vehiculos_NodoB auxiliar) {
462 System.out.println("estoy en el metodo buscar mas grande izquierda");
463 if (rama.isHoja() == true) {
464
465 System.out.println("Estoy en el inicio del if");
466 Vehiculos_NodoB aux1 = rama.getPrimero();
467 System.out.println(aux1.getSiguiente().getVehiculo_placa());
468 while (aux1.siguiente != null) {
469 aux1 = aux1.siguiente;
470
471 }
472 System.out.println("despues del while");
473 if (aux1 == rama.getPrimero()) {
474 rama.setPrimero(null);
475
476 } else {
477 aux1.getAnterior().setSiguiente(null);
478
479 }
480 System.out.println("Estoy en el final del if");
481 rama.setCuenta(rama.getCuenta() - 1);
482 return aux1;
483
484 } else {
485 System.out.println("Estoy en el else de no soy hoja");
486 Vehiculos_NodoB aux = rama.getPrimero();
487 while (aux.getSiguiente() != null) {
488 aux.setSiguiente(aux.getSiguiente());
489 }
490 auxiliar = BuscarMasGrandeIzquirda(aux.getDerecha(), auxiliar);
491
492 }
493 return auxiliar;
494 }
495
496 }
497