public static TreeNode Search(TreeNode root, int value)
{
Queue <TreeNode> toSearch = new Queue <TreeNode>();
toSearch.Enqueue(root);
while (toSearch.Count > 0)
{
TreeNode current = toSearch.Dequeue();
if (current.Value == value)
{
return(current);
}
else
{
if (current.Left != null)
{
toSearch.Enqueue(current.Left);
}
if (current.Right != null)
{
toSearch.Enqueue(current.Right);
}
}
}
return(null);
}
public static DataStructures.Node <T> GetNodeAtBeginningOfLoop <T>(
DataStructures.LinkedList <T> linkedList)
{
if (linkedList.Head == null)
{
throw new ArgumentException("Cannot evaluate an empty list.");
}
DataStructures.Node <T> slowRunner = linkedList.Head;
DataStructures.Node <T> fastRunner = linkedList.Head;
while (true)
{
// Jump ahead one
slowRunner = slowRunner.Next;
if (fastRunner.Next != null)
{
// Jump ahead two
fastRunner = fastRunner.Next.Next;
}
else
{
throw new ArgumentException("List does not have a loop.");
}
if (slowRunner == fastRunner)
{
return(slowRunner);
}
}
}
//--------------------------------------------------------------------
private void _AssertCountingVisitor(DataStructures.Node Node, DataStructures.VisitationType VisitType, int ExpectedCount)
{
//Console.WriteLine( "Testing VisitNodes( " + VisitType.ToString() + " )." );
DataStructures.Node.CountingVisitor visitor = new DataStructures.Node.CountingVisitor();
Node.VisitNodes(visitor, VisitType);
Assert.AreEqual(ExpectedCount, visitor.Count, "Visitor count mismatch after VisitNodes( " + VisitType.ToString() + " ).");
}
public static TreeNode Search(TreeNode root, int value)
{
// Found..
if (root.Value == value)
{
return(root);
}
// Base case..
if (root.Left == null && root.Right == null)
{
return(null);
}
TreeNode next = null;
if (root.Left != null)
{
next = Search(root.Left, value);
}
if (next != null)
{
return(next);
}
if (root.Right != null)
{
next = Search(root.Right, value);
}
return(next);
}
public void Test_10_Navigation()
{
DataStructures.Node root = new DataStructures.Node();
NodeTestData.AddTestChildren(root);
NodeTestData.AssertTestChildren(root);
return;
}
public void Test_00_TextGraph()
{
DataStructures.Node root = new DataStructures.Node();
NodeTestData.AddTestChildren(root);
Console.WriteLine(root.TextGraph());
return;
}
//--------------------------------------------------------------------
public static void AddTestChildren(DataStructures.Node root)
{
// D3 = C2.Prev A1
// C3 = C2.Next +- B1
// A1 = C1.First | +- C1
// C7 = C1.Last | | +- D1
// A1 = C1.Root | | +- D2
// B1 = C1.Parent | | +- D3
// C1 = C2.PrevSib | +- C2
// C2 = C1.NextSib | +- C3
// C1 = C1.FirstSib +- B2
// C3 = C1.LastSib | +- C4
// B1 = A1.FirstChild | +- C5
// B3 = A1.LastChild | +- C6
// B1 = A1.FirstDesc +- B3
// C7 = A1.LastDesc +- C7
DataStructures.Node A1 = new DataStructures.Node("A1", "A1", null);
DataStructures.Node B1 = new DataStructures.Node("B1", "B1", null);
DataStructures.Node B2 = new DataStructures.Node("B2", "B2", null);
DataStructures.Node B3 = new DataStructures.Node("B3", "B3", null);
DataStructures.Node C1 = new DataStructures.Node("C1", "C1", null);
DataStructures.Node C2 = new DataStructures.Node("C2", "C2", null);
DataStructures.Node C3 = new DataStructures.Node("C3", "C3", null);
DataStructures.Node C4 = new DataStructures.Node("C4", "C4", null);
DataStructures.Node C5 = new DataStructures.Node("C5", "C5", null);
DataStructures.Node C6 = new DataStructures.Node("C6", "C6", null);
DataStructures.Node C7 = new DataStructures.Node("C7", "C7", null);
DataStructures.Node D1 = new DataStructures.Node("D1", "D1", null);
DataStructures.Node D2 = new DataStructures.Node("D2", "D2", null);
DataStructures.Node D3 = new DataStructures.Node("D3", "D3", null);
root.AddChild(A1, -1, false);
{
A1.AddChild(B1, -1, false);
{
B1.AddChild(C1, -1, false);
{
C1.AddChild(D1, -1, false);
C1.AddChild(D2, -1, false);
C1.AddChild(D3, -1, false);
}
B1.AddChild(C2, -1, false);
B1.AddChild(C3, -1, false);
}
A1.AddChild(B2, -1, false);
{
B2.AddChild(C4, -1, false);
B2.AddChild(C5, -1, false);
B2.AddChild(C6, -1, false);
}
A1.AddChild(B3, -1, false);
{
B3.AddChild(C7, -1, false);
}
}
return;
}
public void Test_20_Clone()
{
DataStructures.Node root = new DataStructures.Node();
NodeTestData.AddTestChildren(root);
DataStructures.Node.CloningVisitor visitor = new DataStructures.Node.CloningVisitor(root);
root.VisitNodes(visitor, DataStructures.VisitationType.DecendentsDepthFirst);
NodeTestData.AssertTestChildren(visitor.TargetRoot);
return;
}
public void Test_00_DebugOutput()
{
DataStructures.Node root = new DataStructures.Node( "", "", new DebugOutputNodeListener() );
root.Value = "root";
root.Notify(
new DataStructures.Node.NodeUpdateNotification(
DataStructures.Node.NodeNotification.NotificationStatus.Completed
, root ) );
NodeTestData.AddTestChildren( root );
return;
}
public static void RemoveNodeFromList(ref DataStructures.Node <T> node)
{
if (node.Next == null)
{
throw new ArgumentException("Cannot delete node using this method - next " +
"element is null");
}
T nextNodeValue = node.Next.Value;
node.Value = nextNodeValue;
node.Next = node.Next.Next;
}
//--------------------------------------------------------------------
public static void JumbleTestChildren(DataStructures.Node root)
{
DataStructures.Node child = null;
child = root.FindDescNode("C1");
child.ClearChildren(false);
child.AddChild(new DataStructures.Node("D1", "D1", null), -1, false);
child.AddChild(new DataStructures.Node("D2", "D2", null), -1, false);
child.AddChild(new DataStructures.Node("D3", "D3", null), -1, false);
child = root.FindDescNode("C5");
child.ClearChildren(false);
return;
}
public void Test_10_CountingVisitorOnRoot()
{
DataStructures.Node root = new DataStructures.Node();
NodeTestData.AddTestChildren(root);
this._AssertCountingVisitor(root, DataStructures.VisitationType.None, 0);
this._AssertCountingVisitor(root, DataStructures.VisitationType.Parents, 0);
this._AssertCountingVisitor(root, DataStructures.VisitationType.PreviousSiblings, 0);
this._AssertCountingVisitor(root, DataStructures.VisitationType.NextSiblings, 0);
this._AssertCountingVisitor(root, DataStructures.VisitationType.PreviousNodes, 0);
this._AssertCountingVisitor(root, DataStructures.VisitationType.NextNodes, 14);
this._AssertCountingVisitor(root, DataStructures.VisitationType.Children, 1);
// Not Implemented: this._AssertCountingVisitor( root, DataStructures.VisitationType.DecendentsBreadthFirst, 0 );
this._AssertCountingVisitor(root, DataStructures.VisitationType.DecendentsDepthFirst, 14);
return;
}
//--------------------------------------------------------------------
public static void AssertTestChildren(DataStructures.Node root)
{
Assert.AreEqual("D3", root.FindDescNode("C2").PrevNode.Value.ToString(), "D3 = C2.Prev");
Assert.AreEqual("C3", root.FindDescNode("C2").NextNode.Value.ToString(), "C3 = C2.Next");
Assert.AreEqual("A1", root.FindDescNode("C1").FirstNode.FirstChildNode.Value.ToString(), "A1 = C1.First.FirstChild"); // Special case.
Assert.AreEqual("C7", root.FindDescNode("C1").LastNode.Value.ToString(), "C7 = C1.Last");
Assert.AreEqual("A1", root.FindDescNode("C1").RootNode.FirstChildNode.Value.ToString(), "A1 = C1.Root.FirstChild"); // Special case.
Assert.AreEqual("B1", root.FindDescNode("C1").ParentNode.Value.ToString(), "B1 = C1.Parent");
Assert.AreEqual("C1", root.FindDescNode("C2").PrevSibNode.Value.ToString(), "C1 = C2.PrevSib");
Assert.AreEqual("C2", root.FindDescNode("C1").NextSibNode.Value.ToString(), "C2 = C1.NextSib");
Assert.AreEqual("C1", root.FindDescNode("C1").FirstSibNode.Value.ToString(), "C1 = C1.FirstSib");
Assert.AreEqual("C3", root.FindDescNode("C1").LastSibNode.Value.ToString(), "C3 = C1.LastSib");
Assert.AreEqual("B1", root.FindDescNode("A1").FirstChildNode.Value.ToString(), "B1 = A1.FirstChild");
Assert.AreEqual("B3", root.FindDescNode("A1").LastChildNode.Value.ToString(), "B3 = A1.LastChild");
Assert.AreEqual("B1", root.FindDescNode("A1").FirstDescNode.Value.ToString(), "B1 = A1.FirstDesc");
Assert.AreEqual("C7", root.FindDescNode("A1").LastDescNode.Value.ToString(), "C7 = A1.LastDesc");
return;
}
public static DataStructures.LinkedList <int> AddLinkedLists(
DataStructures.LinkedList <int> first,
DataStructures.LinkedList <int> second)
{
if (first.Head == null && second.Head == null)
{
return(null);
}
var summedLists = new DataStructures.LinkedList <int>();
var summedRunner = new DataStructures.Node <int>(0);
summedLists.Head = summedRunner;
DataStructures.Node <int> firstRunner = first.Head;
DataStructures.Node <int> secondRunner = second.Head;
bool carry = false;
while (firstRunner != null || secondRunner != null)
{
var newNode = new DataStructures.Node <int>(0);
int sum = 0;
if (carry)
{
sum++;
}
if (firstRunner == null)
{
sum += secondRunner.Value;
}
else if (secondRunner == null)
{
sum += firstRunner.Value;
}
else
{
sum += firstRunner.Value + secondRunner.Value;
}
carry = false;
if (sum >= 10)
{
sum -= 10;
carry = true;
}
summedRunner.Value = sum;
summedRunner.Next = newNode;
summedRunner = summedRunner.Next;
firstRunner = firstRunner == null ? null : firstRunner.Next ?? null;
secondRunner = secondRunner == null ? null : secondRunner.Next ?? null;
}
return(summedLists);
}
