二叉树相关算法

节点：

 

  class  Node < T >
    {
         public  T Value {  get ;  set ; }

         public  Node < T >  Left {  get ;  set ; }

         public  Node < T >  Right {  get ;  set ; }

         public  Node(T value, Node < T >  left, Node < T >  right)
        {
            Value  =  value;
            Left  =  left;
            Right  =  right;
        }

         public  Node(T value) :  this (value,  null ,  null ) { }
    }

 

 

二叉树：

 

前中后深度优先遍历非递归，上到下（下到上）宽度优先遍历非递归，输出某层，获取深度

    class  BinaryTree < T >
    {
         protected  IComparer < T >  comparer  =  Comparer < T > .Default; 

         public  Node < T >  Root {  get ;  set ; }

         public   void  Clear()
        {
            Root  =   null ;
        }

         public   void  PreOrder()
        {
             if  (Root  ==   null )
                 return ;
            
            Stack < Node < T >>  stack  =   new  Stack < Node < T >> ();
            stack.Push(Root);

             while  (stack.Count  >   0 )
            {
                Node < T >  node  =  stack.Pop();
                Console.Write(node.Value  +   "   " );
                 if  (node.Right  !=   null )
                    stack.Push(node.Right);
                 if  (node.Left  !=   null )
                    stack.Push(node.Left);
            }         
        }

         public   void  MidOrder()
        {
             if  (Root  ==   null )
                 return ;

            Stack < Node < T >>  stack  =   new  Stack < Node < T >> ();
             for  (Node < T >  current  =  Root; current  !=   null   ||  stack.Count  >   0 ; current  =  current.Right)
            {
                 while  (current  !=   null )
                {
                    stack.Push(current);
                    current  =  current.Left;
                }

                current  =  stack.Pop();
                Console.Write(current.Value  +   "   " );
            }
        }

         public   void  AfterOrder()
        {
             if  (Root  ==   null )
                 return ;
            Stack < Node < T >>  toVisit  =   new  Stack < Node < T >> ();
            Stack < bool >  hasBeenProcessed  =   new  Stack < bool > ();
            Node < T >  current  =  Root;
             if  (current  !=   null )
            {
                toVisit.Push(current);
                hasBeenProcessed.Push( false );
                current  =  current.Left;
            }

             while  (toVisit.Count  !=   0 )
            {
                 if  (current  !=   null )
                {
                    toVisit.Push(current);
                    hasBeenProcessed.Push( false );
                    current  =  current.Left;
                }
                 else
                {
                     bool  processed  =  hasBeenProcessed.Pop();
                    Node < T >  node  =  toVisit.Pop();
                     if  ( ! processed)
                    {
                        toVisit.Push(node);
                        hasBeenProcessed.Push( true );  
                        current  =  node.Right;
                    }
                     else
                        Console.WriteLine(node.Value  +   "   " );
                }
            }
        }

         public   void  UpDownOrder()
        {
             if  (Root  ==   null ) 
                 return ;
            Queue < Node < T >>  queue  =   new  Queue < Node < T >> ();
            queue.Enqueue(Root);
            
             while  (queue.Count  >   0 )
            {
                Node < T >  node  =  queue.Dequeue();
                Console.Write(node.Value  +   "   " );
                 if  (node.Left  !=   null )
                    queue.Enqueue(node.Left);
                 if  (node.Right  !=   null )
                    queue.Enqueue(node.Right);
            }         
        }

         public   void  DownUpOrder()
        {
             if  (Root  ==   null )
                 return ;
            Queue < Node < T >>  queue  =   new  Queue < Node < T >> ();
            queue.Enqueue(Root);
            Stack < Node < T >>  stack  =   new  Stack < Node < T >> ();
             while  (queue.Count  >   0 )
            {
                Node < T >  node  =  queue.Dequeue();
                stack.Push(node);
                 if  (node.Left  !=   null )
                    queue.Enqueue(node.Left);
                 if  (node.Right  !=   null )
                    queue.Enqueue(node.Right);
            }
             int  c  =  stack.Count;
             for  ( int  i  =   0 ; i  <  c; i ++ )
            {
                Console.Write(stack.Pop().Value  +   "   " );
            }
        }

         public   void  PrintNodeAtLevel( int  level)
        {
             if  (level  ==   0 ) Console.Write(Root.Value  +   "   " );
            PrintNodeAtLevel(Root, level);
        }

         private   void  PrintNodeAtLevel(Node < T >  node,  int  level)
        {
             if  (node  ==   null   ||  level  <   0 )
                 return ;
             if  (level  ==   0 )
            {
                Console.Write(node.Value  +   "   " );
                 return ;
            }
            PrintNodeAtLevel(node.Left, level  -   1 );
            PrintNodeAtLevel(node.Right, level  -   1 );
        }

         public   int  GetDepth()
        {
             if  (Root  ==   null )
                 return   0 ;
             return  GetDepth(Root);
        }

         private   int  GetDepth(Node < T >  node)
        {
             if  (node  ==   null )  return   0 ;
             int  l  =  GetDepth(node.Left);
             int  r  =  GetDepth(node.Right);
             return  Math.Max(l,r)  +   1 ;
        }
    }

 

 

