prefacio
En la estructura de datos y algoritmos, cada algoritmo tiene ventajas y desventajas.
Almacenado en el orden: no ordenar, buscar más difícil; almacenadas en el orden: tipo, borrar, insertar dificultad
cadena de tiendas: pedido sea, son más difíciles de encontrar.
Sobre la base de los tres puntos anteriores, tenemos un árbol de tipo binario.
árbol de tipo binario
Árbol tipo binario (Binary Ordenar árbol), También conocido como un árbol binario de búsqueda (búsqueda binaria Árbol), también conocido como árbol binario de búsqueda. árbol de tipo binario o un árbol vacío o un árbol binario que tiene las siguientes propiedades:
(1) Si el subárbol izquierdo no está vacío, entonces el valor del subárbol izquierdo, todos los nodos son menos que o igual a la del nodo raíz ;
(2) Si el subárbol derecho no está vacía, el subárbol derecho de nodos de todos los valores son igual o mayor que el valor del nodo raíz;
(3) izquierdo y derecho sub-árboles son árbol de tipo binario;
estructura de árbol de ordenación binario
package demo9;
public class BinarySortTree {
Node root;
/*
* 向二叉排序树中添加节点
*/
public void add(Node node) {
//如果是一颗空树
if(root==null) {
root=node;
}else {
root.add(node);
}
}
/*
* 中序遍历二叉排序树
*/
public void midShow() {
if(root!=null) {
root.midShow(root);
}
}
package demo9;
public class Node {
int value;
Node left;
Node right;
public Node (int value) {
this.value=value;
}
/*
* 向子树中添加节点
*/
public void add(Node node) {
if(node==null) {
return;
}
//判断传入的节点的值比当前子树的根节点的值是大是小
//添加的节点比当前结点更小
if(node.value<this.value) {
//如果左节点为空
if(this.left==null) {
this.left=node;
//如果不为空
}else {
this.left.add(node);
}
//右子树
}else {
if(this.right==null) {
this.right=node;
//如果不为空
}else {
this.right.add(node);
}
}
}
/*
* 中序遍历二叉排序,z中序遍历二叉排序树结果为从小到大的顺序
*/
public void midShow(Node node) {
if(node==null) {
return;
}
midShow(node.left);
System.out.println(node.value);
midShow(node.right);
}
categorías de prueba:
public class TestBinarySortTree {
public static void main(String[] args) {
int [] arr=new int [] {7,3,10,12,5,1,9};
//创建一颗二叉排序树
BinarySortTree bst=new BinarySortTree();
//循环添加
for(int i:arr) {
bst.add(new Node(i));
}
//查看树中的值
bst.midShow();
Después de los pasos anteriores, hemos creado con éxito un árbol de tipo binario, y puede ser juzgado por una simple prueba para establecer árbol es correcta, uno de la manera más sencilla consiste en recorrer el árbol por el orden, debido a la especie de árbol binario características, a finde resultados de recorrido deben ser ordenados en serie ascendente de valores
Obtener el valor mínimo y el valor máximo del árbol
Debido a las características del árbol de tipo binario, que es el valor mínimo debe estar en el subárbol más a la izquierda, la máxima inevitable en el subárbol más a la derecha, por supuesto, si está vacío, entonces no hay árbol, si es sólo con los nodos del árbol, entonces el mínimo y el valor máximo es el nodo raíz en sí
Encontrar un árbol de ordenación binario
Encuentre el nodo contiene un cierto valor, es relativamente sencillo encontrar la implementación específica puede mirar el código:
/*
* 查找节点
*/
public Node search(int value) {
if(root==null) {
return null;
}else {
return root.search(value);
}
}
/**
* 查找节点
*/
public Node search(int value) {
if(this.value==value){
return this;
}else if(value<this.value){
if(left==null) {
return null;
}
return left.search(value);
}else{
if(right==null) {
return null;
}
return right.search(value);
}
}
árbol de tipo binario de borrado
nodo del árbol binario tipo de eliminación es el lugar más complejo, debido principalmente a la eliminación de las veces, hay muchos casos
nodo eliminado ninguna ha dejado y subárbol derecho
nodo es eliminado sólo el subárbol izquierdo
borrado nodo tiene sólo el subárbol derecho
elimina el nodo ha dejado y sub-estructuras correctas
tres primeros casos, el mejor trato, que sea directamente al padre señalando a sus hijos, por último, una mirada directa más compleja, combinada en el código sea más fácil de entender los comentarios:
/**
* 删除节点
*/
public void delete(int value) {
if(root==null) {
return;
}else {
//找到这个节点
Node target=search(value);
//如果没有这个节点
if(target==null) {
return;
}
//找到他的父节点
Node parent=searchParent(value);
//要删除的节点是叶子节点
if(target.left==null&&target.right==null) {
//要删除的节点是父节点的左子节点
if(parent.left.value==value) {
parent.left=null;
//要删除的节点是右节点
}else {
parent.right=null;
}
//要删除的节点有两个子节点
}else if(target.left!=null&&target.right!=null) {
//删除右子树中值最小的节点，取刚获取到该节点的值
int min=deleteMin(target.right);
//替换目标节点中的值
target.value=min;
//要删除的节点有一个左子节点或右字节点
}else {
if(target.left!=null) {
//要删除的节点是左子节点
if(parent.left.value==value) {
parent.left=target.left;
//要删除的节点是右节点
}else {
parent.right=target.right;
}
//右子节点
}else {
if(parent.right.value==value) {
parent.right=target.right;
//要删除的节点是右节点
}else {
parent.right=target.right;
}
}
}
}
}
/**
* 删除一颗树中最小的值的节点
* @param right
* @return
*/
private int deleteMin(Node node) {
Node target=node;
//递归向左找
while(target.left!=null) {
target=target.left;
}
//删除最小值的这个节点
delete(target.value);
return target.value;
}
/*
* 搜索父节点
*/
public Node searchParent(int value) {
if(root==null) {
return null;
}else {
return root.searchParent(value);
}
}
}
/**
* 搜索父节点
*/
public Node searchParent(int value) {
if((this.left!=null&&this.left.value==value)||(this.right!=null&&this.right.value==value)) {
return this;
}else {
if(this.value>value&&this.left!=null) {
return this.left.searchParent(value);
}else if(this.value<value&&this.right!=null){
return this.right.searchParent(value);
}
return null;
}
}
}
resumen
Principalmente revisa los principios básicos de la especie de árbol binario, no es muy complicado, ya modo de aplicación del código, aprendieron a crear una especie de árbol binario, insertar, encontrar y eliminar archivos. El cual elimina el nodo correspondiente puede decirse que es más complejo, un más difícil de entender, en el proceso de aprendizaje se puede combinar con el fin de dibujar su propia manera de entender.
