[C#] Binärbaum

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BinaryTreeLib
{
 // class TreeNode definition
 class TreeNode 
 {
 private TreeNode leftNode; 
 private int data; 
 private TreeNode rightNode;
 private int[] arrayInOrder = new int[10];
 private int arrayCounter = 0;
 private bool statusArray = false;
 

 // initialize data and make this a leaf node
 public TreeNode( int nodeData )
 { 
 data = nodeData; 
 leftNode = rightNode = null; // node has no children
 }
 
 // LeftNode property
 public TreeNode LeftNode 
 {
 get 
 {
 return leftNode;
 }
 
 set
 {
 leftNode = value;
 }
 }
 
 // Data property
 public int Data
 {
 get 
 {
 return data;
 }

 set 
 {
 data = value;
 }
 }
 
 // RightNode property
 public TreeNode RightNode 
 {
 get 
 {
 return rightNode;
 }
 
 set
 {
 rightNode = value;
 }
 }
 

 // insert TreeNode into Tree that contains nodes;
 // ignore duplicate values
 public void Insert( int insertValue )
 {
 // insert in left subtree
 if ( insertValue < data ) 
 {
 // insert new TreeNode
 if ( leftNode == null )
 leftNode = new TreeNode( insertValue );

 // continue traversing left subtree
 else
 leftNode.Insert( insertValue );
 }

 // insert in right subtree
 else if ( insertValue > data ) 
 {
 // insert new TreeNode
 if ( rightNode == null )
 rightNode = new TreeNode( insertValue );

 // continue traversing right subtree
 else
 rightNode.Insert( insertValue );
 }

 } // end method Insert


 // delete TreeNode from Tree that contains nodes;
 public void Delete(int deleteValue, TreeNode root)
 {
 if (!statusArray)
 {
 InOrderArray(root); //Fills String strInOrder
 statusArray = true; //call InOrderArray only once.
 }
 
 if (arrayInOrder.Contains(deleteValue))
 {
 int index = 0;

 //get index...
 for (int i = 0; i < arrayInOrder.Length; i++)
 {
 if(arrayInOrder[i] == deleteValue)
 index = i;
 }

 Console.WriteLine("Value found! Deleting Process....");

 //Get References
 TreeNode delValue = FindNode(deleteValue, root);
 TreeNode nextInOrderElem = FindNode(arrayInOrder[index+1], root);

 delValue = nextInOrderElem; //Override Reference

 if (nextInOrderElem.HasAChild())
 nextInOrderElem = nextInOrderElem.LeftNode;
 }
 else
 Console.WriteLine("Value not found.");
 } // end method DeleteNode

 //Helper Methods 
 private bool IsLeaf()
 {
 if (this.LeftNode == null && this.RightNode == null)
 return true;
 else
 return false;
 }

 private bool HasAChild()
 {
 if ((this.LeftNode != null && this.RightNode == null) || (this.LeftNode == null && this.RightNode != null))
 return true;
 else
 return false;
 }

 private TreeNode FindNode(int value, TreeNode r)
 {
 if (r.Data < value) //Left
 {
 if (r.LeftNode != null && r.LeftNode.Data == value)
 return r.LeftNode;
 else if(r.LeftNode == null)
 return FindNode(value, r.RightNode);
 else
 return FindNode(value, r.LeftNode);
 }
 else if (r.Data > value) //right
 {
 if (r.RightNode != null && r.RightNode.Data == value)
 return r.RightNode;
 else if (r.RightNode == null)
 return FindNode(value, r.LeftNode);
 else
 return FindNode(value, r.RightNode);
 }

 return null;
 }
 
 private void InOrderArray( TreeNode node )
 {
 if ( node == null )
 return;

 // traverse left subtree
 InOrderArray(node.LeftNode);

 arrayInOrder[arrayCounter] = node.Data;
 arrayCounter++;

 // traverse right subtree
 InOrderArray(node.RightNode);
 }
 } // end class TreeNode

 // class Tree definition
 public class Tree 
 {
 private TreeNode root;

 // construct an empty Tree of integers
 public Tree() 
 { 
 root = null; 
 }

 // Insert a new node in the binary search tree.
 // If the root node is null, create the root node here.
 // Otherwise, call the insert method of class TreeNode.
 public void InsertNode( int insertValue )
 {
 lock ( this ) 
 { 
 if ( root == null )
 root = new TreeNode( insertValue );

 else
 root.Insert( insertValue );
 }
 }

 public void DeleteNode(int deleteValue)
 {
 lock (this)
 {
 if (root == null)
 Console.WriteLine("Baum leer - kann nicht gelöscht werden.\n");
 else
 root.Delete(deleteValue, root);
 }
 }

 // begin preorder traversal
 public void PreorderTraversal()
 { 
 lock ( this ) 
 {
 PreorderHelper( root ); 
 }
 }

 // recursive method to perform preorder traversal
 private void PreorderHelper( TreeNode node )
 {
 if ( node == null )
 return;

 // output node data
 Console.Write( node.Data + " " ); 

 // traverse left subtree
 PreorderHelper( node.LeftNode ); 

 // traverse right subtree
 PreorderHelper( node.RightNode ); 
 }

 // begin inorder traversal
 public void InorderTraversal()
 { 
 lock ( this ) 
 {
 InorderHelper( root ); 
 }
 }

 // recursive method to perform inorder traversal
 private void InorderHelper( TreeNode node )
 {
 if ( node == null )
 return;

 // traverse left subtree
 InorderHelper( node.LeftNode );

 // output node data
 Console.Write( node.Data + " " );

 // traverse right subtree
 InorderHelper( node.RightNode );
 }

 // begin postorder traversal
 public void PostorderTraversal()
 { 
 lock ( this ) 
 {
 PostorderHelper( root ); 
 }
 }

 // recursive method to perform postorder traversal
 private void PostorderHelper( TreeNode node )
 {
 if ( node == null )
 return;

 // traverse left subtree
 PostorderHelper( node.LeftNode );

 // traverse right subtree
 PostorderHelper( node.RightNode );

 // output node data
 Console.Write( node.Data + " " );
 }

 } // end class Tree
}

// Fig. 23.18: TreeTest.java
// This program tests class Tree.

using System;
using BinaryTreeLib;
//using BinaryTreeLibrary;

namespace TreeTest
{
 // class TreeTest definition
 public class TreeTest 
 {
 // test class Tree
 static void Main( string[] args )
 {
 Tree tree = new Tree();
 int insertValue;
 int deleteValue = 0;

 Console.WriteLine("Delete nothing:");
 tree.DeleteNode(1);

 Console.WriteLine( "Inserting values: " );
 Random random = new Random();

 // insert 10 random integers from 0-99 in tree 
 for ( int i = 1; i <= 10; i++ ) 
 {
 insertValue = random.Next( 100 );
 Console.Write( insertValue + " " );

 tree.InsertNode( insertValue );
 }
 // perform preorder traversal of tree
 Console.WriteLine( "\n\nPreorder traversal" );
 tree.PreorderTraversal();

 // perform inorder traversal of tree
 Console.WriteLine( "\n\nInorder traversal" );
 tree.InorderTraversal();

 // perform postorder traversal of tree
 Console.WriteLine( "\n\nPostorder traversal" );
 tree.PostorderTraversal();

 while (true)
 {
 Console.Write("\n\nEnter a Value to delete (Stop with -1): ");
 deleteValue = Convert.ToInt32(Console.ReadLine());

 if (deleteValue == -1)
 break;

 tree.DeleteNode(deleteValue);

 // perform preorder traversal of tree
 Console.WriteLine("\n\nPreorder traversal");
 tree.PreorderTraversal();

 // perform inorder traversal of tree
 Console.WriteLine("\n\nInorder traversal");
 tree.InorderTraversal();

 // perform postorder traversal of tree
 Console.WriteLine("\n\nPostorder traversal");
 tree.PostorderTraversal();
 Console.WriteLine();
 }

 Console.Read();
 }

 } // end class TreeTest
}