/*
* Given values of two nodes n1 and n2 in a Binary Tree,
* find the Lowest Common Ancestor (LCA)
*
* Time complexity: O(n)
*/
public static CtciTreeNode <int> FindFromBinaryTree(CtciTreeNode <int> parent, int value1, int value2)
{
if (parent.Value == value1 || parent.Value == value2)
{
return(parent);
}
CtciTreeNode <int> leftNode = null;
CtciTreeNode <int> rightNode = null;
if (parent.Left != null)
{
leftNode = FindFromBinaryTree(parent.Left, value1, value2);
}
if (parent.Right != null)
{
rightNode = FindFromBinaryTree(parent.Right, value1, value2);
}
if (leftNode != null && rightNode != null)
{
return(parent);
}
else if (leftNode != null || rightNode != null)
{
return((leftNode != null) ? leftNode : rightNode);
}
else
{
return(null);
}
}
protected List <LinkedList <T> > AllSequences(CtciTreeNode <T> node)
{
List <LinkedList <T> > result = new List <LinkedList <T> >();
if (node == null)
{
result.Add(new LinkedList <T>());
return(result);
}
LinkedList <T> prefix = new LinkedList <T>();
prefix.AddLast(node.Value);
List <LinkedList <T> > left = AllSequences(node.Left);
List <LinkedList <T> > right = AllSequences(node.Right);
foreach (LinkedList <T> leftList in left)
{
foreach (LinkedList <T> rightList in right)
{
List <LinkedList <T> > weaved = new List <LinkedList <T> >();
WeaveLists(leftList, rightList, weaved, prefix);
CopyListNodes(weaved, result);
}
}
return(result);
}
public void TestBinarySearchTree()
{
CtciTreeNode <int> node20 = CtciTreeNode <int> .CtciBinaryTreeNode(20);
CtciTreeNode <int> node8 = CtciTreeNode <int> .CtciBinaryTreeNode(8);
CtciTreeNode <int> node22 = CtciTreeNode <int> .CtciBinaryTreeNode(22);
CtciTreeNode <int> node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
CtciTreeNode <int> node12 = CtciTreeNode <int> .CtciBinaryTreeNode(12);
CtciTreeNode <int> node10 = CtciTreeNode <int> .CtciBinaryTreeNode(10);
CtciTreeNode <int> node14 = CtciTreeNode <int> .CtciBinaryTreeNode(14);
node20.Left = node8;
node20.Right = node22;
node8.Left = node4;
node8.Right = node12;
node12.Left = node10;
node12.Right = node14;
Assert.Equal(node12, Ancestor.FindFromBST(node20, 10, 14));
Assert.Equal(node8, Ancestor.FindFromBST(node20, 14, 8));
Assert.Equal(node20, Ancestor.FindFromBST(node20, 10, 22));
}
public void BuildSequence()
{
CtciTreeNode <int> node1 = CtciTreeNode <int> .CtciBinaryTreeNode(1);
CtciTreeNode <int> node2 = CtciTreeNode <int> .CtciBinaryTreeNode(2);
CtciTreeNode <int> node3 = CtciTreeNode <int> .CtciBinaryTreeNode(3);
CtciTreeNode <int> node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
CtciTreeNode <int> node5 = CtciTreeNode <int> .CtciBinaryTreeNode(5);
CtciTreeNode <int> node6 = CtciTreeNode <int> .CtciBinaryTreeNode(6);
node4.Left = node2;
node4.Right = node6;
List <LinkedList <int> > results1 = sequence.BuildSequence(node4);
Assert.Equal(2, results1.Count);
node2.Left = node1;
List <LinkedList <int> > results2 = sequence.BuildSequence(node4);
Assert.Equal(3, results2.Count);
node2.Right = node3;
List <LinkedList <int> > results3 = sequence.BuildSequence(node4);
Assert.Equal(8, results3.Count);
}
public void TestBinaryTree()
{
CtciTreeNode <int> node1 = CtciTreeNode <int> .CtciBinaryTreeNode(1);
CtciTreeNode <int> node2 = CtciTreeNode <int> .CtciBinaryTreeNode(2);
CtciTreeNode <int> node3 = CtciTreeNode <int> .CtciBinaryTreeNode(3);
CtciTreeNode <int> node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
CtciTreeNode <int> node5 = CtciTreeNode <int> .CtciBinaryTreeNode(5);
CtciTreeNode <int> node6 = CtciTreeNode <int> .CtciBinaryTreeNode(6);
CtciTreeNode <int> node7 = CtciTreeNode <int> .CtciBinaryTreeNode(7);
node1.Left = node2;
node1.Right = node3;
node2.Left = node4;
node2.Right = node5;
node3.Left = node6;
node3.Right = node7;
Assert.Equal(node2, Ancestor.FindFromBinaryTree(node1, 4, 5));
Assert.Equal(node1, Ancestor.FindFromBinaryTree(node1, 4, 6));
Assert.Equal(node1, Ancestor.FindFromBinaryTree(node1, 3, 4));
Assert.Equal(node2, Ancestor.FindFromBinaryTree(node1, 2, 4));
}
/*
* Given values of two nodes n1 and n2 in a Binary Search Tree,
* find the Lowest Common Ancestor (LCA)
*
* Time complexity: O(log(n))
*/
public static CtciTreeNode <int> FindFromBST(CtciTreeNode <int> parent, int value1, int value2)
{
if (value1 > value2)
{
int tmp = value2;
value2 = value1;
value1 = tmp;
}
if (parent.Value > value1 && parent.Value < value2)
{
return(parent);
}
if (parent.Value == value1 || parent.Value == value2)
{
return(parent);
}
if (parent.Value > value1 && parent.Value > value2)
{
return(FindFromBST(parent.Left, value1, value2));
}
else
{
return(FindFromBST(parent.Right, value1, value2));
}
}
public bool FindRoute2(CtciTreeNode <int> node1, CtciTreeNode <int> node2)
{
if (node1 == node2)
{
return(true);
}
Queue <CtciTreeNode <int> > queue = new Queue <CtciTreeNode <int> >();
queue.Enqueue(node1);
while (queue.Count > 0)
{
CtciTreeNode <int> node = queue.Dequeue();
foreach (CtciTreeNode <int> child in node.Children)
{
if (child == node2)
{
return(true);
}
queue.Enqueue(child);
}
}
return(false);
}
protected void AddToTree(CtciTreeNode <int> head, CtciTreeNode <int> newNode)
{
CtciTreeNode <int> parent = head;
CtciTreeNode <int> child = head;
while (child != null)
{
parent = child;
if (newNode.Value <= child.Value)
{
child = child.Left;
}
else
{
child = child.Right;
}
}
if (newNode.Value <= parent.Value)
{
parent.Left = newNode;
}
else
{
parent.Right = newNode;
}
}
public CtciTreeNode <int> CreateMinimalHeight2(int[] sortedArr)
{
int start = sortedArr.GetLowerBound(0);
int finish = sortedArr.GetUpperBound(0);
CtciTreeNode <int> head = CreateTreeRecursively(sortedArr, start, finish);
return(head);
}
protected CtciTreeNode <T> FindMostLeft(CtciTreeNode <T> node)
{
while (node.Left != null)
{
node = node.Left;
}
return(node);
}
public List <LinkedList <T> > BuildSequence(CtciTreeNode <T> head)
{
if (head == null)
{
throw new Exception("Incorrect Data");
}
return(AllSequences(head));
}
protected CtciTreeNode <T> FindInOrderParent(CtciTreeNode <T> node)
{
while (node == node.Parent.Right)
{
node = node.Parent;
}
return(node.Parent);
}
public CtciTreeNode <T> FindAncestor(CtciTreeNode <T> head, CtciTreeNode <T> nodeP, CtciTreeNode <T> nodeQ)
{
if (head == null || nodeP == null || nodeQ == null)
{
throw new Exception("Incorrect Data");
}
Q08_Result <T> result = FindRecursively(head, nodeP, nodeQ);
return(result.Node);
}
public CtciTreeNode <T> FindSuccessor(CtciTreeNode <T> node)
{
if (node.Right != null)
{
return(FindMostLeft(node.Right));
}
else
{
return(FindInOrderParent(node));
}
}
public void FindAncestor()
{
CtciTreeNode <int> node1 = CtciTreeNode <int> .CtciBinaryTreeNode(1);
CtciTreeNode <int> node2 = CtciTreeNode <int> .CtciBinaryTreeNode(2);
CtciTreeNode <int> node3 = CtciTreeNode <int> .CtciBinaryTreeNode(3);
CtciTreeNode <int> node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
CtciTreeNode <int> node5 = CtciTreeNode <int> .CtciBinaryTreeNode(5);
CtciTreeNode <int> node6 = CtciTreeNode <int> .CtciBinaryTreeNode(6);
CtciTreeNode <int> node7 = CtciTreeNode <int> .CtciBinaryTreeNode(7);
CtciTreeNode <int> node8 = CtciTreeNode <int> .CtciBinaryTreeNode(8);
CtciTreeNode <int> node9 = CtciTreeNode <int> .CtciBinaryTreeNode(9);
CtciTreeNode <int> node10 = CtciTreeNode <int> .CtciBinaryTreeNode(10);
CtciTreeNode <int> node11 = CtciTreeNode <int> .CtciBinaryTreeNode(11);
CtciTreeNode <int> node12 = CtciTreeNode <int> .CtciBinaryTreeNode(12);
node1.Left = node2;
node1.Right = node3;
node2.Left = node4;
node2.Right = node5;
node4.Left = node8;
node4.Right = node9;
node5.Left = node10;
node5.Right = node11;
node3.Left = node6;
node3.Right = node7;
node7.Left = node12;
Assert.Equal(node2, commonAncestor.FindAncestor(node1, node9, node10));
Assert.Equal(node3, commonAncestor.FindAncestor(node1, node6, node12));
Assert.Equal(node3, commonAncestor.FindAncestor(node1, node3, node12));
Assert.Equal(node1, commonAncestor.FindAncestor(node1, node8, node7));
}
public CtciTreeNode <int> CreateMinimalHeight(int[] sortedArr)
{
if (sortedArr.Length <= 0)
{
throw new Exception("Incorrect Data");
}
int value = sortedArr[sortedArr.GetUpperBound(0) / 2];
CtciTreeNode <int> head = CtciTreeNode <int> .CtciBinaryTreeNode(value);
int start = sortedArr.GetLowerBound(0);
int finish = (sortedArr.GetUpperBound(0) / 2) - 1;
Stack <Tuple <int, int> > stack = new Stack <Tuple <int, int> >();
stack.Push(new Tuple <int, int>(start, finish));
start = (sortedArr.GetUpperBound(0) / 2) + 1;
finish = sortedArr.GetUpperBound(0);
stack.Push(new Tuple <int, int>(start, finish));
while (stack.Count > 0)
{
Tuple <int, int> partition = stack.Pop();
if (partition.Item1 > partition.Item2)
{
continue;
}
value = sortedArr[(partition.Item1 + partition.Item2) / 2];
CtciTreeNode <int> node = CtciTreeNode <int> .CtciBinaryTreeNode(value);
AddToTree(head, node);
start = partition.Item1;
finish = ((partition.Item1 + partition.Item2) / 2) - 1;
stack.Push(new Tuple <int, int>(start, finish));
start = ((partition.Item1 + partition.Item2) / 2) + 1;
finish = partition.Item2;
stack.Push(new Tuple <int, int>(start, finish));
}
return(head);
}
public CtciTreeNode <int> CreateTreeRecursively(int[] sortedArr, int start, int finish)
{
if (start > finish)
{
return(null);
}
int mid = (start + finish) / 2;
int value = sortedArr[mid];
CtciTreeNode <int> node = CtciTreeNode <int> .CtciBinaryTreeNode(value);
node.Left = CreateTreeRecursively(sortedArr, start, mid - 1);
node.Right = CreateTreeRecursively(sortedArr, mid + 1, finish);
return(node);
}
public void FindRoute2()
{
CtciTreeNode <int> node1 = new CtciTreeNode <int>(1);
CtciTreeNode <int> node2 = new CtciTreeNode <int>(1);
CtciTreeNode <int> node3 = new CtciTreeNode <int>(1);
CtciTreeNode <int> node4 = new CtciTreeNode <int>(1);
CtciTreeNode <int> node5 = new CtciTreeNode <int>(1);
node1.Children.Add(node2);
node1.Children.Add(node4);
node2.Children.Add(node5);
node5.Children.Add(node3);
Assert.True(route.FindRoute2(node1, node3));
Assert.False(route.FindRoute2(node2, node1));
}
protected bool Validate(CtciTreeNode <int> current, int?min, int?max)
{
if ((min != null && current.Value <= min) || (max != null && current.Value > max))
{
return(false);
}
if (current.Left != null && Validate(current.Left, min, current.Value) == false)
{
return(false);
}
if (current.Right != null && Validate(current.Right, current.Value, max) == false)
{
return(false);
}
return(true);
}
protected Q08_Result <T> FindRecursively(CtciTreeNode <T> head, CtciTreeNode <T> nodeP, CtciTreeNode <T> nodeQ)
{
if (head == null)
{
return(new Q08_Result <T>(null, false));
}
if (head == nodeP && head == nodeQ)
{
return(new Q08_Result <T>(head, true));
}
Q08_Result <T> resultLeft = FindRecursively(head.Left, nodeP, nodeQ);
if (resultLeft.IsAncestor)
{
return(resultLeft);
}
Q08_Result <T> resultRight = FindRecursively(head.Right, nodeP, nodeQ);
if (resultRight.IsAncestor)
{
return(resultRight);
}
if (resultLeft.Node != null && resultRight.Node != null)
{
return(new Q08_Result <T>(head, true));
}
else if (head == nodeP || head == nodeQ)
{
bool isAncestor = resultLeft.Node != null || resultRight.Node != null;
return(new Q08_Result <T>(head, isAncestor));
}
else
{
return(new Q08_Result <T>(resultLeft.Node != null ? resultLeft.Node : resultRight.Node, false));
}
}
public void Validate()
{
CtciTreeNode <int> node1 = CtciTreeNode <int> .CtciBinaryTreeNode(1);
CtciTreeNode <int> node2 = CtciTreeNode <int> .CtciBinaryTreeNode(2);
CtciTreeNode <int> node3 = CtciTreeNode <int> .CtciBinaryTreeNode(3);
CtciTreeNode <int> node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
CtciTreeNode <int> node5 = CtciTreeNode <int> .CtciBinaryTreeNode(5);
CtciTreeNode <int> node6 = CtciTreeNode <int> .CtciBinaryTreeNode(6);
CtciTreeNode <int> node7 = CtciTreeNode <int> .CtciBinaryTreeNode(7);
CtciTreeNode <int> node8 = CtciTreeNode <int> .CtciBinaryTreeNode(8);
CtciTreeNode <int> node9 = CtciTreeNode <int> .CtciBinaryTreeNode(9);
node5.Left = node3;
node5.Right = node8;
node3.Left = node2;
node3.Right = node4;
node2.Left = node1;
node8.Left = node6;
node8.Right = node9;
node6.Right = node7;
Assert.True(validateBst.Validate(node5));
node6.Left = node7;
Assert.False(validateBst.Validate(node5));
}
public void FindSuccessor()
{
CtciTreeNode <int> node1 = new CtciTreeNode <int>(1);
node1.Children.Add(null);
node1.Children.Add(null);
CtciTreeNode <int> node2 = new CtciTreeNode <int>(2);
node2.Children.Add(null);
node2.Children.Add(null);
CtciTreeNode <int> node3 = new CtciTreeNode <int>(3);
node3.Children.Add(null);
node3.Children.Add(null);
CtciTreeNode <int> node4 = new CtciTreeNode <int>(4);
node4.Children.Add(null);
node4.Children.Add(null);
CtciTreeNode <int> node5 = new CtciTreeNode <int>(5);
node5.Children.Add(null);
node5.Children.Add(null);
CtciTreeNode <int> node6 = new CtciTreeNode <int>(6);
node6.Children.Add(null);
node6.Children.Add(null);
CtciTreeNode <int> node7 = new CtciTreeNode <int>(7);
node7.Children.Add(null);
node7.Children.Add(null);
CtciTreeNode <int> node8 = new CtciTreeNode <int>(8);
node8.Children.Add(null);
node8.Children.Add(null);
CtciTreeNode <int> node9 = new CtciTreeNode <int>(9);
node9.Children.Add(null);
node9.Children.Add(null);
node1.Left = node2;
node2.Parent = node1;
node1.Right = node3;
node3.Parent = node1;
node3.Left = node6;
node6.Parent = node3;
node3.Right = node7;
node7.Parent = node3;
node2.Left = node4;
node4.Parent = node2;
node2.Right = node5;
node5.Parent = node2;
node5.Left = node8;
node8.Parent = node5;
node5.Right = node9;
node9.Parent = node5;
Assert.Equal(successor.FindSuccessor(node9), node1);
Assert.Equal(successor.FindSuccessor(node8), node5);
Assert.Equal(successor.FindSuccessor(node5), node9);
Assert.Equal(successor.FindSuccessor(node2), node8);
Assert.NotEqual(successor.FindSuccessor(node2), node4);
}
public bool Validate(CtciTreeNode <int> head)
{
return(Validate(head, null, null));
}
public void CreateMinimalHeight2()
{
int[] sortedArr1 = new int[] { 1, 2, 3, 4, 5, 6, 7 };
int[] sortedArr2 = new int[] { 1, 2, 3, 4, 5 };
CtciTreeNode <int> node1 = CtciTreeNode <int> .CtciBinaryTreeNode(1);
CtciTreeNode <int> node2 = CtciTreeNode <int> .CtciBinaryTreeNode(2);
CtciTreeNode <int> node3 = CtciTreeNode <int> .CtciBinaryTreeNode(3);
CtciTreeNode <int> node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
CtciTreeNode <int> node5 = CtciTreeNode <int> .CtciBinaryTreeNode(5);
CtciTreeNode <int> node6 = CtciTreeNode <int> .CtciBinaryTreeNode(6);
CtciTreeNode <int> node7 = CtciTreeNode <int> .CtciBinaryTreeNode(7);
node4.Left = node2;
node4.Right = node6;
node2.Left = node1;
node2.Right = node3;
node6.Left = node5;
node6.Right = node7;
CtciTreeNode <int> result = minimal.CreateMinimalHeight2(sortedArr1);
Assert.True(node4.Value == result.Value);
Assert.True(node4.Left.Value == result.Left.Value);
Assert.True(node4.Left.Left.Value == result.Left.Left.Value);
Assert.True(node4.Left.Right.Value == result.Left.Right.Value);
Assert.True(node4.Right.Value == result.Right.Value);
Assert.True(node4.Right.Left.Value == result.Right.Left.Value);
Assert.True(node4.Right.Right.Value == result.Right.Right.Value);
node1 = CtciTreeNode <int> .CtciBinaryTreeNode(1);
node2 = CtciTreeNode <int> .CtciBinaryTreeNode(2);
node3 = CtciTreeNode <int> .CtciBinaryTreeNode(3);
node4 = CtciTreeNode <int> .CtciBinaryTreeNode(4);
node5 = CtciTreeNode <int> .CtciBinaryTreeNode(5);
result = minimal.CreateMinimalHeight2(sortedArr2);
node3.Left = node1;
node3.Right = node4;
node1.Right = node2;
node4.Right = node5;
Assert.True(node3.Value == result.Value);
Assert.True(node3.Left.Value == result.Left.Value);
Assert.True(node3.Right.Value == result.Right.Value);
Assert.True(node3.Left.Right.Value == result.Left.Right.Value);
Assert.True(node3.Right.Right.Value == result.Right.Right.Value);
}
public Q08_Result(CtciTreeNode <T> node, bool isAncestor)
{
this.node = node;
this.isAncestor = isAncestor;
}