Buscar..


Introducción

El árbol binario es un árbol en el que cada nodo tiene un máximo de dos hijos. El árbol de búsqueda binaria (BST) es un árbol binario en el que sus elementos se colocan en un orden especial. En cada BST, todos los valores (es decir, la clave) en el subárbol izquierdo son menores que los valores en el subárbol derecho.

Árbol de búsqueda binario - Inserción (Python)

Esta es una implementación simple de la inserción de árbol de búsqueda binaria utilizando Python.

A continuación se muestra un ejemplo:

introduzca la descripción de la imagen aquí

Siguiendo el fragmento de código, cada imagen muestra la visualización de ejecución, lo que facilita la visualización de cómo funciona este código.

class Node:
    def __init__(self, val):
        self.l_child = None
        self.r_child = None
        self.data = val

introduzca la descripción de la imagen aquí

def insert(root, node):
    if root is None:
        root = node
    else:
        if root.data > node.data:
            if root.l_child is None:
                root.l_child = node
            else:
                insert(root.l_child, node)
        else:
            if root.r_child is None:
                root.r_child = node
            else:
                insert(root.r_child, node)

introduzca la descripción de la imagen aquí

def in_order_print(root):
    if not root:
        return
    in_order_print(root.l_child)
    print root.data
    in_order_print(root.r_child)

introduzca la descripción de la imagen aquí

def pre_order_print(root):
    if not root:
        return        
    print root.data
    pre_order_print(root.l_child)
    pre_order_print(root.r_child)    

introduzca la descripción de la imagen aquí

Árbol de búsqueda binario - Eliminación (C ++)

Antes de comenzar con la eliminación, solo quiero poner algunas luces en lo que es un árbol de búsqueda binaria (BST). Cada nodo en una BST puede tener un máximo de dos nodos (hijo izquierdo y derecho). El subárbol izquierdo de un nodo tiene una clave menor o igual que la clave de su nodo principal. El subárbol derecho de un nodo tiene una clave mayor que la clave de su nodo principal.

Eliminar un nodo en un árbol mientras se mantiene su propiedad de árbol de búsqueda binaria.

introduzca la descripción de la imagen aquí

Hay tres casos que deben considerarse al eliminar un nodo.

  • Caso 1: el nodo que se eliminará es el nodo de hoja (nodo con valor 22).
  • Caso 2: el nodo que se va a eliminar tiene un hijo (nodo con valor 26).
  • Caso 3: El nodo a eliminar tiene ambos hijos (Nodo con valor 49).

Explicación de los casos:

  1. Cuando el nodo que se va a eliminar es un nodo de hoja, simplemente elimine el nodo y pase nullptr a su nodo principal.
  2. Cuando un nodo que se va a eliminar tiene solo un hijo, copie el valor hijo en el valor del nodo y elimine el hijo (convertido al caso 1)
  3. Cuando un nodo que se va a eliminar tiene dos hijos, el mínimo de su subárbol derecho se puede copiar al nodo y el valor mínimo se puede eliminar del subárbol derecho del nodo (Convertido al Caso 2)

Nota: El mínimo en el subárbol derecho puede tener un máximo de un hijo y ese hijo también correcto si tiene el hijo izquierdo significa que no es el valor mínimo o que no está siguiendo la propiedad BST.

La estructura de un nodo en un árbol y el código para la eliminación:

struct node
{
    int data;
    node *left, *right;
};

node* delete_node(node *root, int data)
{
  if(root == nullptr) return root;
  else if(data < root->data) root->left  = delete_node(root->left, data);
  else if(data > root->data) root->right = delete_node(root->right, data);

  else
  {
    if(root->left == nullptr && root->right == nullptr) // Case 1
    {
      free(root);
      root = nullptr;
    }
    else if(root->left == nullptr)       // Case 2
    {
       node* temp = root;
       root= root->right;
       free(temp);
    }
    else if(root->right == nullptr)      // Case 2
    {
       node* temp = root;
       root = root->left;
       free(temp);
    }
    else                                 // Case 3
    {
       node* temp = root->right;

       while(temp->left != nullptr) temp = temp->left;

       root->data = temp->data;
       root->right = delete_node(root->right, temp->data);
    }
  }
  return root;
}

La complejidad de tiempo del código anterior es O ( h ), donde h es la altura del árbol.

El antepasado común más bajo en un BST

Considere el BST:

introduzca la descripción de la imagen aquí

El antepasado común más bajo de 22 y 26 es 24.

El antepasado común más bajo de 26 y 49 es 46.

El antepasado común más bajo de 22 y 24 es 24.

La propiedad del árbol de búsqueda binario se puede usar para encontrar los nodos del antepasado más bajo

Código Psuedo:

lowestCommonAncestor(root,node1, node2){

if(root == NULL)    
return NULL;



 else if(node1->data == root->data || node2->data== root->data)    
    return root;
    
    else if((node1->data <= root->data && node2->data > root->data)
              || (node2->data <= root->data && node1->data > root->data)){
        
             return root;
    }
    
    else if(root->data > max(node1->data,node2->data)){
            return lowestCommonAncestor(root->left, node1, node2);
    }
        
        else {
            return lowestCommonAncestor(root->right, node1, node2);
      }
        }

Árbol binario de búsqueda - Python

class Node(object):
    def __init__(self, val):
        self.l_child = None
        self.r_child = None
        self.val = val


class BinarySearchTree(object):
    def insert(self, root, node):
        if root is None:
            return node

        if root.val < node.val:
            root.r_child = self.insert(root.r_child, node)
        else:
            root.l_child = self.insert(root.l_child, node)

        return root


    def in_order_place(self, root):
        if not root:
            return None
        else:
            self.in_order_place(root.l_child)
            print root.val
            self.in_order_place(root.r_child)

    def pre_order_place(self, root):
        if not root:
            return None
        else:
            print root.val
            self.pre_order_place(root.l_child)
            self.pre_order_place(root.r_child)

    def post_order_place(self, root):
        if not root:
            return None
        else:
            self.post_order_place(root.l_child)
            self.post_order_place(root.r_child)
            print root.val

"" "Crear un nodo diferente e insertar datos en él" ""

r = Node(3)
node = BinarySearchTree()
nodeList = [1, 8, 5, 12, 14, 6, 15, 7, 16, 8]

for nd in nodeList:
    node.insert(r, Node(nd))

print "------In order ---------"
print (node.in_order_place(r))
print "------Pre order ---------"
print (node.pre_order_place(r))
print "------Post order ---------"
print (node.post_order_place(r))


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow