public void InOrderTraversal(DSTreeNode <int> root, int value, DSTreeNode <int> left)
{
if (root == null)
{
return;
}
if (root.Data == value)
{
FindSuccessor(root, left);
return;
}
/// If Successor not already found
if (_inOrderSuccessorNode == -1)
{
if (root.Left != null)
{
InOrderTraversal(root.Left, value, root);
}
if (root.Right != null)
{
InOrderTraversal(root.Right, value, left);
}
}
}
private void Iterator(DSTreeNode <int> root, int level, List <DSLinkedList <int> > _node)
{
if (root == null)
{
return;
}
if (_node.Count == level)
{
var list = new DSLinkedList <int>();
list.Add(root.Data);
_node.Add(list);
}
else
{
_node[level].Add(root.Data);
}
if (root.Left != null)
{
Iterator(root.Left, level + 1, _node);
}
if (root.Right != null)
{
Iterator(root.Right, level + 1, _node);
}
}
public DSLinkedList <int>[] levelOrder(DSTreeNode <int> root)
{
List <DSLinkedList <int> > _node = new List <DSLinkedList <int> >();
Iterator(root, 0, _node);
return(_node.ToArray());
}
public void Contruct_Test_Positive()
{
DSNode <int> list = new DSNode <int>()
{
Data = 1,
Next = new DSNode <int>()
{
Data = 2,
Next = new DSNode <int>()
{
Data = 3,
Next = new DSNode <int>()
{
Data = 4,
Next = new DSNode <int>()
{
Data = 5,
Next = new DSNode <int>()
{
Data = 6,
Next = new DSNode <int>()
{
Data = 7,
Next = new DSNode <int>()
{
Data = 8,
Next = new DSNode <int>()
{
Data = 9
}
}
}
}
}
}
}
}
};
CompleteBTreeUsingLinkedList obj = new CompleteBTreeUsingLinkedList(list);
DSTreeNode <int> head = obj.Construct();
var traversal = obj.LevelOrderTraversal();
int i = 1;
foreach (var item in traversal)
{
Assert.AreEqual(item, i);
i++;
}
}
public void Iterator_Test()
{
DSTreeNode <int> dSTreeNode = new DSTreeNode <int>(1);
dSTreeNode.Left = new DSTreeNode <int>(2)
{
Right = new DSTreeNode <int>(5),
Left = new DSTreeNode <int>(4)
};
dSTreeNode.Right = new DSTreeNode <int>(3)
{
Right = new DSTreeNode <int>(7),
Left = new DSTreeNode <int>(6)
};
ListOfDepth obj = new ListOfDepth();
var actual = obj.levelOrder(dSTreeNode);
var expected = new DSLinkedList <int> [3];
expected[0] = new DSLinkedList <int>();
expected[0].Add(1);
expected[1] = new DSLinkedList <int>();
expected[1].Add(2);
expected[1].Add(3);
expected[2] = new DSLinkedList <int>();
expected[2].Add(4);
expected[2].Add(5);
expected[2].Add(6);
expected[2].Add(7);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.Length, expected.Length);
for (int i = 0; i < actual.Length; i++)
{
var actualData = actual[i]._head;
var expectedData = expected[i]._head;
Assert.AreEqual(actual[i].Count, expected[i].Count);
while (actualData != null)
{
Assert.AreEqual(actualData.Data, expectedData.Data);
actualData = actualData.Next;
expectedData = expectedData.Next;
}
}
}
public DSTreeNode <int> Construct()
{
if (_listHead == null)
{
return(null);
}
DSQueue <DSTreeNode <int> > queue = new DSQueue <DSTreeNode <int> >();
DSTreeNode <int> treeNode = new DSTreeNode <int>(_listHead.Data);
queue.Enqueue(treeNode);
var current = _listHead;
while (current != null)
{
DSTreeNode <int> de = null;
if (queue.Count > 0)
{
de = queue.Dequeue();
}
if (current.Next != null)
{
de.Left = new DSTreeNode <int>(current.Next.Data);
queue.Enqueue(de.Left);
current = current.Next;
if (current.Next != null)
{
de.Right = new DSTreeNode <int>(current.Next.Data);
queue.Enqueue(de.Right);
current = current.Next;
}
}
else
{
break;
}
}
return(treeNode);
}
private void FindSuccessor(DSTreeNode <int> root, DSTreeNode <int> left)
{
// Case 1: If right node is not null
if (root.Right != null)
{
var current = root.Right;
while (current.Left != null)
{
current = current.Left;
}
_inOrderSuccessorNode = current.Data;
}
else
{
if (left != null)
{
_inOrderSuccessorNode = left.Data;
}
}
}
public int[] LevelOrderTraversal()
{
DSTreeNode <int> _treeHead = Construct();
List <int> arr = new List <int>();
DSQueue <DSTreeNode <int> > queue = new DSQueue <DSTreeNode <int> >();
var tempNode = _treeHead;
while (tempNode != null)
{
arr.Add(tempNode.Data);
if (tempNode.Left != null)
{
queue.Enqueue(tempNode.Left);
}
if (tempNode.Right != null)
{
queue.Enqueue(tempNode.Right);
}
if (queue.Count > 0)
{
tempNode = queue.Dequeue();
}
else
{
tempNode = null;
}
}
return(arr.ToArray());
}
public InOrderSuccessorBST(DSTreeNode <int> tree)
{
Tree = tree;
}
