Estructura de datos de árbol en C#

1. Estructura de datos de árbol en C#
2. Pasos para construir una estructura de datos de árbol en C#

Los árboles en C# serán el tema de discusión en este artículo. La estructura de datos es lo primero que necesitamos saber.

Puede organizar y almacenar sus datos en la computadora utilizando una estructura de datos de manera más eficiente. Las pilas, las listas vinculadas y las colas son ejemplos de estructuras de datos secuenciales.

Estructura de datos de árbol en C#

Un tipo de datos jerárquicos organizados en forma de árbol se denomina estructura de datos de árbol. Comprende un nodo central, nodos estructurales y subnodos unidos entre sí por bordes.

También es posible afirmar que las raíces, las ramas y las hojas de la estructura de datos del árbol están vinculadas.

Se puede utilizar un árbol para representar datos en una estructura jerárquica. Cada nodo que conforma un árbol consta de dos subpartes: datos y referencias.

El nodo en la parte superior del árbol se denomina raíz. Los dos productos directamente debajo de él se denominan subárbol izquierdo y subárbol derecho.

El código para escribir un nodo de árbol podría verse así:

struct node {
  int Data;
  struct node
  *Leftchild;
  struct node
  *Rightchild;
};

Terminologías Básicas en la Estructura de Datos en Árbol en C#

A continuación se encuentran las terminologías básicas que necesita conocer en la estructura de datos de árbol en C#:

• Nodo raíz: El nodo en la parte superior del árbol se conoce como la raíz. Cada árbol tiene una sola raíz y una sola ruta conduce desde la raíz a cualquier otro nodo.
• Nodo de nivel: Los niveles de los nodos reflejan el número de nodos que se han generado. Los nodos descienden en incrementos de nivel de 1, 2, etc., con el nodo raíz siempre en la parte superior.
• Nodo Subárbol: Los descendientes de un nodo están representados por el subárbol.
• Nodo padre: si cualquier nodo que no sea el raíz está conectado a un nodo padre, se denomina padre.
• Nodo hijo: Cuando el borde de un nodo desciende, se le denomina nodo hijo.

Ventajas de la Estructura de Datos en Árbol en C#

Aquí hay dos ventajas de usar la estructura de datos de árbol en C#:

1. No es necesario indicar el tamaño de un árbol al compararlo con otras estructuras de datos, como matrices o listas enlazadas. Como resultado, el árbol es eficiente en términos de su espacio de almacenamiento.
2. Por el contrario, trabajar con árboles elimina la necesidad de operaciones que requieren mucha mano de obra, como insertar, eliminar y encontrar nodos, que son necesarios para las listas vinculadas.

Pasos para construir una estructura de datos de árbol en C#

Aquí tenemos un ejemplo de una estructura de datos de árbol en C#. Lea los pasos a continuación para seguir adelante.

1. Para comenzar, debemos tener las siguientes bibliotecas:

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   

2. Cree una clase llamada node en la clase Shanii que almacene las variables de tipo int key, leftn como el nodo izquierdo y rightn como el nodo derecho.

   class node {
     public int key;
     public node leftn, rightn;
   };
   

3. Luego, haz un nodo raíz y una lista de nodos llamada z a partir del objeto de un nodo.

   static node rootnode = null;
   static List<node> z = new List<node>();
   

4. Para generar un nodo con los datos, necesitamos escribir una función llamada nuevonodo que lo hará. Inicialmente, los dos hijos de este nuevo nodo son null.

   static node newnode(int val) {
     node y = new node();
     y.key = val;
     y.leftn = null;
     y.rightn = null;
     return y;
   }
   

5. Ahora, veremos si se puede acceder al nodo usando la verificación if. En caso afirmativo, se utilizará el hijo izquierdo del nodo actual.

   if (rootnode == null) {
     rootnode = node;
   }
   

6. Si está disponible, se utiliza el nodo secundario actual. Dado que el hijo izquierdo de este nodo ya se ha utilizado, se utiliza el hijo derecho.

   else if (z[0].leftn == null) {
     z[0].leftn = node;
   }
   

7. La dirección de un nodo recién agregado en el árbol se agrega a la cola. Por lo tanto, puede usarse para almacenar información sobre los nodos de sus hijos.

   else {
     z[0].rightn = node;
     z.RemoveAt(0);
   }
   z.Add(node);
   

8. La siguiente clase se usará para construir un árbol.

   static void Constructtree(int[] ar, int a) {
     for (int i = 0; i < a; i++) InsrtVal(ar[i]);
   }
   

9. La siguiente función organizará los nodos según su nivel.

   static void OrderData(node root) {}
   

10. Finalmente, mencionaremos las funciones necesarias para crear y organizar un árbol y sus parámetros.

    static void Main() {
      int[] array = { 29, 39, 49, 59, 69, 79 };
      int n = array.Length;
      Constructtree(array, n);
      OrderData(rootnode);
      Console.ReadKey();
    }
    

Código fuente completo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace tree_example {
  class Shanii {
    class node {
      public int key;
      public node leftn, rightn;
    };
    static node rootnode = null;
    static List<node> z = new List<node>();

    static node newnode(int val) {
      node y = new node();
      y.key = val;
      y.leftn = null;
      y.rightn = null;
      return y;
    }

    static void InsrtVal(int newval) {
      node node = newnode(newval);
      if (rootnode == null) {
        rootnode = node;
      }

      else if (z[0].leftn == null) {
        z[0].leftn = node;
      }

      else {
        z[0].rightn = node;
        z.RemoveAt(0);
      }
      z.Add(node);
    }

    static void Constructtree(int[] ar, int a) {
      for (int i = 0; i < a; i++) InsrtVal(ar[i]);
    }

    static void OrderData(node root) {
      if (root == null)
        return;
      List<node> n = new List<node>();
      n.Add(root);
      while (n.Count > 0) {
        Console.Write(n[0].key + " ");
        if (n[0].leftn != null)
          n.Add(n[0].leftn);
        if (n[0].rightn != null)
          n.Add(n[0].rightn);
        n.RemoveAt(0);
      }
    }

    static void Main() {
      int[] array = { 29, 39, 49, 59, 69, 79 };
      int n = array.Length;
      Constructtree(array, n);
      OrderData(rootnode);
      Console.ReadKey();
    }
  }
}

Producción :

29 39 49 59 69 79