c#数据结构--树类

网上找到的

using System;
using System.Collections;

namespace Tree
{
/**//**//**//// <summary>
/// LEFT左子树，RIGHT右子树
/// </summary>
enum Position{LEFT,RIGHT};
/**//**//**//// <summary>
/// LINK指向孩子，THREAD指向后继
/// </summary>
enum Tag{LINK,THREAD};
/**//**//**//// <summary>
/// 二叉树节点的抽象定义
/// </summary>
interface IBinNode
{
  bool isLeaf();
  object Element{get;set;}
  IBinNode Left{get;set;}
  IBinNode Right{get;set;}
}

/**//**//**//// <summary>
/// 遍历，线索化等操作的接口
/// </summary>
interface ITravelBinTree
{
  void PreOrderTravel();
  void InOrderTravel();
  void RevOrderTravel();
  void Print(IBinNode t);
}
interface IInsertBinTree
{
  void Insert(IBinNode node,Position pos);
}
/**//**//**//// <summary>
/// Normal actualize of bintree
/// </summary>
class BinNodePtr : IBinNode
{
  protected object element;
  protected IBinNode lchild;
  protected IBinNode rchild;
  public BinNodePtr(object e,IBinNode left,IBinNode right)
  {
   element = e;
   lchild = left;
   rchild = right;
  }
  public BinNodePtr(object e)
  {
   element = e;
   lchild = rchild = null;
  }
  public BinNodePtr()
  {
   element = null;
   lchild = rchild =null;
  }
  public bool isLeaf()
  { 
   if(lchild==null && rchild==null)
    return true;
   return false;
  }
  public object Element
  {
   get{return element;}
   set{element = value;}
  }
  public IBinNode Left
  {
   get
   {
    return lchild;
   }
   set
   {
    lchild = value;
   }
  }
  public IBinNode Right
  {
   get
   {
    return rchild;
   }
   set
   {
    rchild = value;
   }
  }
}
class BinNodeLine : BinNodePtr,IBinNode
{
  private Tag ltag,rtag;
  public BinNodeLine(object e,IBinNode left,IBinNode right) :base(e,left,right)
  {ltag = rtag = Tag.LINK;}
  public BinNodeLine(object e) : base(e)
  {ltag = rtag = Tag.LINK;}
  public Tag LTag
  {
   get{return ltag;}
   set{ltag = value;}
  }
  public Tag RTag
  {
   get{return rtag;}
   set{rtag = value;}
  }
}
class TravelBinTree : ITravelBinTree,IInsertBinTree
{
  const int INIT_TREE_SIZE=20;
  private IBinNode tree;
  private BinNodeLine head; //线索化后的头指针
  private IBinNode prenode; //指向最近访问过的前驱节点
  public TravelBinTree()
  {
   tree = new BinNodePtr();
  }
  public TravelBinTree(IBinNode INode)
  {
   tree = INode;
  }
  /**//**//**//// <summary>
  /// 先序遍历树,用非递归算法实现
  /// </summary>
  /// <remarks>非递归实现</remarks>
  public void PreOrderTravel()
  {
   IBinNode temptree;
   Stack stk = new Stack(INIT_TREE_SIZE);
   if(tree == null)
    throw(new InvalidOperationException("访问的树为空"));
   temptree = tree;
   stk.Push(tree);
   while(stk.Count!=0)
   {
    while(temptree!=null)
    {
     Print(temptree);
     stk.Push(temptree.Left);
     temptree = temptree.Left;
    }
    stk.Pop(); // 空指针退栈
    if(stk.Count != 0)
    {
     temptree=(IBinNode)stk.Pop();
     stk.Push(temptree.Right);
     temptree = temptree.Right;
    }
   }
  }
  public void InOrderTravel()
  {
   InOrderTravel(tree);
  }
  private void InOrderTravel(IBinNode t)
  {
   if(t==null) return;
   InOrderTravel(t.Left);
   Print(t);
   InOrderTravel(t.Right);
  }
  public void RevOrderTravel()
  {
   RevOrderTravel(tree);
  }
  private void RevOrderTravel(IBinNode t)
  {
   if(t==null) return;
   RevOrderTravel(t.Left);
   RevOrderTravel(t.Right);
   Print(t);
  }
  public void Print(IBinNode t)
  {
   Console.Write(t.Element + ",");
  }
  public void Insert(IBinNode node,Position pos)
  {
   if(node == null)
    throw(new InvalidOperationException("不能将空节点插入树"));
   switch(pos)
   {
    case Position.LEFT : tree.Left = node;break;
    case Position.RIGHT: tree.Right = node;break;
   }
  }
  /**//**//**//// <summary>
  /// 按照先序遍历顺序遍历树
  /// </summary>
  public void TreeBuilder()
  {
   Stack stk = new Stack(INIT_TREE_SIZE);
   stk.Push(tree);
   Position pos;
   string para;
   pos = Position.LEFT;
   IBinNode baby,temp;
   while(true)
   {
    para = Console.ReadLine();
    if(para == "")
    {
     if(pos == Position.RIGHT)
     {
      stk.Pop();
      while(stk.Count!=0 && ((IBinNode)stk.Peek()).Right!=null)
       stk.Pop();
      if(stk.Count ==0) break;
     }
     else
      pos = Position.RIGHT;
    }
    else
    {
     if(tree.GetType().Equals()==true)
      baby = new BinNodePtr(para);
     temp = (IBinNode)stk.Peek();
     if(pos == Position.LEFT)
      temp.Left = baby;
     else
      temp.Right = baby;
     pos = Position.LEFT;
     stk.Push(baby);
    }
   }

  }
  /**//**//**//// <summary>
  /// 中序线索化
  /// </summary>
  public void InOrderThreading()
  {
   head = new BinNodeLine("");
   head.RTag = Tag.THREAD;
   head.Right = head;
   if(tree == null) head.Left = head;
   else
   {
    head.Left = tree; prenode = head;

   }
  }
  /**//**//**//// <summary>
  /// 中序线索化的递归实现
  /// </summary>
  /// <param name="t"></param>
  private void InThreading(IBinNode t)
  {
   if(t==null) 
    return;
   else
   {
    InThreading(t.Left);
   // if(left
   }
  }
}
/**//**//**//// <summary>
/// Summary description for Class1.
/// </summary>
class Class1
{
  /**//**//**//// <summary>
  /// 测试控制台
  /// </summary>
  /// <param name="args"></param>
  static void Main(string[] args)
  {
   string para = null;
   para = Console.ReadLine();
   BinNodePtr root = new BinNodePtr(para);
   TravelBinTree t = new TravelBinTree(root);
   t.TreeBuilder();
   t.PreOrderTravel();
   Console.WriteLine("");
   t.InOrderTravel();
   Console.WriteLine("");
   t.RevOrderTravel();
  }
}
}