Árbol de ordenación binaria
1 Primero observe un requisito.
Proporcione una secuencia (7, 3, 10, 12, 5, 1, 9), que requiere una consulta de datos eficiente y una suma
2 Análisis de la solución
Usar matriz La
matriz no está ordenada Ventajas: agregar directamente al final de la matriz, lo cual es rápido. Desventajas: velocidad de búsqueda lenta.
Clasificación de matrices. Ventajas: se puede utilizar la búsqueda binaria. La velocidad de búsqueda es rápida. Desventajas: Para asegurar el orden de la matriz, al agregar nuevos datos, después de encontrar la posición de inserción
, los datos posteriores necesitan moverse en su conjunto, lo cual es lento.
Use la lista enlazada de almacenamiento en cadena
No importa si la lista enlazada está ordenada o no, la velocidad de búsqueda es lenta y la velocidad de agregar datos es más rápida que la de las matrices, y no es necesario mover los datos en su totalidad.
Utilice un árbol de ordenación binario
3 árbol de ordenación binaria describe el árbol de ordenación
binaria: BST: (árbol de ordenación binaria (búsqueda )), para cualquier árbol de ordenación binaria de nodo no hoja, el valor requerido del nodo hijo izquierdo que cuando
un valor pequeño antes del nodo y el hijo derecho El valor del nodo es mayor que el valor del nodo actual.
Nota especial: si tiene el mismo valor, puede colocar el nodo en el nodo secundario izquierdo o en el nodo secundario derecho. Por
ejemplo, para los datos anteriores (7, 3, 10, 12, 5, 1, 9), el El árbol de clasificación binario correspondiente es: 
4 Creación del árbol de clasificación binaria y recorrido de
una matriz para crear un árbol de ordenación binario correspondiente y utilizar el recorrido en orden del árbol de ordenación binaria, por ejemplo: la matriz es Array (7, 3, 10, 12, 5, 1, 9) El
árbol de ordenación binario correspondiente se crea de la siguiente manera: 
5 Eliminación del
árbol de ordenación binaria La situación de eliminación del árbol de ordenación binaria es más complicada y hay tres situaciones que deben tenerse en cuenta.
- Eliminar nodos de hoja (por ejemplo: 2, 5, 9, 12)
- Eliminar nodos con solo un subárbol (por ejemplo: 1)
- Eliminar nodos con dos subárboles (por ejemplo: 7, 3, 10)
- Análisis
de la idea de operación Análisis de pensamiento de varias situaciones de eliminación de nodos: La
primera situación:
eliminación de nodos hoja (por ejemplo: 2, 5, 9, 12)
Ideas
(1) Necesidad de encontrar el nodo a eliminar targetNode
( 2) Encuentre el nodo padre padre de
targetNode (3) Determine si targetNode es el nodo hijo izquierdo o el nodo hijo derecho del padre
(4) Elimine correspondientemente de acuerdo con la situación anterior.
Nodo hijo izquierdo parent.left = null
Nodo hijo derecho padre. = nulo;
El segundo caso: eliminar un nodo con solo un subárbol como 1
idea
(1) primero necesita encontrar el nodo que se eliminará targetNode
(2) encontrar el nodo padre de targetNode
(3) determinar el targetNode Es el nodo hijo un nodo hijo izquierdo o un nodo hijo derecho
(4) Es targetNode un nodo hijo izquierdo o un nodo hijo derecho del padre
(5) Si targetNode tiene un nodo hijo izquierdo
(5). 1 Si targetNode es un nodo hijo izquierdo del padre Hijo node
parent.left = targetNode.left;
(5) .2 Si targetNode es el nodo secundario derecho del parent
parent.right = targetNode.left;
(6) Si targetNode tiene un nodo secundario derecho
(6). 1 Si targetNode es el nodo secundario izquierdo del parent
parent.left = targetNode.right;
(6). 2 Si targetNode es el nodo secundario derecho del parent
parent.right = targetNode.righ
Caso 3: Elimine el nodo con dos subárboles. (Por ejemplo: 7, 3, 10)
Idea
(1) Necesita encontrar el nodo que se va a eliminar primero targetNode
(2) Encuentre el nodo principal de targetNode parent
(3) ) Encuentre el nodo más pequeño del subárbol derecho de targetNode
(4) Use una variable temporal para guardar el valor del nodo más pequeño temp = 11
(5) Elimine el nodo más pequeño
(6) targetNode.value = temp
6
Paquete de implementación de código de nodo de eliminación de árbol de ordenación binaria com.lin.binarysorttree_0314;
public class BinarySortTreeTest {
public static void main(String[] args) {
int[] arr = {7, 3, 10, 12, 5, 1, 9};
BinarySortTree binarySortTree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
binarySortTree.add(new SNode(arr[i]));
}
binarySortTree.add(new SNode(2));
binarySortTree.infixOrder();
// 删除
System.out.println("***********");
binarySortTree.delNode(2);
binarySortTree.delNode(3);
binarySortTree.delNode(5);
binarySortTree.delNode(7);
binarySortTree.delNode(9);
binarySortTree.delNode(12);
System.out.println("root:" + binarySortTree.getRoot());
binarySortTree.infixOrder();
}
}
class BinarySortTree { raíz de SNodo privado; // Encuentra el nodo que se eliminará public SNode getRoot () { devolver raíz; } público SNode searchDelNode (valor int) { if (raíz == nulo) { devolver nulo; } else { devolver raíz. searchDelNode (value); } } // Encuentra el nodo padre del nodo a eliminar public SNode searchParent (int value) { if (root == null) { return null; } else { return root.searchParent (value); } } / ** * @param nodo el nodo entrante (como el nodo raíz del árbol de clasificación binaria) * @return el valor del nodo más pequeño del árbol de clasificación binaria con nodo como el nodo raíz * / public int delRightTreeMin (nodo SNode ) { SNode objetivo = nodo;
// Encuentra el nodo izquierdo en un bucle y encontrarás el valor mínimo
while (target.left! = Null) { target = target.left; } delNode (target.value); // !!! return target.value ; //! !! }
// 删除节点
public void delNode(int value) {
if(root == null) {
return;
} else {
// 找删除节点
SNode targetNode = searchDelNode(value);
// 没有找到
if(targetNode == null) {
return;
}
// 如果发现当前这棵二叉树只有一个节点
if(root.left == null && root.right == null) {
root = null;
return;
}
// 去找到targetNode的父节点
SNode parent = searchParent(value);
// 如果删除的节点是叶子节点
if(targetNode.left == null && targetNode.right == null) {
// 判断targetNode是父节点的左子节点还是右子节点
if(parent.left != null && parent.left.value == value) {
parent.left = null;
} else if(parent.right != null && parent.right.value == value) {
parent.right = null;
}
} else if(targetNode.left != null && targetNode.right != null) { // 有左右子节点
int delRightTreeMin = delRightTreeMin(targetNode.right);
targetNode.value = delRightTreeMin;
} else {// 只有一个子节点
// 要删除的节点只有左节点
if(targetNode.left != null) {
if(parent != null) {
// 如果targetNode是parent的左子节点
if(parent.left.value == value) {
parent.left = targetNode.left;
} else {
parent.right = targetNode.left;
}
} else {
root = targetNode.left;
}
} else {// 要删除的节点有右子节点
if(parent != null) {
if(parent.left.value == value) {
parent.left = targetNode.right;
} else {
parent.right = targetNode.right;
}
} else {
root = targetNode.right;
}
}
}
}
}
// 中序遍历
public void infixOrder() {
if(root == null) {
System.out.println("空树！");
} else {
root.infixOrder();
}
}
// 添加
public void add(SNode node) {
if(root == null) {
root = node;
} else {
root.add(node);
}
}
}
class SNode { valor int protegido; SNode protegido a la izquierda; derecho protegido de SNode;
public SNode(int value) {
// TODO Auto-generated constructor stub
this.value = value;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Node = [value = " + value + "]";
}
// 添加节点
public void add(SNode 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);
}
}
}
// 中序遍历
public void infixOrder() {
if(this.left != null) {
this.left.infixOrder();
}
System.out.println(this);
if(this.right != null) {
this.right.infixOrder();
}
}
// 查找要删除的节点
public SNode searchDelNode(int value) {
if(this.value == value) {
return this;
} else if(this.value > value) {
// 如果左子节点为空
if(this.left == null) {
return null;
}
return this.left.searchDelNode(value);
} else {
if(this.right == null) {
return null;
}
return this.right.searchDelNode(value);
}
}
// 查找要删除节点的父节点, 如果没有则返回null
public SNode searchParent(int value) {
if(( this.left != null && this.left.value == value)
|| ( this.right != null && this.right.value == value )) {
return this;
} else {
// 如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
if(value < this.value && this.left != null) {
return this.left.searchParent(value);
} else if(value >= this.value && this.right != null) {
return this.right.searchParent(value);
} else {
return null;
}
}
}
} 
Cualquier similitud es pura coincidencia. Siga al editor para obtener más información ...