public void AddSearchNode(Node node)
{
if (HeadNode == null)
{
HeadNode = node;
}
else
{
HeadNode.AddBinarySearchNode(node);
}
}
public bool RemoveNode(Node node)
{
var removeChildParentTuple = FindNodeAndParent(node);
if (removeChildParentTuple.Item1 == null)
{
return false;
}
var currentNode = removeChildParentTuple.Item1;
var parentNode = removeChildParentTuple.Item2;
//Node we're removing has a null right
if (currentNode.RightNode == null)
{
if (parentNode == null)
{
HeadNode = currentNode.LeftNode;
}
else
{
var result = parentNode.CompareTo(currentNode);
if (result > 0)
{
parentNode.LeftNode = currentNode.LeftNode;
}
else if (result < 0)
{
parentNode.RightNode = currentNode.LeftNode;
}
}
}
else if (currentNode.RightNode.LeftNode == null)
{
currentNode.RightNode.LeftNode = currentNode.LeftNode;
if (parentNode == null)
{
HeadNode = currentNode.RightNode;
}
else
{
var result = parentNode.CompareTo(currentNode);
if (result > 0)
{
parentNode.LeftNode = currentNode.RightNode;
}
else if (result < 0)
{
parentNode.RightNode = currentNode.RightNode;
}
}
}
else
{
var leftMost = currentNode.RightNode.LeftNode;
var leftMostParent = currentNode.RightNode;
while (leftMost.LeftNode != null)
{
leftMostParent = leftMost;
leftMost = leftMost.LeftNode;
}
leftMostParent.LeftNode = leftMost.RightNode;
leftMost.LeftNode = currentNode.LeftNode;
leftMost.RightNode = currentNode.RightNode;
if (parentNode == null)
{
HeadNode = leftMost;
}
else
{
var result = parentNode.CompareTo(currentNode);
if (result > 0)
{
parentNode.LeftNode = leftMost;
}
else if (result < 0)
{
parentNode.RightNode = leftMost;
}
}
}
return true;
}
public Tuple<Node, Node> FindNodeAndParent(Node node)
{
var currentNode = HeadNode;
Node parent = null;
while (currentNode != null)
{
var result = currentNode.CompareTo(node);
if (result > 0)
{
parent = currentNode;
currentNode = currentNode.LeftNode;
}
else if (result < 0)
{
parent = currentNode;
currentNode = currentNode.RightNode;
}
else
{
break;
}
}
return new Tuple<Node, Node>(currentNode, parent);
}
public bool Contains(Node node)
{
var result = FindNodeAndParent(node);
return result.Item1 != null;
}
public void AddBalancedNode(Node node)
{
if (HeadNode == null)
{
HeadNode = node;
}
else
{
var queue = new Queue<Node>();
queue.Enqueue(HeadNode);
while (queue.Any())
{
var current = queue.Dequeue();
if (current.LeftNode == null)
{
current.LeftNode = node;
break;
}
else if (current.RightNode == null)
{
current.RightNode = node;
break;
}
else
{
queue.Enqueue(current.LeftNode);
queue.Enqueue(current.RightNode);
}
}
}
}
public void AddNodeEntrance(object param)
{
var newNode = new Node
{
Value = CurrentValue ?? 5,
IsExpanded = true,
IsSelected = true
};
if (SearchMethod)
{
AddSearchNode(newNode);
}
else
{
AddBalancedNode(newNode);
}
PropertyChanged(this, new PropertyChangedEventArgs("IsBinarySearchTree"));
}
private static bool CompareToEverythingOnRight(Node node, int value)
{
if (node == null)
{
return true;
}
if (node.Value < value)
{
return false;
}
var leftSide = CompareToEverythingOnRight(node.LeftNode, value);
var rightSide = CompareToEverythingOnRight(node.RightNode, value);
return leftSide && rightSide;
}
public void AddBinarySearchNode(Node node)
{
if (Value <= node.Value)
{
if (RightNode == null)
{
RightNode = node;
}
else
{
RightNode.AddBinarySearchNode(node);
}
}
else
{
if (LeftNode == null)
{
LeftNode = node;
}
else
{
LeftNode.AddBinarySearchNode(node);
}
}
}
