EdD - Clase BinaryTree (lo más simple)

A continuación está la clase Node para árboles binarios

Código:


using System;

namespace E01
{
  /// <summary>
  /// Clase para representar un nodo de un árbol binario
  /// </summary>
  /// <typeparam name="ELEMENT">Tipo de dato del elemento</typeparam>
  public class Node<ELEMENT>
  {
    #region Estructura Interna y Propiedades
    /// <summary>
    /// Mantiene el elemento en el nodo
    /// </summary>
    private ELEMENT _Item;
    /// <summary>
    /// Facililta el acceso al elemento en el nodo
    /// </summary>
    public virtual ELEMENT Item
    {
      get { return this._Item; }
      set { this._Item = value; }
    }
    /// <summary>
    /// Mantiene el enlace al subárbol izquierdo
    /// </summary>
    private Node<ELEMENT> _Left;
    /// <summary>
    /// Facilita el acceso al enlace al subárbol izquierdo
    /// </summary>
    public virtual Node<ELEMENT> Left
    {
      get { return this._Left; }
      set { this._Left = value; }
    }
    /// <summary>
    /// Mantiene el elace al subárbol derecho
    /// </summary>
    private Node<ELEMENT> _Right;
    /// <summary>
    /// Facilita el acceso al enlace al subárbol derecho
    /// </summary>
    public virtual Node<ELEMENT> Right
    {
      get { return this._Right; }
      set { this._Right = value; }
    }
    #endregion

    #region Constructores
    /// <summary>
    /// Constructor por defecto, inicializa los campos de la estructura
    /// interna en valores por defecto
    /// </summary>
    public Node()
    {
      this.Item = default(ELEMENT);
      this.Left = null;
      this.Right = null;
    }
    /// <summary>
    /// Constructor especializado, permite fijar el elemento del nodo
    /// </summary>
    /// <param name="item">Elemento en el nodo</param>
    public Node(ELEMENT item)
      : this()
    {
      this.Item = item;
    }
    /// <summary>
    /// Constructor especializado, permite fijar el elemento del nodo
    /// y el valor de los enlaces a subárboles izquierdo y derecho
    /// </summary>
    /// <param name="item">Elemento en el nodo</param>
    /// <param name="next">Enlace al subárbol izquierdo</param>
    /// <param name="prev">Enlace al subárbol derecho</param>
    public Node(ELEMENT item, Node<ELEMENT> left, Node<ELEMENT> right)
      : this()
    {
      this.Item = item;
      this.Left = left;
      this.Right = right;
    }
    #endregion

    /// <summary>
    /// Metodo para probar las distintas formas en que
    /// se puede recorrer un árbol
    /// </summary>
    public virtual void Visit()
    {
      Console.Write("{0} ", this.Item.ToString());
    }
  }
}


La clase BinaryTree es esta:

Código:


using System;
using System.Text;

namespace E01
{
  /// <summary>
  /// Implementación de árbol binario
  /// </summary>
  /// <typeparam name="ELEMENT">Tipo de dato de elementos que se introduce en el árbol</typeparam>
  public class BinaryTree <ELEMENT>
  {
    #region Estructura interna y Propiedades
    /// <summary>
    /// Mantiene la raíz del árbol
    /// </summary>
    private Node<ELEMENT> _Root;
    /// <summary>
    /// Facililta el acceso a la raíz del árbol
    /// </summary>
    protected virtual Node<ELEMENT> Root
    {
      get { return this._Root; }
      set { this._Root = value; }
    }
    #endregion

    #region Otras Propiedades
    /// <summary>
    /// Indica si el árbol está vacio
    /// </summary>
    public virtual Boolean IsEmpty
    {
      get { return this.Root == null; }
    }
    #endregion 

