Задача с# помогите добить дерево и реализовать удаление

[ekzo]

Нужно реализовать удаление правого наследника, я пытылся, но чет как то не так

[ekzo]

код

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

namespace TreeApp
{
class Program
{
static void Main(string[] args)
{
var tree = new BinaryTree();
tree.Insert(8);
tree.Insert(4);
tree.Insert(10);
tree.Insert(1);
tree.Insert(11);
tree.Insert(6);
tree.Insert(5);
tree.Insert(3);
tree.Insert(2);
tree.Insert(7);
BinaryTreeExtensions.Print(tree);
Console.WriteLine("div2 = "+tree.CountElements().ToString ());
Console.WriteLine("Height = " + tree.HeightThree().ToString());
tree.Delete(tree, 10);
Console.WriteLine("Delete 10");
BinaryTreeExtensions.Print(tree);
tree.Delete();
Console.ReadKey(true);
}
}


public enum BinSide
{
Left,
Right
}

public class BinaryTree
{

public long? Data { get; private set; }
public BinaryTree Left { get; set; }
public BinaryTree Right { get; set; }
public BinaryTree Parent { get; set; }


public void Insert(long data)
{
if (Data == null || Data == data)
{
Data = data;
return;
}
if (Data > data)
{
if (Left == null) Left = new BinaryTree();
Insert(data, Left, this);
}
else
{
if (Right == null) Right = new BinaryTree();
Insert(data, Right, this);
}
}


private void Insert(long data, BinaryTree node, BinaryTree parent)
{

if (node.Data == null || node.Data == data)
{
node.Data = data;
node.Parent = parent;
return;
}
if (node.Data > data)
{
if (node.Left == null) node.Left = new BinaryTree();
Insert(data, node.Left, node);
}
else
{
if (node.Right == null) node.Right = new BinaryTree();
Insert(data, node.Right, node);
}
}
private void Insert(BinaryTree data, BinaryTree node, BinaryTree parent)
{

if (node.Data == null || node.Data == data.Data)
{
node.Data = data.Data;
node.Left = data.Left;
node.Right = data.Right;
node.Parent = parent;
return;
}
if (node.Data > data.Data)
{
if (node.Left == null) node.Left = new BinaryTree();
Insert(data, node.Left, node);
}
else
{
if (node.Right == null) node.Right = new BinaryTree();
Insert(data, node.Right, node);
}
}

private BinSide? MeForParent(BinaryTree node)
{
if (node.Parent == null) return null;
if (node.Parent.Left == node) return BinSide.Left;
if (node.Parent.Right == node) return BinSide.Right;
return null;
}

public BinaryTree Delete(BinaryTree root, long data)
{
if (root == null)
return null;
if (data < root.Data)
root.Left = Delete(root.Left, data);
else if (data > root.Data)
root.Right = Delete(root.Right, data);
else if(root.Left!=null && root.Right!=null)
{
root.Data = FindMin(root.Right);
root.Right = Delete(root.Right, root.Data.Value);

}else
{
if (root.Left != null)
root = root.Left;
else
root = root.Right;
}
return root;
}


private long FindMin(BinaryTree root)
{
if (root.Left != null)
return FindMin(root.Left);
else
return root.Data.Value;
}

public BinaryTree Find(long data)
{
if (Data == data) return this;
if (Data > data)
{
return Find(data, Left);
}
return Find(data, Right);
}
private BinaryTree Find(long data, BinaryTree node)
{
if (node == null) return null;

if (node.Data == data) return node;
if (node.Data > data)
{
return Find(data, node.Left);
}
return Find(data, node.Right);
}


public long CountElements()
{
return CountElements(this);
}
/// <summary>
/// Количество элементов в определённом узле
/// </summary>
/// <param name="node">Узел для подсчета</param>
/// <returns></returns>
private long CountElements(BinaryTree node)
{
long count = 0;
if (node.Data % 2 == 0)
count = 1;
if (node.Right != null)
{
count += CountElements(node.Right);
}
if (node.Left != null)
{
count += CountElements(node.Left);
}
return count;
}

public int HeightThree()
{
return HeightThree(this);
}

private int HeightThree(BinaryTree node)
{
int Height = 1;
int heightLeft = 0;
int heightRight = 0;
if (node.Right != null)
{
heightRight = HeightThree(node.Right);
}
if (node.Left != null)
{
heightLeft = HeightThree(node.Left);
}
return Height+Math.Max(heightLeft,heightRi ght);
}
/// <summary>
/// Удалить дерево
/// </summary>
public void Delete()
{
DeleteNode(this);


}
private void DeleteNode(BinaryTree node)
{
if (node == null)
return;
if(node.Right!=null)
{
DeleteNode(node.Right);
}
if(node.Left!=null)
{
DeleteNode(node.Left);
}
if (node.Left == null && node.Right == null)
node=null;
}
}

public class BinaryTreeExtensions
{

public static void Print(BinaryTree node)
{
if (node != null)
{
if (node.Parent == null)
{
Console.WriteLine("ROOT:{0}", node.Data);
}
else
{
if (node.Parent.Left == node)
{
Console.WriteLine("Left for {1} --> {0}", node.Data, node.Parent.Data);
}

if (node.Parent.Right == node)
{
Console.WriteLine("Right for {1} --> {0}", node.Data, node.Parent.Data);
}
}
if (node.Left != null)
{
Print(node.Left);
}
if (node.Right != null)
{
Print(node.Right);
}
}
}
}
}