Directorio artículo
¿Cuál es el árbol de búsqueda binaria
Binarios árboles binarios de búsqueda (árbol binario de búsqueda), que puede ser árbol vacío, o que tengan las siguientes propiedades: si su subárbol izquierdo no está vacío, entonces el valor del subárbol izquierdo, todos los nodos son menos de su raíz nodo de valor, y si su subárbol derecho no está vacía, el valor del subárbol derecho, todos los nodos son mayores que el valor de la raíz; sus subárboles izquierdo y derecho son binarios árbol de búsqueda. Cada nodos sub-árbol se forman para satisfacer las propiedades.
nodo del árbol de definición
public class BST01<E extends Comparable<E>> {
private class Node {
E e;
Node left; //左子节点
Node right; //右子节点
public Node(E e) {
this.e = e;
}
}
}
Añadir nodos
Definir un atributo de nodo raíz Node root;
recursiva
public void add(E e) {
root = add(root, e);
}
private Node add(Node node, E e) {
if (node == null) {
return new Node(e);
}
if (e.compareTo(node.e) > 0) {
node.right = add(node.right, e);
} else /*if (e.compareTo(node.e) < 0)*/ {
node.left = add(node.left, e);
}
return node;
}
Else para lograr lo anterior, contiene <= nodo; si se abre la anotación, la libre = nodo.
Ciclo para lograr
public void addByCircle(E e) {
if (root == null) {
root = new Node(e);
} else {
Node p = root;
while (p != null) {
if (e.compareTo(p.e) > 0) {
if (p.right == null) {
p.right = new Node(e);
break;
} else {
p = p.right;
}
} else /*if (e.compareTo(p.e) < 0)*/ {
if (p.left == null) {
p.left = new Node(e);
break;
} else {
p = p.left;
}
} /*else {
break;
}*/
}
}
}
Else para lograr lo anterior, contiene <= nodo; si los dos anotaciones abierta, libre = nodo.
traversal Jerarquía (recorrido primero en amplitud)
Imprimir el valor de todos los elementos en el árbol de nodos e, e impreso en un orden jerárquico.
public void levelOrder1() {
Queue<Node> queue = new LinkedList<>();
queue.add(root);
StringBuilder sb = new StringBuilder();
while (!queue.isEmpty()) {
Node node = queue.remove();
sb.append(node.e + " ");
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
System.out.println(sb);
}
A partir de la raíz, cada nodo eliminado, mantendrá los nodos hijos izquierdo y derecho a una cola FIFO.
prueba
public static void main(String[] args) {
BST01<Integer> bst = new BST01<>();
bst.add(33);
bst.add(31);
bst.add(36);
bst.add(19);
bst.add(92);
bst.add(9);
bst.add(38);
bst.add(98);
bst.add(43);
bst.add(54);
bst.add(54);
bst.add(98);
bst.add(19);
bst.levelOrder1();
}
exportación
33 31 36 19 92 9 38 98 19 43 98 54 54
Aumento de los niveles de nodo de atributo profundidad
Desde la salida anterior, vista de jerarquía, no es muy clara.
A continuación, Nodeañadir un nivel de propiedad de la representación de profundidaddepth
private class Node {
E e;
Node left;
Node right;
int depth;
public Node(E e) {
this.e = e;
}
public Node(E e, int depth) {
this(e);
this.depth = depth;
}
}
En consecuencia, para modificar y agregar los métodos nodo de recorrido.
La final sigue
public class BST01<E extends Comparable<E>> {
private class Node {
E e;
Node left;
Node right;
int depth;
public Node(E e) {
this.e = e;
}
public Node(E e, int depth) {
this(e);
this.depth = depth;
}
}
private Node root;
public void add(E e) {
root = add(root, e, 0);
}
private Node add(Node node, E e, int depth) {
if (node == null) {
return new Node(e, depth);
}
if (e.compareTo(node.e) > 0) {
node.right = add(node.right, e, depth + 1);
} else /*if (e.compareTo(node.e) <= 0)*/ {
node.left = add(node.left, e, depth + 1);
}
return node;
}
public void addByCircle(E e) {
if (root == null) {
root = new Node(e);
root.depth = 0;
} else {
Node p = root;
while (p != null) {
if (e.compareTo(p.e) > 0) {
if (p.right == null) {
p.right = new Node(e, p.depth + 1);
break;
} else {
p = p.right;
}
} else /*if (e.compareTo(p.e) < 0)*/ {
if (p.left == null) {
p.left = new Node(e, p.depth + 1);
break;
} else {
p = p.left;
}
} /*else {
break;
}*/
}
}
}
public void levelOrder1() {
Queue<Node> queue = new LinkedList<>();
queue.add(root);
StringBuilder sb = new StringBuilder();
while (!queue.isEmpty()) {
Node node = queue.remove();
sb.append(node.e + " ");
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
System.out.println(sb);
}
public void levelOrder2() {
Queue<Node> queue = new LinkedList<>();
queue.add(root);
StringBuilder sb = new StringBuilder();
int tempDepth = -1;
while (!queue.isEmpty()) {
Node node = queue.remove();
if (tempDepth != node.depth) {
sb.append("\n");
}
sb.append(node.e + "(depth=" + node.depth +") ");
tempDepth = node.depth;
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
System.out.println(sb);
}
}
prueba
Añadir los mismos datos de prueba, y luego llamar levelOrder2()recorrido.
exportación
33(depth=0)
31(depth=1) 36(depth=1)
19(depth=2) 92(depth=2)
9(depth=3) 38(depth=3) 98(depth=3)
19(depth=4) 43(depth=4) 98(depth=4)
54(depth=5)
54(depth=6)
Esta estructura de salida, para entender este árbol binario de búsqueda más intuitiva.
El árbol entero debería tener este aspecto
33
31 36
19 92
9 38 98
19 43 98
54
54
