数据结构与算法(C#实现) [ 来自：CSDN ]

二叉树

程序代码：

[ 复制代码到剪贴板 ]

using System;
using System.Collections;

namespace DataStructure
{
    /// <summary>
    /// BinaryTree 的摘要说明。
    /// </summary>
    public class BinaryTree:NaryTree
    {
         //构造二叉空树
         public BinaryTree():base(2)
         {
             //
             // TODO: 在此处添加构造函数逻辑
             //
         }
         
  public BinaryTree(object _obj):base(2,_obj)
         {
  
  }

         //------------------------------------------------------------------
         protected override object GetEmptyInstance(uint _degree)
         {
      return new BinaryTree(_degree);
  }
         //------------------------------------------------------------------
 
         //重写深度遍历
         public override void DepthFirstTraversal(IPrePostVisitor _vis)
         {
              if ( !IsEmpty() )
              {
                  _vis.PreVisit(this.Key);
                  this[0].DepthFirstTraversal(_vis);
                  _vis.Visit(this.Key);
                  this[1].DepthFirstTraversal(_vis);
                  _vis.PostVisit(this.Key);
              }
          }


          //二叉树大小的比较
          //先比较关键字，如果相等，再比较左子树，如果再相等，则比较右子树----如此递归
          #region IComparable 成员

          public override int CompareTo(object obj)
          {
               // TODO: 添加 BinaryTree.CompareTo 实现
               //因为Comare()中已经进行了类型断定，故不会出现转型错误
               BinaryTree tmpTree=(BinaryTree)obj;
 
               if( this.IsEmpty() )
                   return tmpTree.IsEmpty()?0:-1;
               if( tmpTree.IsEmpty() )
                   return 1;
               int result=Comparer.Default.Compare(this,tmpTree);
               if(result==0)
                   result=this[0].CompareTo(tmpTree[0]);
               if(result==0)
                   result=this[1].CompareTo(tmpTree[1]);
 
               return result;
           }

           #endregion
      }
 }

二叉堆（数组实现）

程序代码：

[ 复制代码到剪贴板 ]

using System;
using System.Collections;

namespace DataStructure
{
    /// <summary>
    /// BinaryHeap 的摘要说明。-------二叉堆(基于数组的实现)
    /// </summary>
    public class BinaryHeap:IPriorityQueue
    {
         protected ArrayList array;
         //建立一个最多容纳_length个对象的空二叉堆
         public BinaryHeap(uint _length)
         {
              //
              // TODO: 在此处添加构造函数逻辑
              //
              array=new ArrayList((int)_length);
              array.Capacity=(int)_length;
         }

         //堆中对象个数
         public virtual int Count{get{return this.array.Count;}
    }

    //将成员数组变成用1为基数表达的形式
    public virtual object Item(int _i)
    {
         if(_i>=this.array.Capacity)
         throw new Exception("My:out of index");//不能出界
         return this.array[_i-1];
    }
 
    #region IPriorityQueue 成员

    //先将空洞放在数组的下一个位置上，也就是i(注：基数是1),然后和[i/2]位置上的数比较，如果小于则将空洞上移到[i/2]位置，而原先[i/2]位置上的对象则移到[i]上，否则就将空洞变为_obj----如此递归
    public void Enqueue(Object _obj)
    {
       // TODO: 添加 BinaryHeap.Enqueue 实现
       if( this.array.Count==this.array.Capacity )
           throw new Exception("My:priority queue is full");//如果优先队列已满，则抛出异常
       this.array.Add(new object());
       int i=this.array.Count;
       while(i>1&&Comparer.Default.Compare(this.array[i/2-1],_obj )>0)
       {
           //this.Item(i)=this.Item(i/2);
           this.array[i-1]=this.array[i/2-1];
           i/=2;
       }
       this.array[i-1]=_obj;
    }

    public object FindMin()
    {
         // TODO: 添加 BinaryHeap.FindMin 实现
         if( this.array.Count==0 )
             throw new Exception("My:priority queue is empty");//如果队列是空的，则抛出异常
         return this.array[0];
    }

    public object DequeueMin()
    {
         // TODO: 添加 BinaryHeap.DequeueMin 实现
         object tmpObj=this.FindMin();
         int i=1;
         while( (2*i+1)<=this.array.Count)
         {
             if( Comparer.Default.Compare(this.array[2*i-1],this.array[2*i])<=0 )
             {
                 this.array[i-1]=this.array[2*i-1];
                 this.array[2*i-1]=tmpObj;
                 i=2*i;
             }
             else
             {
                 this.array[i-1]=this.array[2*i];
                 this.array[2*i]=tmpObj;
                 i=2*i+1;
             }
         }

         object delObj=this.array[i-1];//暂时储存要删去的元素

         if(i!=this.array.Count)//如果搜索到的对象就是数组的最后一个对象，则什么都不要做
         {
             this.array[i-1]=this.array[this.array.Count-1];//添补空洞
         }
         this.array.RemoveAt(this.array.Count-1);//将最后一个对象删除
         return delObj;
     }

     #endregion
 }
}

AVLTree

程序代码：

[ 复制代码到剪贴板 ]

using System;

using System.Collections;

 

namespace DataStructure

{

     /// 

     /// AVLTree 的摘要说明。-----平衡二叉查找树

     /// 

     public class AVLTree:BST

     {

         protected int height;//空树的高定义为-1;

         //构造一棵空的二叉查找树

         public AVLTree():base()

         {

              //

              // TODO: 在此处添加构造函数逻辑

              //

              height=-1;

         }

         public AVLTree(object _obj):base(_obj)

         {

              height=0;

         }

         //------------------------------------------------------------------

         protected override object GetEmptyInstance(uint _degree)

         {    return new AVLTree(); }

         //------------------------------------------------------------------

 

         protected int BalanceFactor()

         {

              if (this.IsEmpty() )

                   return 0;

              return ((AVLTree)this.Left).height-((AVLTree)this.Right).height;

         }

         //调整高度

         protected void AdjustHeight(){   this.height=Math.Max( ((AVLTree)this.Left).height, ((AVLTree)this.Right).height)+1;     }

         //平衡时的四种旋转方式

         protected void LLRotation()

         {

              if( this.IsEmpty() )

                   throw new Exception("My:invalid operation!");

              AVLTree avlB=new AVLTree(this.key);

                            avlB.AttachSubtree(1,(AVLTree)this[0][1]);

              avlB.AttachSubtree(2,(AVLTree)this[1]);

 

              

              this.key=this[0].Key;

              this[0]=this[0][0];

              this[1]=avlB;

              //调整两个节点的高度

              ((AVLTree)this.Right).AdjustHeight();

              this.AdjustHeight();

         }

         protected void LRRotation()

         {

              if( this.IsEmpty() )

                   throw new Exception("My:invalid operation!");

              ((AVLTree)this.Left).RRRotation();

              this.LLRotation();

 

         }

         protected void RRRotation()

         {

              if( this.IsEmpty() )

                   throw new Exception("My:invalid operation!");

              AVLTree avlB=new AVLTree(this.key);

              

 

              avlB.AttachSubtree(1,(AVLTree)this[0]);

              avlB.AttachSubtree(2,(AVLTree)this[1][0]);

 

              //avlA.AttachSubtree(1,avlB);

              

              //this=avlA;

              this.key=this[1].Key;

              this[0]=avlB;

              this[1]=this[1][1];

              //调整两个节点的高度

              ((AVLTree)this.Left).AdjustHeight();

              this.AdjustHeight();

         }

         protected void RLRotation()

         {

              if( this.IsEmpty() )

                   throw new Exception("My:invalid operation!");

              ((AVLTree)this.Right).LLRotation();

              this.RRRotation();

         }

//---------------override--------------------

         public override void AttachKey(object _obj)

         {

              if(!IsEmpty())

                   throw new Exception("My:this node must be a empty tree node!");

              this.key=_obj;

              //产生一个degree长的数组,并将其初始化为空树

              this.treeList=new ArrayList();

              this.treeList.Capacity=(int)this.degree;

              for(int i=0;i
              {

                   treeList.Add(new AVLTree());

              }

              //

              this.height=0;

         }

         //在改动树的结构后平衡树

         public override void Balance()

         {

              this.AdjustHeight();

              //大于1则说明不平衡

              if( Math.Abs(this.BalanceFactor())>1)

              {

                   if(this.BalanceFactor()>0)

                   {

                       if (((AVLTree)this.Left).BalanceFactor()>0)

                            this.LLRotation();

                       else

                            this.LRRotation();

                   }                  

                   else

                   {

                       if (((AVLTree)this.Right).BalanceFactor()<0)

                            this.RRRotation();

                       else

                            this.RLRotation();

                   }

              }

         }

         public int Height{get{return this.height;}}
}