Advertisement
jtentor

BinaryTree.cs - 1.00

Nov 12th, 2015
576
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Text;
  3.  
  4. namespace DemoBinaryTree
  5. {
  6.     /// <summary>
  7.     /// Implementación de Árbol Binario
  8.     /// </summary>
  9.     /// <typeparam name="E">Tipo de dato del elemento que se referencia en cada nodo</typeparam>
  10.     public class BinaryTree<E>
  11.     {
  12.         /// <summary>
  13.         /// Mantiene la raíz del árbol
  14.         /// </summary>
  15.         private BTNode<E> root;
  16.         protected virtual BTNode<E> Root
  17.         {
  18.             get { return this.root; }
  19.             set { this.root = value; }
  20.         }
  21.  
  22.         public virtual Boolean IsEmpty
  23.         {
  24.             get { return this.Root == null; }
  25.         }
  26.  
  27.         /// <summary>
  28.         /// Constructor por defecto con valor por defecto
  29.         /// </summary>
  30.         public BinaryTree(BTNode<E> root = null)
  31.         {
  32.             this.Root = root;
  33.         }
  34.  
  35.         /// <summary>
  36.         /// Constructor especializado, permite asignar
  37.         /// el valor del item de la raíz del árbol
  38.         /// </summary>
  39.         /// <param name="root">referencia al item de la raíz del árbol, puede ser null</param>
  40.         public BinaryTree(E item = default(E)) : this(new BTNode<E>(item))
  41.         { }
  42.  
  43.         /// <summary>
  44.         /// Constructor especializado, permite asignar
  45.         /// el valor del item de la raíz del árbol y
  46.         /// los subárboles izquierdo y derecho
  47.         /// </summary>
  48.         /// <param name="root">referencia al item de la raíz del árbol, puede ser null</param>
  49.         /// <param name="leftTree">referencia a un árbol que estará a la izquierda, puede ser null</param>
  50.         /// <param name="rightTree">referencia a un árbol que estará a la derecha, puede ser null</param>
  51.         public BinaryTree(E item, BinaryTree<E> leftTree = null, BinaryTree<E> rightTree = null)
  52.         {
  53.             this.Root = new BTNode<E>(item);
  54.             if (leftTree != null)
  55.             {
  56.                 this.Root.Left = leftTree.Root;
  57.             }
  58.             if (rightTree != null)
  59.             {
  60.                 this.Root.Right = rightTree.Root;
  61.             }
  62.         }
  63.  
  64.         /// <summary>
  65.         /// Devuelve el subárbol izquierdo si no esta vacío
  66.         /// </summary>
  67.         /// <returns>Referencia al subárbol izquierdo</returns>
  68.         public BinaryTree<E> GetLeftSubTree()
  69.         {
  70.             if (IsEmpty)
  71.             {
  72.                 throw new Exception("Árbol vacío");
  73.             }
  74.             return new BinaryTree<E>(Root.Left);
  75.         }
  76.  
  77.         /// <summary>
  78.         /// Devuelve el subárbol derecho si no esta vacío
  79.         /// </summary>
  80.         /// <returns>Referencia al subárbol derecho</returns>
  81.         public BinaryTree<E> GetRightSubTree()
  82.         {
  83.             if (IsEmpty)
  84.             {
  85.                 throw new Exception("Árbol vacío");
  86.             }
  87.             return new BinaryTree<E>(Root.Right);
  88.         }
  89.  
  90.         /// <summary>
  91.         /// Muestra la representación del árbol en forma de lista
  92.         /// </summary>
  93.         /// <returns>Cadena con la representación</returns>
  94.         public override string ToString()
  95.         {
  96.             return ToString(this.Root);
  97.         }
  98.         /// <summary>
  99.         /// Implementación recursiva para mostrar un árbol en forma de lista
  100.         /// </summary>
  101.         /// <param name="root">Nodo del árbol</param>
  102.         /// <returns>Cadena con la representación</returns>
  103.         protected string ToString(BTNode<E> root)
  104.         {
  105.             StringBuilder sb = new StringBuilder();
  106.             //string s = string.Empty;
  107.             if (root != null)
  108.             {
  109.                 //s = root.Item.ToString();
  110.                 sb.Append(root.Item.ToString());
  111.                 if (root.Left != null)
  112.                 {
  113.                     //s = s + " (" + ToString(root.Left);
  114.                     sb.Append(" (" + ToString(root.Left));
  115.                     if (root.Right != null)
  116.                     {
  117.                         //s = s + ", " + ToString(root.Right);
  118.                         sb.Append(", " + ToString(root.Right));
  119.                     }
  120.                     //s = s + ")";
  121.                     sb.Append(")");
  122.                 }
  123.                 else
  124.                 {
  125.                     if (root.Right != null)
  126.                     {
  127.                         //s = s + " (, " + ToString(root.Right) + ")";
  128.                         sb.Append(" (, " + ToString(root.Right) + ")");
  129.                     }
  130.                 }
  131.             }
  132.             //return s;
  133.             return sb.ToString(); ;
  134.         }
  135.  
  136.         #region Comportamiento para recorrer un árbol
  137.         /// <summary>
  138.         /// Implementación del recorrido Pre Orden
  139.         /// </summary>
  140.         public virtual void PreOrder()
  141.         {
  142.             PreOrder(this.Root);
  143.         }
  144.         /// <summary>
  145.         /// Implementación recursiva de Pre Orden
  146.         /// </summary>
  147.         /// <param name="root">Nodo a visitar</param>
  148.         protected virtual void PreOrder(BTNode<E> root)
  149.         {
  150.             if (root != null)
  151.             {
  152.                 root.Visit();
  153.                 PreOrder(root.Left);
  154.                 PreOrder(root.Right);
  155.             }
  156.         }
  157.         /// <summary>
  158.         /// Implementación del recorrido En Orden
  159.         /// </summary>
  160.         public virtual void InOrder()
  161.         {
  162.             InOrder(this.Root);
  163.         }
  164.         /// <summary>
  165.         /// Implementación recursiva de En Orden
  166.         /// </summary>
  167.         /// <param name="root">Nodo a visitar</param>
  168.         protected virtual void InOrder(BTNode<E> root)
  169.         {
  170.             if (root != null)
  171.             {
  172.                 InOrder(root.Left);
  173.                 root.Visit();
  174.                 InOrder(root.Right);
  175.             }
  176.         }
  177.         /// <summary>
  178.         /// Implementación del recorrido Post Orden
  179.         /// </summary>
  180.         public virtual void PostOrder()
  181.         {
  182.             PostOrder(this.Root);
  183.         }
  184.         /// <summary>
  185.         /// Implementación recursiva de Post Orden
  186.         /// </summary>
  187.         /// <param name="root">Nodo a visitar</param>
  188.         protected virtual void PostOrder(BTNode<E> root)
  189.         {
  190.             if (root != null)
  191.             {
  192.                 PostOrder(root.Left);
  193.                 PostOrder(root.Right);
  194.                 root.Visit();
  195.             }
  196.         }
  197.  
  198.         /// <summary>
  199.         /// Implementación del recorrido En Orden Descendente
  200.         /// </summary>
  201.         public virtual void InDescendingOrder()
  202.         {
  203.             InDescendingOrder(this.Root);
  204.         }
  205.         /// <summary>
  206.         /// Implementación recursiva de En Orden Descendente
  207.         /// </summary>
  208.         /// <param name="root">Nodo a visitar</param>
  209.         protected virtual void InDescendingOrder(BTNode<E> root)
  210.         {
  211.             if (root != null)
  212.             {
  213.                 InDescendingOrder(root.Right);
  214.                 root.Visit();
  215.                 InDescendingOrder(root.Left);
  216.             }
  217.         }
  218.        
  219.        
  220.         #endregion
  221.  
  222.        
  223.        
  224.         /// <summary>
  225.         /// Cuenta la cantidad de nodos
  226.         /// </summary>
  227.         /// <returns>Cantidad de nodos</returns>
  228.         public virtual int NodeCount()
  229.         {
  230.             return NodeCount(this.Root);
  231.         }
  232.         /// <summary>
  233.         /// Cuenta recursivamente la cantidad de nodos
  234.         /// </summary>
  235.         /// <param name="root">Nodo a procesar</param>
  236.         /// <returns>Cantidad de nodos</returns>
  237.         protected virtual int NodeCount(BTNode<E> root)
  238.         {
  239.             if (root != null)
  240.             {
  241.                 return 1 + NodeCount(root.Left) + NodeCount(root.Right);
  242.             }
  243.             return 0;
  244.         }
  245.  
  246.         /// <summary>
  247.         /// Cuenta la cantidad de hojas
  248.         /// </summary>
  249.         /// <returns>Cantidad de hojas</returns>
  250.         public virtual int LeafCount()
  251.         {
  252.             return LeafCount(this.Root);
  253.         }
  254.         /// <summary>
  255.         /// Cuenta recursivamente la cantidad de hojas
  256.         /// </summary>
  257.         /// <param name="root">Nodo a procesar</param>
  258.         /// <returns>Cantidad de hojas</returns>
  259.         protected virtual int LeafCount(BTNode<E> root)
  260.         {
  261.             if (root != null)
  262.             {
  263.                 if ((root.Left == null) && (root.Right == null))
  264.                 {
  265.                     return 1;
  266.                 }
  267.                 else
  268.                 {
  269.                     return LeafCount(root.Left) + LeafCount(root.Right);
  270.                 }
  271.             }
  272.             return 0;
  273.         }
  274.  
  275.         /// <summary>
  276.         /// Cuenta la cantidad de nodos internos
  277.         /// </summary>
  278.         /// <returns>Cantidad de nodos internos</returns>
  279.         public virtual int InternalNodeCount()
  280.         {
  281.             return InternalNodeCount(this.Root);
  282.         }
  283.         /// <summary>
  284.         /// Cuenta recursivamente la cantidad de nodos internos
  285.         /// </summary>
  286.         /// <param name="root">Nodo a procesar</param>
  287.         /// <returns>Cantidad de nodos internos</returns>
  288.         protected virtual int InternalNodeCount(BTNode<E> root)
  289.         {
  290.             if (root != null)
  291.             {
  292.                 if ((root.Left == null) && (root.Right == null))
  293.                 {
  294.                     return 0;
  295.                 }
  296.                 else
  297.                 {
  298.                     return 1 + LeafCount(root.Left) + LeafCount(root.Right);
  299.                 }
  300.             }
  301.             return 0;
  302.         }
  303.  
  304.         /// <summary>
  305.         /// Determina el máximo nivel
  306.         /// </summary>
  307.         /// <returns>Nro de nivel</returns>
  308.         public virtual int MaxLevel()
  309.         {
  310.             if (!IsEmpty)
  311.             {
  312.                 return MaxLevel(this.Root);
  313.             }
  314.             return -1;
  315.         }
  316.         /// <summary>
  317.         /// Determina recursivamente el máximo nivel
  318.         /// </summary>
  319.         /// <param name="root">Nodo a procesar</param>
  320.         /// <returns>Nro de nivel</returns>
  321.         protected virtual int MaxLevel(BTNode<E> root)
  322.         {
  323.             if (root != null)
  324.             {
  325.                 if ((root.Left != null) || (root.Right != null))
  326.                 {
  327.                     int leftLevel = MaxLevel(root.Left);
  328.                     int rightLevel = MaxLevel(root.Right);
  329.                     return 1 + Math.Max(leftLevel, rightLevel);
  330.                 }
  331.             }
  332.             return 0;
  333.         }
  334.  
  335.         /// <summary>
  336.         /// Determina la altura
  337.         /// </summary>
  338.         /// <returns>Altura</returns>
  339.         public virtual int Height()
  340.         {
  341.             return MaxLevel() + 1;
  342.         }
  343.     }
  344. }
Advertisement
RAW Paste Data Copied
Advertisement