Árbol binario sesgado

Un árbol binario sesgado es un tipo de árbol binario en el que todos los Nodes tienen un solo hijo o ningún hijo.

Tipos de árboles binarios sesgados 

Hay 2 tipos especiales de árbol sesgado: 

1. Árbol binario sesgado a la izquierda: 
estos son aquellos árboles binarios sesgados en los que todos los Nodes tienen un hijo izquierdo o ningún hijo. Es un árbol dominado por el lado izquierdo. Todos los hijos correctos quedan como nulos.

A continuación se muestra un ejemplo de un árbol sesgado a la izquierda:

C++

#include <bits/stdc++.h>
using namespace std;
 
// A Tree node
struct Node {
    int key;
    struct Node *left, *right;
};
 
// Utility function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
 
    return (temp);
}
 
// Driver code
int main()
{
    /*
            1
           /
          2
         /
        3
    */
    Node* root = newNode(1);
    root->left = newNode(2);
    root->left->left = newNode(3);
 
    return 0;
}

Java

// Java implementation of above approach
import java.util.*;
 
class GFG
{
     
// A Tree node
static class Node
{
    int key;
     Node left, right;
};
   
// Utility function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
   
    return (temp);
}
   
// Driver code
public static void main(String args[])
{
    /*
            1
           /
          2
         /
        3
    */
    Node root = newNode(1);
    root.left = newNode(2);
    root.left.left = newNode(3);
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 implementation of the above approach
 
# Class that represents an individual
# node in a Binary Tree
class Node:
    def __init__(self, key):
         
        self.left = None
        self.right = None
        self.val = key
         
# Driver code
 
"""         1
           /
          2
         /
        3     """
root = Node(1)
root.left = Node(2)
root.left.left = Node(2)
 
# This code is contributed by dhruvsantoshwar

C#

// C# implementation of above approach
using System;
  
class GFG
{
          
    // A Tree node
     public class Node
    {
         public int key;
         public Node left, right;
    };
          
    // Utility function to create a new node
     static Node newNode(int key)
    {
        Node temp = new Node();
        temp.key = key;
        temp.left = temp.right = null;
          
        return (temp);
    }
          
    // Driver code
    public static void Main()
    {
        /*
                1
            /
            2
            /
            3
        */
        Node root = newNode(1);
        root.left = newNode(2);
        root.left.left = newNode(3);
    }
}
 
// This code is contributed by AnkitRai01

Javascript

<script>
// Javascript implementation of above approach
 
// A Tree node
class Node
{
    constructor()
    {
        this.key=0;
        this.left=this.right=null;
    }
}
 
// Utility function to create a new node
function newNode(key)
{
    let temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
     
    return (temp);
}
 
// Driver code
 /*
            1
           /
          2
         /
        3
    */
let root = newNode(1);
root.left = newNode(2);
root.left.left = newNode(3);
 
 
// This code is contributed by avanitrachhadiya2155
</script>

2. Árbol binario sesgado a la derecha: 
estos son aquellos árboles binarios sesgados en los que todos los Nodes tienen un hijo derecho o ningún hijo. Es un árbol dominado por el lado derecho. Todos los hijos dejados quedan como nulos.

A continuación se muestra un ejemplo de un árbol sesgado a la derecha:

C++

#include <bits/stdc++.h>
using namespace std;
 
// A Tree node
struct Node {
    int key;
    struct Node *left, *right;
};
 
// Utility function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
 
    return (temp);
}
 
// Driver code
int main()
{
    /*
        1
         \
          2
           \
            3
    */
    Node* root = newNode(1);
    root->right = newNode(2);
    root->right->right = newNode(3);
 
    return 0;
}

Java

// Java implementation of above approach
import java.util.*;
class GFG
{
     
// A Tree node
static class Node
{
    int key;
    Node left, right;
};
   
// Utility function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
   
    return (temp);
}
   
// Driver code
public static void main(String args[])
{
    /*
       1
        \
         2
          \
           3
    */
    Node root = newNode(1);
    root.right = newNode(2);
    root.right.right = newNode(3);
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 implementation of the above approach
 
# A Tree node
class Node:
     
    def __init__(self, key):
         
        self.left = None
        self.right = None
        self.val = key
         
# Driver code
"""        
        1
         \
          2
           \
            3
                 """
root = Node(1)
root.right = Node(2)
root.right.right = Node(3)
 
# This code is contributed by shivanisinghss2110

C#

// C# implementation of above approach
using System;
  
class GFG
{
       
// A Tree node
public class Node
{
    public int key;
    public Node left, right;
};
     
// Utility function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
     
    return (temp);
}
     
// Driver code
public static void Main(String []args)
{
    /*
       1
        \
         2
          \
           3
    */
    Node root = newNode(1);
    root.right = newNode(2);
    root.right.right = newNode(3);
}
}
  
// This code is contributed by PrinciRaj1992

Javascript

<script>
 
// Javascript implementation of above approach
 
// A Tree node
class Node
{
    constructor()
    {
        this.key = 0;
        this.left = this.right = null;
    }
}
 
// Utility function to create a new node
function newNode(key)
{
    let temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
     
    return(temp);
}
 
// Driver code
 /*
            1
           /
          2
         /
        3
    */
let root = newNode(1);
root.right = newNode(2);
root.right.right = newNode(3);
 
// This code is contributed by shivanisinghss2110
 
</script>

Publicación traducida automáticamente

Artículo escrito por piyush25pv y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *