// Method recursively calls itself down the tree until it find an open spot
public void Insert(Student student)
{
// If students name is greater or equal to the parent then insert to right node
if (string.Compare(student.Name, this.Student.Name) >= 0)
{ // if right child is null create new node
if (RightChild == null)
{
RightChild = new Node(student);
}
else
{ // if right child not null recursively call insert on right child
RightChild.Insert(student);
}
}
else
{ // if the students name is less than the parent then insert to left node
if (LeftChild == null)
{ // if the left child is null create a new node
LeftChild = new Node(student);
}
else
{ // If the left child is not null then recursively call insert on left child
LeftChild.Insert(student);
}
}
}
/// <summary>
/// Evaluate as boolean
/// </summary>
internal override bool BoolEvaluate(ConditionEvaluator.IConditionEvaluationState state)
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(LeftChild.CanBoolEvaluate(state),
state.ElementLocation,
"ExpressionDoesNotEvaluateToBoolean",
LeftChild.GetUnexpandedValue(state),
LeftChild.GetExpandedValue(state),
state.Condition);
if (LeftChild.BoolEvaluate(state))
{
// Short circuit
return(true);
}
else
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(RightChild.CanBoolEvaluate(state),
state.ElementLocation,
"ExpressionDoesNotEvaluateToBoolean",
RightChild.GetUnexpandedValue(state),
RightChild.GetExpandedValue(state),
state.Condition);
return(RightChild.BoolEvaluate(state));
}
}
internal override QueryResults <TOutput> Open(QuerySettings settings, bool preferStriping)
{
QueryResults <TLeftInput> leftResults = LeftChild.Open(settings, false);
QueryResults <TRightInput> rightResults = RightChild.Open(settings, false);
return(new BinaryQueryOperatorResults(leftResults, rightResults, this, settings, false));
}
public void Insert(T value)
{
if (value.CompareTo(Value) < 0)
{
if (LeftChild != null)
{
LeftChild.Insert(value);
}
else
{
LeftChild = new BinarySearchTreeNode <T>(value);
LeftChild.Parent = this;
}
}
if (value.CompareTo(Value) >= 0)
{
if (RightChild != null)
{
RightChild.Insert(value);
}
else
{
RightChild = new BinarySearchTreeNode <T>(value);
RightChild.Parent = this;
}
}
}
public int GetHeight()
{
int leftHeight = LeftChild == null ? 0 : LeftChild.GetHeight();
int rightHeight = RightChild == null ? 0 : RightChild.GetHeight();
return((leftHeight > rightHeight ? leftHeight : rightHeight) + 1);
}
/// <summary>
/// Evaluate as boolean
/// </summary>
internal override bool BoolEvaluate(ConditionEvaluator.IConditionEvaluationState state)
{
if (!LeftChild.TryBoolEvaluate(state, out bool leftBool))
{
ProjectErrorUtilities.ThrowInvalidProject(
state.ElementLocation,
"ExpressionDoesNotEvaluateToBoolean",
LeftChild.GetUnexpandedValue(state),
LeftChild.GetExpandedValue(state),
state.Condition);
}
if (!leftBool)
{
// Short circuit
return(false);
}
else
{
if (!RightChild.TryBoolEvaluate(state, out bool rightBool))
{
ProjectErrorUtilities.ThrowInvalidProject(
state.ElementLocation,
"ExpressionDoesNotEvaluateToBoolean",
RightChild.GetUnexpandedValue(state),
RightChild.GetExpandedValue(state),
state.Condition);
}
return(rightBool);
}
}
public Rectangle?GetRandomRoom(MT19337 rng)
{
if (WalkableSpace != null)
{
return(WalkableSpace);
}
var leftRoom = LeftChild.GetRandomRoom(rng);
var rightRoom = RightChild.GetRandomRoom(rng);
if (leftRoom == null)
{
if (rightRoom == null)
{
return(null);
}
return(rightRoom);
}
if (rightRoom == null)
{
return(leftRoom);
}
// got both
return((rng.Between(0, 1) == 0) ? leftRoom : rightRoom);
}
public void CreateRooms()
{
// this function generates all the rooms and hallways for this cell and all of its children.
if (LeftChild != null || RightChild != null)
{
// this cell has been split, so go into the children cells
if (LeftChild != null)
{
LeftChild.CreateRooms();
}
if (RightChild != null)
{
RightChild.CreateRooms();
}
// Check if there's rooms on both sides, and connect those specific rooms
var room1 = LeftChild.GetRoom();
var room2 = RightChild.GetRoom();
if (room1 != null && room2 != null && this.halls.Count == 0)
{
this.ConnectRooms(room1.Value, room2.Value);
}
}
else
{
// this cell needs a room
Point roomSize;
Point roomPos;
// the room can be between 3 x 3 up to the size of the cell - 2.
roomSize = new Point(rand.Next(3, Width - 2), rand.Next(3, Height - 2));
roomPos = new Point(rand.Next(1, Width - roomSize.X - 1), rand.Next(1, Height - roomSize.Y - 1));
Room = new Rectangle(X + roomPos.X, Y + roomPos.Y, roomSize.X, roomSize.Y);
}
}
/// <summary>
/// Evaluate as boolean
/// </summary>
internal override bool BoolEvaluate(ConditionEvaluationState state)
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(LeftChild.CanBoolEvaluate(state),
state.conditionAttribute,
"ExpressionDoesNotEvaluateToBoolean",
LeftChild.GetUnexpandedValue(state),
LeftChild.GetExpandedValue(state),
state.parsedCondition);
if (!LeftChild.BoolEvaluate(state))
{
// Short circuit
return(false);
}
else
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(RightChild.CanBoolEvaluate(state),
state.conditionAttribute,
"ExpressionDoesNotEvaluateToBoolean",
RightChild.GetUnexpandedValue(state),
RightChild.GetExpandedValue(state),
state.parsedCondition);
return(RightChild.BoolEvaluate(state));
}
}
public TreeNode GetNodes()
{
var node = new TreeNode("Node value: " + Value +
" Balnce factor: " + BalanceFactor);
if (RightChild != null)
{
node.Nodes.Add(RightChild.GetNodes());
}
else
{
node.Nodes.Add("*empty*");
}
if (LeftChild != null)
{
node.Nodes.Add(LeftChild.GetNodes());
}
else
{
node.Nodes.Add("*empty*");
}
return(node);
}
/// <summary>
/// Prints addition's expression
/// </summary>
public override void Print()
{
Console.Write("( + ");
LeftChild.Print();
RightChild.Print();
Console.Write(") ");
}
public void AddNode(T nodeValue)
{
if (nodeValue.CompareTo(this._Value) > 0)
{
if (RightChild != null)
{
RightChild.AddNode(nodeValue);
}
else
{
RightChild = new BinaryTree <T>(nodeValue);
}
}
else
{
if (LeftChild != null)
{
LeftChild.AddNode(nodeValue);
}
else
{
LeftChild = new BinaryTree <T>(nodeValue);
}
}
}
/// <summary>
/// för in en ny nod i trädet
/// </summary>
/// <param name="value">trädets potentiella nya värde</param>
public void Insert(T value)
{
if (value.CompareTo(this.Value) > 0) //jämför infört värde med värdet i aktuella noden som genomsöks
{
if (RightChild == null) //om nodens högra barn är tomt
{
RightChild = new BinarySearchTreeNode <T>(value); //skapar ny instans av typen BinarySearchTreeNode.
RightChild.Parent = this; //gör aktuell nod till förälder till den nyskapade noden
}
else
{
RightChild.Insert(value); //om != null, anropa funktionen rekursivt
}
}
else if (value.CompareTo(this.Value) < 0) //jämför infört värde med värdet i aktuella noden som genomsöks
{
if (LeftChild == null) //om nodens vänstra barn är tomt
{
LeftChild = new BinarySearchTreeNode <T>(value); //skapar ny instans av typen BinarySearchTreeNode.
LeftChild.Parent = this; //gör aktuell nod till förälder till den nyskapade noden
}
else
{
LeftChild.Insert(value); //om != null, anropa funktionen rekursivt
}
}
}
private void UpdateConditionedProperties(ConditionEvaluator.IConditionEvaluationState state)
{
if (!_conditionedPropertiesUpdated && state.ConditionedPropertiesInProject != null)
{
string leftUnexpandedValue = LeftChild.GetUnexpandedValue(state);
string rightUnexpandedValue = RightChild.GetUnexpandedValue(state);
if (leftUnexpandedValue != null)
{
ConditionEvaluator.UpdateConditionedPropertiesTable
(state.ConditionedPropertiesInProject,
leftUnexpandedValue,
RightChild.GetExpandedValue(state));
}
if (rightUnexpandedValue != null)
{
ConditionEvaluator.UpdateConditionedPropertiesTable
(state.ConditionedPropertiesInProject,
rightUnexpandedValue,
LeftChild.GetExpandedValue(state));
}
_conditionedPropertiesUpdated = true;
}
}
private BiTree <T> FindFirstUnbalancedNode()
{
if (!isBalancedNode)
{
return(this);
}
else
{
BiTree <T> toReturn = null;
if (LeftChild != null)
{
toReturn = LeftChild.FindFirstUnbalancedNode();
}
if (toReturn != null)
{
return(toReturn);
}
if (RightChild != null)
{
toReturn = RightChild.FindFirstUnbalancedNode();
}
if (toReturn != null)
{
return(toReturn);
}
return(null);
}
}
public ShapeNode RBuildTree(Diagram parent)
{
ShapeNode node = new ShapeNode(parent)
{
Bounds = new Rect(new Point(), MainWindow.NodeSize),
Text = Key.ToString(),
Tag = this
};
parent.Nodes.Add(node);
if (LeftChild != null)
{
var childNode = LeftChild.RBuildTree(parent);
childNode.AttachTo(node, AttachToNode.TopLeft);
var link = new DiagramLink(parent, node, childNode);
parent.Links.Add(link);
}
if (RightChild != null)
{
var childNode = RightChild.RBuildTree(parent);
childNode.AttachTo(node, AttachToNode.TopRight);
var link = new DiagramLink(parent, node, childNode);
parent.Links.Add(link);
}
return(node);
}
// Add a node to this node's subtree.
public void AddNode(TreeNode node, ref TreeNode linkFromParent)
{
// See which subtree should hold it.
if (node.Value < this.Value)
{
if (LeftChild == null)
{
LeftChild = node;
node.Height = 1;
}
else
{
LeftChild.AddNode(node, ref LeftChild);
}
}
else
{
if (RightChild == null)
{
RightChild = node;
node.Height = 1;
}
else
{
RightChild.AddNode(node, ref RightChild);
}
}
// Update the node's height (in case subtree heights have changed).
UpdateHeight();
// When we return to this point, we may need to rebalance our subtree.
RebalanceSubtree(this, ref linkFromParent);
}
public bool Find(T value)
{
//Om rotnoden är det värde som söks
if (Equals(this.Value, value))
{
return(true);
}
if (value.CompareTo(Value) < 0)
{
//Om värdet som söks är lägre än nuvarande nod och dess vänsterbarn ej finns så finns värdet som söks inte
if (Equals(LeftChild, null))
{
return(false);
}
//Om noden har ett vänsterbarn så fortsätter rekursionen
return(LeftChild.Find(value));
}
else
{
//Om noden har 2 barn. Då ersätts den borttagna noden med det minsta värdet i höger subträd
if (Equals(RightChild, null))
{
return(false);
}
//Om noden har ett vänsterbarn så fortsätter rekursionen
return(RightChild.Find(value));
}
}
public void GenerateRooms(MT19337 rng)
{
// this function generates all the rooms and hallways for this BSPMapNode and all of its children.
if (LeftChild == null && RightChild == null)
{
if (WalkableSpace != null)
{
return;
}
// the room can be between 3 x 3 tiles to the size of the leaf - 2.
var roomWidth = rng.Between(BSPTreeEngine.MIN_ROOM_WIDTH, Width - 2);
var roomHeight = rng.Between(BSPTreeEngine.MIN_ROOM_HEIGHT, Height - 2);
// place the room within the BSPMapNode, but don't put it right
// against the side of the BSPMapNode (that would merge rooms together)
var roomStartX = rng.Between(1, Width - roomWidth - 1);
var roomStartY = rng.Between(1, Height - roomHeight - 1);
WalkableSpace = new Rectangle(X + roomStartX, Y + roomStartY, roomWidth, roomHeight);
return;
}
// subleafs:
LeftChild?.GenerateRooms(rng);
RightChild?.GenerateRooms(rng);
// both leafs exist. we know their GetRandomRoom shouldn't return null, because we just called GenerateRooms.
if (LeftChild != null && RightChild != null)
{
MakeHallway(rng, (Rectangle)LeftChild.GetRandomRoom(rng), (Rectangle)RightChild.GetRandomRoom(rng));
}
}
public void Insert(T value)
{
if (Find(value))
{
//Om det angivna värdet redan finns i trädet visas ett felmeddelande istället
throw new NotImplementedException("Det här värdet finns redan i trädet!");
}
//Undersöker om värdet är högre eller lägre än rotnoden
if (value.CompareTo(Value) > 0)
{
if (this.RightChild == null)
{
this.RightChild = new BinarySearchTreeNode <T>(value);
this.RightChild.Parent = this;
}
else
{
RightChild.Insert(value);
}
}
else
{
if (this.LeftChild == null)
{
this.LeftChild = new BinarySearchTreeNode <T>(value);
this.LeftChild.Parent = this;
}
else
{
LeftChild.Insert(value);
}
}
}
public bool Find(T value)
{
if (value.Equals(Value))
{
return(true);
}
else
{
if (value.CompareTo(Value) < 0)
{
if (LeftChild != null)
{
return(LeftChild.Find(value));
}
}
if (value.CompareTo(Value) >= 0)
{
if (RightChild != null)
{
return(RightChild.Find(value));
}
}
}
return(false);
}
internal void BubbleDownData(Func <T, T, bool> compare)
{
if (LeftChild == null && RightChild == null)
{
return;
}
if (LeftChild != null && !compare(Data, LeftChild.Data))
{
// Swap
// TODO into a method
T temp = LeftChild.Data;
LeftChild.Data = Data;
Data = temp;
LeftChild.BubbleDownData(compare);
}
else if (RightChild != null && !compare(Data, RightChild.Data))
{
// Swap
T temp = RightChild.Data;
RightChild.Data = Data;
Data = temp;
RightChild.BubbleDownData(compare);
}
}
public virtual TreeNode InsertTreeNode(TreeNode newNode)
{
if (newNode.Value >= Value)
{
if (RightChild == null)
{
RightChild = newNode;
newNode.Parent = this;
}
else
{
RightChild.InsertTreeNode(newNode);
}
}
else
{
if (LeftChild == null)
{
LeftChild = newNode;
newNode.Parent = this;
}
else
{
LeftChild.InsertTreeNode(newNode);
}
}
return(newNode);
}
public void ReplaceWithSingleNode(BeachLineElement newNode)
{
if (Parent != null)
{
newNode.SetParent(Parent);
if (Parent.LeftChild == this)
{
Parent.SetLeftChild(newNode);
}
else
{
Parent.SetRightChild(newNode);
}
}
else
{
// This is the root node
mBeachLine.SetRoot(newNode);
}
if (LeftChild != null)
{
newNode.SetLeftChild(LeftChild);
LeftChild.SetParent(newNode);
}
if (RightChild != null)
{
newNode.SetRightChild(RightChild);
RightChild.SetParent(newNode);
}
mParent = null;
mLeftChild = null;
mRightChild = null;
}
private void PrintRightChild(TravelType travelOrder)
{
if (RightChild != null)
{
RightChild.PrintTreeNode(travelOrder);
}
}
public void DrawTree(Vector3 offset, int iteration)
{
Color color = this is BeachLineArc ? Color.green : Color.cyan;
// Draw square
float square_size = 0.5f;
Debug.DrawRay(new Vector3(-square_size, -square_size, 0) + offset, 2 * Vector3.right * square_size, color);
Debug.DrawRay(new Vector3(-square_size, square_size, 0) + offset, 2 * Vector3.right * square_size, color);
Debug.DrawRay(new Vector3(-square_size, square_size, 0) + offset, 2 * Vector3.down * square_size, color);
Debug.DrawRay(new Vector3(square_size, square_size, 0) + offset, 2 * Vector3.down * square_size, color);
float child_x_offset = 4f / Mathf.Pow(2, iteration);
Vector3 left_child_offset = new Vector3(offset.x + child_x_offset, offset.y - 1.5f, 0);
Vector3 right_child_offset = new Vector3(offset.x - child_x_offset, offset.y - 1.5f, 0);
if (LeftChild != null)
{
Debug.DrawLine(
offset + (new Vector3(0, -square_size, 0)),
left_child_offset + (new Vector3(0, square_size, 0)),
Color.white);
LeftChild.DrawTree(left_child_offset, iteration + 1);
}
if (RightChild != null)
{
Debug.DrawLine(
offset + (new Vector3(0, -square_size, 0)),
right_child_offset + (new Vector3(0, square_size, 0)),
Color.white);
RightChild.DrawTree(right_child_offset, iteration + 1);
}
}
public override BinaryTree <T> Add(T value)
{
if (value.CompareTo(Value) == -1)
{
if (LeftChild.GetType() == typeof(Branch <T>))
{
LeftChild.Add(value);
}
else
{
Branch <T> tempBranch = new Branch <T>(value);
LeftChild = tempBranch;
}
}
else if (value.CompareTo(Value) == 1)
{
if (RightChild.GetType() == typeof(Branch <T>))
{
RightChild.Add(value);
}
else
{
Branch <T> tempBranch = new Branch <T>(value);
RightChild = tempBranch;
}
}
return(this);
}
private int GetDepth()
{
if (IsEmpty)
{
return(0);
}
if (LeftChild == null)
{
if (RightChild == null)
{
return(1);
}
else
{
return(RightChild.GetDepth() + 1);
}
}
else
{
if (RightChild == null)
{
return(LeftChild.GetDepth() + 1);
}
else
{
return(Math.Max(LeftChild.GetDepth(), RightChild.GetDepth()) + 1);
}
}
}
/// <summary>
/// Evaluate as boolean
/// </summary>
internal override bool BoolEvaluate(ConditionEvaluator.IConditionEvaluationState state)
{
bool isLeftNum = LeftChild.TryNumericEvaluate(state, out double leftNum);
bool isLeftVersion = LeftChild.TryVersionEvaluate(state, out Version leftVersion);
bool isRightNum = RightChild.TryNumericEvaluate(state, out double rightNum);
bool isRightVersion = RightChild.TryVersionEvaluate(state, out Version rightVersion);
if ((!isLeftNum && !isLeftVersion) || (!isRightNum && !isRightVersion))
{
ProjectErrorUtilities.ThrowInvalidProject(
state.ElementLocation,
"ComparisonOnNonNumericExpression",
state.Condition,
/* helpfully display unexpanded token and expanded result in error message */
isLeftNum ? RightChild.GetUnexpandedValue(state) : LeftChild.GetUnexpandedValue(state),
isLeftNum ? RightChild.GetExpandedValue(state) : LeftChild.GetExpandedValue(state));
}
return((isLeftNum, isLeftVersion, isRightNum, isRightVersion) switch
{
(true, _, true, _) => Compare(leftNum, rightNum),
(_, true, _, true) => Compare(leftVersion, rightVersion),
(true, _, _, true) => Compare(leftNum, rightVersion),
(_, true, true, _) => Compare(leftVersion, rightNum),
_ => false
});
public void Insert(int inputData)
{
//Right input>= root value
if (inputData >= Data)
{
if (RightChild == null) //this is termination condition to add node cause its a leaf node
{
RightChild = new TreeNode(inputData);
}
else
{
RightChild.Insert(inputData); //Recursive call the insert
}
}
//Left
if (inputData <= Data)
{
if (LeftChild == null) //this is termination condition to add node cause its a leaf node
{
LeftChild = new TreeNode(inputData);
}
else
{
LeftChild.Insert(inputData);//Recursive call the insert
}
}
}
