private Node MakeMirrorCopyTree(Node OriginalRoot, Node MirrorRoot)
{
if (OriginalRoot == null) return null;
else
{
MirrorRoot = new Node(OriginalRoot.data);
}
if (OriginalRoot.left != null)
{
MirrorRoot.right = MakeMirrorCopyTree(OriginalRoot.left, MirrorRoot.right);
}
if (OriginalRoot.right != null)
{
MirrorRoot.left = MakeMirrorCopyTree(OriginalRoot.right, MirrorRoot.left);
}
return MirrorRoot;
}
public void ZigZagTraversal(Node root)
{
bool printLeftToRight=true;
if (root == null)
return;
else
{
for (int i = 0; i < getHeight(); i++)
{
PrintThisLevel(i, root, 0, printLeftToRight);
printLeftToRight = !printLeftToRight;
}
}
}
private int HeightOfNode(Node root)
{
if (root == null)
{
return 0;
}
else if (root.right == null && root.left == null)
{
return 1;
}
else
{
return Max(HeightOfNode(root.left), HeightOfNode(root.right)) + 1;
}
}
public void PrintThisLevel(int levelToPrint, Node node, int currLevel,bool printLeftToRight)
{
if (levelToPrint == 0 && currLevel == 0)
{
Console.Write(node.data + " ");
return;
}
if (node == null)
return;
if (currLevel == levelToPrint - 1)
{
if (printLeftToRight)
{
if (node.left != null)
{
Console.Write(node.left.data + " ");
}
if (node.right != null)
{
Console.Write(node.right.data + " ");
}
return;
}
else
{
if (node.right != null)
{
Console.Write(node.right.data + " ");
}
if (node.left != null)
{
Console.Write(node.left.data + " ");
}
return;
}
}
else
{
if (printLeftToRight)
{
PrintThisLevel(levelToPrint, node.left, currLevel + 1, printLeftToRight);
PrintThisLevel(levelToPrint, node.right, currLevel + 1, printLeftToRight);
}
else
{
PrintThisLevel(levelToPrint, node.right, currLevel + 1, printLeftToRight);
PrintThisLevel(levelToPrint, node.left, currLevel + 1, printLeftToRight);
}
}
}
public void ReverseLevelOrderTraversal(Node root)
{
for (int i = getHeight(); i >=0; i--)
{
PrintThisLevel(i, root, 0, false);
Console.WriteLine();
}
}
public void AddNodeToBinarySearchTree(int num)
{
Node curr;
Node newnode = new Node(num);
if (root == null)
{
root = newnode;
}
else
{
curr = root;
while (curr != null)
{
if (num < curr.data)
{
if (curr.left != null)
curr = curr.left;
else
{
curr.left = newnode;
return;
}
}
else if (num >= curr.data)
{
if (curr.right != null)
{
curr = curr.right;
}
else
{
curr.right = newnode;
return;
}
}
}
}
}
public void PrintAllPaths(Node Root, Stack<Node> s)
{
}
public void LevelOrderRecursiveTraversal(Node node)
{
for (int i = 0; i <= getHeight(); i++)
{
PrintThisLevel(i, node, 0,true);
Console.WriteLine();
}
}
public void PostOrderPrintRecursive(Node node)
{
if (node == null)
return;
PostOrderPrintRecursive(node.left);
PostOrderPrintRecursive(node.right);
Console.Write(node.data + " ");
}
public void InsertToMakeCompleteBinaryTree(int num)
{
if (root == null)
{
root = new Node(num);
return;
}
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count > 0)
{
Node n = q.Dequeue();
if (n.left == null)
{
n.left = new Node(num);
return;
}
else if (n.right == null)
{
n.right = new Node(num);
return;
}
else
{
q.Enqueue(n.left);
q.Enqueue(n.right);
}
}
}
public void LevelOrderIterativeTraversal(Node node)
{
Queue<Tuple<Node, int>> qn = new Queue<Tuple<Node, int>>();
int level = 0;
int prevlevel = -1;
qn.Enqueue(new Tuple<Node, int>(node, level));
while (qn.Count > 0)
{
Tuple<Node, int> temp = qn.Dequeue();
Node curr = temp.Item1;
prevlevel = level;
level = temp.Item2;
if (curr.left != null)
{
qn.Enqueue(new Tuple<Node, int>(curr.left, level + 1));
}
if (curr.right != null)
{
qn.Enqueue(new Tuple<Node, int>(curr.right, level + 1));
}
if (level != prevlevel)
Console.WriteLine();
Console.Write(" " + curr.data);
}
}
public int getSize(Node root)
{
if (root == null)
return 0;
else
return getSize(root.left) + getSize(root.right) + 1;
}
public Node(int data, Node right=null, Node left=null)
{
this.data = data;
this.right = right;
this.left = left;
}
public Node CloneTree(Node OriginalRoot, Node ClonedRoot)
{
if (OriginalRoot == null)
{
ClonedRoot = null;
}
else
{
ClonedRoot = new Node(OriginalRoot.data);
}
if (OriginalRoot.left != null)
{
ClonedRoot.left = CloneTree(OriginalRoot.left, ClonedRoot.left);
}
if (OriginalRoot.right != null)
{
ClonedRoot.right = CloneTree(OriginalRoot.right, ClonedRoot.right);
}
return ClonedRoot;
}
private int SumOfThisLevel(int levelToSum, Node node, int currLevel)
{
if (node == null)
{
return 0;
}
else if (currLevel == levelToSum)
{
return node.data;
}
else
{
return SumOfThisLevel(levelToSum, node.right, currLevel + 1) + SumOfThisLevel(levelToSum, node.left, currLevel + 1);
}
}
public void PreOrderPrintRecursive(Node node, int level)
{
if (node != null)
{
for (int i = 0; i < level; i++)
Console.Write("|");
Console.Write(node.data);
}
else return;
PreOrderPrintRecursive(node.left, level + 1);
PreOrderPrintRecursive(node.right, level + 1);
}
public static bool IsEquivalentClone(Node OriginalRoot, Node CopyRoot)
{
if (OriginalRoot == null)
{
if (CopyRoot == null)
{ return true; }
else return false;
}
else if (CopyRoot == null)
{
if (OriginalRoot == null)
{ return true; }
else return false;
}
else if (OriginalRoot.data == CopyRoot.data)
{
bool ret = IsEquivalentClone(OriginalRoot.left, CopyRoot.left);
ret &= IsEquivalentClone(OriginalRoot.right, CopyRoot.right);
return ret;
}
else return false;
}
public static bool IsMirrorCopy(Node OriginalRoot, Node CopyRoot)
{
if (OriginalRoot == null && CopyRoot == null)
{
return true;
}
else if ((OriginalRoot == null && CopyRoot != null) || (OriginalRoot != null && CopyRoot == null))
{
return false;
}
else if (OriginalRoot.data == CopyRoot.data)
{
bool ret;
ret = IsMirrorCopy(OriginalRoot.left, CopyRoot.right);
ret &= IsMirrorCopy(OriginalRoot.right, CopyRoot.left);
return ret;
}
else return false;
}