搜索二叉树：

 

搜索、包含、增加删除、获取父节点

  class  BinarySearchTree < T >  : BinaryTree < T >
    {
         public  Node < T >  Search(T data)
        {
            Node < T >  current  =  Root;
             while  (current  !=   null )
            {
                 int  result  =  comparer.Compare(current.Value, data);
                 if  (result  ==   0 )
                     return  current;
                 else   if  (result  >   0 )
                    current  =  current.Left;
                 else   if  (result  <   0 )
                    current  =  current.Right;
            }
             return  current;
        }

         public   bool  Contains(T data)
        {
            Node < T >  current  =  Root;
             int  result;
             while  (current  !=   null )
            {
                result  =  comparer.Compare(current.Value, data);
                 if  (result  ==   0 )
                     return   true ;
                 else   if  (result  >   0 )
                    current  =  current.Left;
                 else   if  (result  <   0 )
                    current  =  current.Right;
            }
             return   false ;
        }

         public  Node < T >  GetParent(Node < T >  node)
        {
            Node < T >  current  =   base .Root, parent  =   null ;
             while  (current  !=   null )
            {
                 int  result  =  comparer.Compare(current.Value, node.Value);
                 if  (result  ==   0 )
                     return  parent;
                 else   if  (result  >   0 )
                {
                    parent  =  current;
                    current  =  current.Left;
                }
                 else   if  (result  <   0 )
                {
                    parent  =  current;
                    current  =  current.Right;
                }
            }
             return  parent;
        }

         public   void  Add(T data)
        {
            Node < T >  n  =   new  Node < T > (data);
             int  result;

            Node < T >  current  =   base .Root, parent  =   null ;
             while  (current  !=   null )
            {
                result  =  comparer.Compare(current.Value, data);
                 if  (result  ==   0 )
                     return ;
                 else   if  (result  >   0 )
                {
                    parent  =  current;
                    current  =  current.Left;
                }
                 else   if  (result  <   0 )
                {
                    parent  =  current;
                    current  =  current.Right;
                }
            }

             if  (parent  ==   null )
                 base .Root  =  n;
             else
            {
                result  =  comparer.Compare(parent.Value, data);
                 if  (result  >   0 )
                    parent.Left  =  n;
                 else
                    parent.Right  =  n;
            }
        }

         public   bool  Remove(T data)
        {
             if  ( base .Root  ==   null )
                 return   false ;   

            Node < T >  current  =   base .Root, parent  =   null ;
             int  result  =  comparer.Compare(current.Value, data);
             while  (result  !=   0 )
            {
                 if  (result  >   0 )
                {
                    parent  =  current;
                    current  =  current.Left;
                }
                 else   if  (result  <   0 )
                {
                    parent  =  current;
                    current  =  current.Right;
                }

                 if  (current  ==   null )
                     return   false ;
                 else
                    result  =  comparer.Compare(current.Value, data);
            }

             if  (current.Right  ==   null )
            {
                 if  (parent  ==   null )
                     base .Root  =  current.Left;
                 else
                {
                    result  =  comparer.Compare(parent.Value, current.Value);
                     if  (result  >   0 )
                        parent.Left  =  current.Left;
                     else   if  (result  <   0 )
                        parent.Right  =  current.Left;
                }
            }
            
             else   if  (current.Right.Left  ==   null )
            {
                current.Right.Left  =  current.Left;

                 if  (parent  ==   null )
                     base .Root  =  current.Right;
                 else
                {
                    result  =  comparer.Compare(parent.Value, current.Value);
                     if  (result  >   0 )
                        parent.Left  =  current.Right;
                     else   if  (result  <   0 )
                        parent.Right  =  current.Right;
                }
            }
             else
            {
                Node < T >  leftmost  =  current.Right.Left, lmParent  =  current.Right;
                 while  (leftmost.Left  !=   null )
                {
                    lmParent  =  leftmost;
                    leftmost  =  leftmost.Left;
                }

                lmParent.Left  =  leftmost.Right;

                leftmost.Left  =  current.Left;
                leftmost.Right  =  current.Right;

                 if  (parent  ==   null )
                     base .Root  =  leftmost;
                 else
                {
                    result  =  comparer.Compare(parent.Value, current.Value);
                     if  (result  >   0 )
                        parent.Left  =  leftmost;
                     else   if  (result  <   0 )
                        parent.Right  =  leftmost;
                }
            }
            
            current.Left  =  current.Right  =   null ;
            current  =   null ;

             return   true ;
        }
    }