BinaryTree | C# Online Compiler

BinaryTree by dennisgearmesh

using System;
using System.Collections;
using System.Collections.Generic;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine("Hello World");
		
		SortedSet<int> intSet = new SortedSet<int>();
		intSet.Add(4);
		intSet.Add(2);
		intSet.Add(1);
		intSet.Add(3);
		
		foreach(int i in intSet)
		{
			Console.WriteLine(i);	
		}
		
		Console.WriteLine(intSet.Max);
		Console.WriteLine(intSet.Min);
	}
	
	public class TreeNode<T> : IComparable<T>
		where T : IComparable<T>
	{
		public T Value = default(T);
		public TreeNode<T> Left = null;
		public TreeNode<T> Right = null;
		
		public TreeNode(T val, TreeNode<T> left, TreeNode<T> right)
		{
			Value = val;
			Left = left;
			Right = right;
		}
			
		public int CompareTo(T other)
		{
			return Value.CompareTo(other);
		}
	}
	
	public enum TreeTraversalDirection
	{
		InOrder = 0,
		PreOrder = 1,
		PostOrder = 2
	}
	
	public interface ITree<T>
	{
		TreeTraversalDirection TraversalDirection {get;set;}
		int Count {get;}
		void Add(T val);
		void Add(ICollection<T> vals);
		bool Contains(T val);
		bool Remove(T val);
		IEnumerator GetEnumerator();
	}
	
	public class Tree<T> : ITree<T>
		where T : IComparable<T>
	{
		private TreeNode<T> Root {get;set;}
		public TreeTraversalDirection TraversalDirection {get;set;}
		public int Count {get; private set;}
			
		public Tree()
		{
			Root = null;	
		}
			
		public Tree(T val)
		{
			Add(val);
		}
		
		public Tree(ICollection<T> vals)
		{
			foreach(T val in vals)
			{
				Add(val);
			}
		}
		
		public void Add(T val)
		{
			if(Root == null)
			{
				Root = new TreeNode<T>(val, null, null);	
			}
			else
			{
				AddTo(Root, val);
			}
			
			Count++;
		}
			
		public void Add(ICollection<T> vals)
		{
			foreach(T val in vals)
			{
				Add(val);	
			}
		}
		
		//Recursive
		private void AddTo(TreeNode<T> node, T val)
		{
			int comparison = node.Value.CompareTo(val);
			
			if(comparison < 0)
			{
				if(node.Left == null)
				{
					node.Left = new TreeNode<T>(val, null, null);
				}
				else
				{
					AddTo(node.Left, val);	
				}
			}
			else
			{
				if(node.Right == null)
				{
					node.Right = new TreeNode<T>(val, null, null);
				}
				else
				{
					AddTo(node.Right, val);	
				}		
			}
		}
			
		public bool Remove(T val)
		{
			TreeNode<T> parent = null;
			TreeNode<T> node = FindWithParent(val, out parent);
			
			if(node == null)
			{
				return false;
			}
			
			Count--;
			
			
			int comparison = parent.Value.CompareTo(node.Value);
			
			if(node.Right == null)
			{
				//left child of node becomes node (even if left child is null)
				
				if(parent == null) //then we must be on the root
				{
					Root = node.Left;	
				}
				else
				{
					node = node.Left;
					if(comparison <= 0)
					{
						parent.Right = node;	
					}
					else
					{
						parent.Left = node;	
					}
				}
			}
			else if (node.Right.Left == null)
			{
				//right child of node becomes node
				if(parent == null) //we must be on the root
				{
					Root = node.Right;	
				}
				else
				{
					node = node.Right;
					if(comparison <= 0)
					{
						parent.Right = node;	
					}
					else
					{
						parent.Left = node;
					}
							
				}
			}
			else
			{
				//left-most child of the node's right child beomes node
				TreeNode<T> leftMostNode = node.Right.Left;
				TreeNode<T> leftMostNodeParent = node.Right;
				
				while(leftMostNode.Left != null)
				{
					leftMostNodeParent = leftMostNode;
					leftMostNode = leftMostNode.Left;
				}
				
				//the left most node's parent's left becomes the left most node's right subtree
				leftMostNodeParent.Left = leftMostNode.Right;
				
				//assign left most node's left and right to node's left and right
				leftMostNode.Left = node.Left;
				leftMostNode.Right = node.Right;
				
				if (parent == null)
				{
					Root = leftMostNode;	
				}
				else
				{
					if(comparison <= 0)
					{
						parent.Right = leftMostNode;
					}
					else
					{
						parent.Left = leftMostNode;
					}
				}
			}
			
			
			return true;
		}
			
		public bool Contains(T val)
		{
			TreeNode<T> parent = null;
			return FindWithParent(val, out parent) != null;
		}
		
		private TreeNode<T> FindWithParent(T val, out TreeNode<T> parent)
		{
			parent = null;
			TreeNode<T> current = Root;
			
			while(current != null)
			{
				int comparison = current.Value.CompareTo(val);
				
				if(comparison == 0)
				{
					break;	
				}
				else if(comparison > 0)
				{
					parent = current;
					current = current.Left;
				}
				else
				{
					parent = current;
					current = current.Right;
				}
			}
			
			return current;
		}
			
		public IEnumerator GetEnumerator()
		{
			switch(TraversalDirection)
			{
				case TreeTraversalDirection.InOrder:
				
					break;
				case TreeTraversalDirection.PreOrder:
				
					break;
				
				case TreeTraversalDirection.PostOrder:
				
					break;
			}
		}
			
		public void PreOrderTraversal(Action<T> action)
		{
			PreOrderTraversal(action, Root);		
		}
			
		public void PreOrderTraversal(Action<T> action, TreeNode<T> node)
		{
			if(node != null)
			{
				action(node.Value);
				PreOrderTraversal(action, node.Left);
				PreOrderTraversal(action, node.Right);
			}
		}
			
		public void PostOrderTraversal(Action<T> action)
		{
			PostOrderTraversal(action, Root);		
		}
			
		public void PostOrderTraversal(Action<T> action, TreeNode<T> node)
		{
			if(node != null)
			{
				PostOrderTraversal(action, node.Left);
				PostOrderTraversal(action, node.Right);
				action(node.Value);
			}
		}
			
			
		public void InOrderTraversal(Action<T> action)
		{
			InOrderTraversal(action, Root);		
		}
			
		public void InOrderTraversal(Action<T> action, TreeNode<T> node)
		{
			if(node != null)
			{
				InOrderTraversal(action, node.Left);
				action(node.Value);
				InOrderTraversal(action, node.Right);
			}
		}
	}
}

 
using System;
using System.Collections;
using System.Collections.Generic;
                    
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
        
        SortedSet<int> intSet = new SortedSet<int>();
        intSet.Add(4);
        intSet.Add(2);
        intSet.Add(1);
        intSet.Add(3);
        
        foreach(int i in intSet)
        {
            Console.WriteLine(i);   
        }
        
        Console.WriteLine(intSet.Max);
        Console.WriteLine(intSet.Min);
    }
    
    public class TreeNode<T> : IComparable<T>
        where T : IComparable<T>
    {
        public T Value = default(T);
        public TreeNode<T> Left = null;
        public TreeNode<T> Right = null;
        
        public TreeNode(T val, TreeNode<T> left, TreeNode<T> right)
        {
            Value = val;
            Left = left;
            Right = right;
        }
            
        public int CompareTo(T other)
        {
            return Value.CompareTo(other);
        }
    }
    
    public enum TreeTraversalDirection
    {
        InOrder = 0,
        PreOrder = 1,
        PostOrder = 2
    }
    
    public interface ITree<T>
    {
        TreeTraversalDirection TraversalDirection {get;set;}
        int Count {get;}
        void Add(T val);
        void Add(ICollection<T> vals);
        bool Contains(T val);
        bool Remove(T val);
        IEnumerator GetEnumerator();
    }
    
    public class Tree<T> : ITree<T>
        where T : IComparable<T>
    {
        private TreeNode<T> Root {get;set;}
        public TreeTraversalDirection TraversalDirection {get;set;}
        public int Count {get; private set;}
            
        public Tree()
        {
            Root = null;    
        }
            
        public Tree(T val)
        {
            Add(val);
        }
        
        public Tree(ICollection<T> vals)
        {
            foreach(T val in vals)
            {
                Add(val);
            }
        }
        
        public void Add(T val)
        {
            if(Root == null)
            {
                Root = new TreeNode<T>(val, null, null);    
            }
            else
            {
                AddTo(Root, val);
            }
            
            Count++;
        }
            
        public void Add(ICollection<T> vals)
        {
            foreach(T val in vals)
            {
                Add(val);   
            }
        }
        
        //Recursive
        private void AddTo(TreeNode<T> node, T val)
        {
            int comparison = node.Value.CompareTo(val);
            
            if(comparison < 0)
            {
                if(node.Left == null)
                {
                    node.Left = new TreeNode<T>(val, null, null);
                }
                else
                {
                    AddTo(node.Left, val);  
                }
            }
            else
            {
                if(node.Right == null)
                {
                    node.Right = new TreeNode<T>(val, null, null);
                }
                else
                {
                    AddTo(node.Right, val); 
                }       
            }
        }
            
        public bool Remove(T val)
        {
            TreeNode<T> parent = null;
            TreeNode<T> node = FindWithParent(val, out parent);
            
            if(node == null)
            {
                return false;
            }
            
            Count--;
            
            
            int comparison = parent.Value.CompareTo(node.Value);
            
            if(node.Right == null)
            {
                //left child of node becomes node (even if left child is null)
                
                if(parent == null) //then we must be on the root
                {
                    Root = node.Left;   
                }
                else
                {
                    node = node.Left;
                    if(comparison <= 0)
                    {
                        parent.Right = node;    
                    }
                    else
                    {
                        parent.Left = node; 
                    }
                }
            }
            else if (node.Right.Left == null)
            {
                //right child of node becomes node
                if(parent == null) //we must be on the root
                {
                    Root = node.Right;  
                }
                else
                {
                    node = node.Right;
                    if(comparison <= 0)
                    {
                        parent.Right = node;    
                    }
                    else
                    {
                        parent.Left = node;
                    }
                            
                }
            }
            else
            {
                //left-most child of the node's right child beomes node
                TreeNode<T> leftMostNode = node.Right.Left;
                TreeNode<T> leftMostNodeParent = node.Right;
                
                while(leftMostNode.Left != null)
                {
                    leftMostNodeParent = leftMostNode;
                    leftMostNode = leftMostNode.Left;
                }
                
                //the left most node's parent's left becomes the left most node's right subtree
                leftMostNodeParent.Left = leftMostNode.Right;
                
                //assign left most node's left and right to node's left and right
                leftMostNode.Left = node.Left;
                leftMostNode.Right = node.Right;
                
                if (parent == null)
                {
                    Root = leftMostNode;    
                }
                else
                {
                    if(comparison <= 0)
                    {
                        parent.Right = leftMostNode;
                    }
                    else
                    {
                        parent.Left = leftMostNode;
                    }
                }
            }
            
            
            return true;
        }
            
        public bool Contains(T val)
        {
            TreeNode<T> parent = null;
            return FindWithParent(val, out parent) != null;
        }
        
        private TreeNode<T> FindWithParent(T val, out TreeNode<T> parent)
        {
            parent = null;
            TreeNode<T> current = Root;
            
            while(current != null)
            {
                int comparison = current.Value.CompareTo(val);
                
                if(comparison == 0)
                {
                    break;  
                }
                else if(comparison > 0)
                {
                    parent = current;
                    current = current.Left;
                }
                else
                {
                    parent = current;
                    current = current.Right;
                }
            }
            
            return current;
        }
            
        public IEnumerator GetEnumerator()
        {
            switch(TraversalDirection)
            {
                case TreeTraversalDirection.InOrder:
                
                    break;
                case TreeTraversalDirection.PreOrder:
                
                    break;
                
                case TreeTraversalDirection.PostOrder:
                
                    break;
            }
        }
            
        public void PreOrderTraversal(Action<T> action)
        {
            PreOrderTraversal(action, Root);        
        }
            
        public void PreOrderTraversal(Action<T> action, TreeNode<T> node)
        {
            if(node != null)
            {
                action(node.Value);
                PreOrderTraversal(action, node.Left);
                PreOrderTraversal(action, node.Right);
            }
        }
            
        public void PostOrderTraversal(Action<T> action)
        {
            PostOrderTraversal(action, Root);       
        }
            
        public void PostOrderTraversal(Action<T> action, TreeNode<T> node)
        {
            if(node != null)
            {
                PostOrderTraversal(action, node.Left);
                PostOrderTraversal(action, node.Right);
                action(node.Value);
            }
        }
            
            
        public void InOrderTraversal(Action<T> action)
        {
            InOrderTraversal(action, Root);     
        }
            
        public void InOrderTraversal(Action<T> action, TreeNode<T> node)
        {
            if(node != null)
            {
                InOrderTraversal(action, node.Left);
                action(node.Value);
                InOrderTraversal(action, node.Right);
            }
        }
    }
}

View IL Code