    #region Constructores
    /// <summary>
    /// Constructor por defecto
    /// </summary>
    public BinaryTree()
    {
      this.Root = null;
    }
    /// <summary>
    /// Constructor especializado, permite asignar
    /// el valor del item de la raíz del árbol
    /// </summary>
    /// <param name="root">referencia al item de la raíz del árbol, puede ser null</param>
    public BinaryTree(ELEMENT item)
      : this()
    {
      this.Root = new Node<ELEMENT>(item);
    }
    /// <summary>
    /// Constructor especializado, permite asignar
    /// el valor del item de la raíz del árbol y
    /// los subárboles izquierdo y derecho
    /// </summary>
    /// <param name="root">referencia al item de la raíz del árbol, puede ser null</param>
    /// <param name="left">referencia a un árbol que estará a la izquierda, puede ser null</param>
    /// <param name="right">referencia a un árbol que estará a la derecha, puede ser null</param>
    public BinaryTree(ELEMENT item, BinaryTree<ELEMENT> leftTree, BinaryTree<ELEMENT> rightTree)
      : this()
    {
      this.Root = new Node<ELEMENT>(item);
      if (leftTree != null)
      {
        this.Root.Left = leftTree.Root;
      }
      if (rightTree != null)
      {
        this.Root.Right = rightTree.Root;
      }
    }
    #endregion

    #region Comportamiento heredado de object
    /// <summary>
    /// Muestra la representación del árbol en forma de lista
    /// </summary>
    /// <returns>Cadena con la representación</returns>
    public override string ToString()
    {
      return ToString(this.Root);
    }
    /// <summary>
    /// Implementación recursiva para mostrar un árbol en forma de lista
    /// </summary>
    /// <param name="root">Nodo del árbol</param>
    /// <returns>Cadena con la representación</returns>
    protected string ToString(Node<ELEMENT> root)
    {
      StringBuilder sb = new StringBuilder();
      //string s = string.Empty;
      if (root != null)
      {
        //s = root.Item.ToString();
        sb.Append(root.Item.ToString());
        if (root.Left != null)
        {
          //s = s + " (" + ToString(root.Left);
          sb.Append(" (" + ToString(root.Left));
          if (root.Right != null)
          {
            //s = s + ", " + ToString(root.Right);
            sb.Append(", " + ToString(root.Right));
          }
          //s = s + ")";
          sb.Append(")");
        }
        else
        {
          if (root.Right != null)
          {
            //s = s + " (, " + ToString(root.Right) + ")";
            sb.Append(" (, " + ToString(root.Right) + ")");
          }
        }
      }
      //return s;
      return sb.ToString(); ;
    }
    #endregion

    #region Comportamiento para recorrer un árbol
    /// <summary>
    /// Implementación del recorrido Pre Orden
    /// para la instancia
    /// </summary>
    public virtual void PreOrder()
    {
      PreOrder(this.Root);
    }
    /// <summary>
    /// Implementación recursiva para recorrer un
    /// árbol en Pre Orden
    /// </summary>
    /// <param name="root">Nodo a visitar</param>
    protected virtual void PreOrder(Node<ELEMENT> root)
    {
      if (root != null)
      {
        root.Visit();
        PreOrder(root.Left);
        PreOrder(root.Right);
      }
    }
    /// <summary>
    /// Implementación del recorrido En Orden
    /// para la instancia
    /// </summary>
    public virtual void InOrder()
    {
      InOrder(this.Root);
    }
    /// <summary>
    /// Implementación recursiva para recorrer un
    /// árbol en En Orden
    /// </summary>
    /// <param name="root">Nodo a visitar</param>
    protected virtual void InOrder(Node<ELEMENT> root)
    {
      if (root != null)
      {
        InOrder(root.Left);
        root.Visit();
        InOrder(root.Right);
      }
    }
    /// <summary>
    /// Implementación del recorrido Post Orden
    /// para la instancia
    /// </summary>
    public virtual void PostOrder()
    {
      PostOrder(this.Root);
    }
    /// <summary>
    /// Implementación recursiva para recorrer un
    /// árbol en PostOrden
    /// </summary>
    /// <param name="root">Nodo a visitar</param>
    protected virtual void PostOrder(Node<ELEMENT> root)
    {
      if (root != null)
      {
        PostOrder(root.Left);
        PostOrder(root.Right);
        root.Visit();
      }
    }
    #endregion
  }
}


Como dije esta es la primera implementación, obviamente no sirve para mucho pero por algo se comienza.