public static List <LinkedList <TreeBinaryNode <T> > > getListOfDepths <T>(TreeBinaryNode <T> node)
{
List <LinkedList <TreeBinaryNode <T> > > list = new List <LinkedList <TreeBinaryNode <T> > >();
LinkedList <TreeBinaryNode <T> > parent = new LinkedList <TreeBinaryNode <T> >();
LinkedList <TreeBinaryNode <T> > children = new LinkedList <TreeBinaryNode <T> >();
if (node != null)
{
children.AddLast(node);
do
{
list.Add(children);
parent = children;
children = new LinkedList <TreeBinaryNode <T> >();
foreach (var el in parent)
{
if (el.left != null)
{
children.AddLast(el.left);
}
if (el.right != null)
{
children.AddLast(el.right);
}
}
} while (children.Count > 0);
}
return(list);
}
private static int checkDepth(TreeBinaryNode <T> node)
{
if (node == null)
{
return(-1);
}
int leftDepth = checkDepth(node.left);
if (leftDepth == Int32.MinValue)
{
return(Int32.MinValue);
}
int rightDepth = checkDepth(node.right);
if (rightDepth == Int32.MinValue)
{
return(Int32.MinValue);
}
if (Math.Abs(leftDepth - rightDepth) > 1)
{
return(Int32.MinValue);
}
else
{
return(Math.Max(leftDepth, rightDepth) + 1);
}
}
public static List <LinkedList <TreeBinaryNode <T> > > getListOfDepths <T>(TreeBinaryNode <T> tree)
{
List <LinkedList <TreeBinaryNode <T> > > lists = new List <LinkedList <TreeBinaryNode <T> > >();
getDepths(tree, lists, 0);
return(lists);
}
private static List <LinkedList <TreeBinaryNode <T> > > getDepths <T>(TreeBinaryNode <T> node, List <LinkedList <TreeBinaryNode <T> > > lists, int level)
{
if (node == null)
{
return(null);
}
LinkedList <TreeBinaryNode <T> > linkedList;
if (lists.Count.Equals(level))
{
linkedList = new LinkedList <TreeBinaryNode <T> >();
lists.Add(linkedList);
}
else
{
linkedList = lists[level];
}
linkedList.AddLast(node);
getDepths(node.left, lists, level + 1);
getDepths(node.right, lists, level + 1);
return(lists);
}
public NodePrint(TreeBinaryNode <T> left, TreeBinaryNode <T> right)
{
bool leftisNull = left == null ? true : false;
bool rightIsNull = right == null ? true : false;
this.left = left;
this.right = right;
if (!leftisNull && !rightIsNull)
{
this.pairDesc = $"[{left.value},{right.value}] ";
}
else if (!leftisNull)
{
this.pairDesc = $"[{left.value},-] ";
}
else if (!rightIsNull)
{
this.pairDesc = $"[-,{right.value}] ";
}
else
{
this.pairDesc = nullNode;
}
}
public static List <List <T> > allSequences(TreeBinaryNode <T> node)
{
List <List <T> > result = new List <List <T> >();
if (node == null)
{
result.Add(new List <T>());
return(result);
}
List <T> prefix = new List <T>();
prefix.Add(node.value);
List <List <T> > leftSeq = allSequences(node.left);
List <List <T> > rightSeq = allSequences(node.right);
foreach (var left in leftSeq)
{
foreach (var right in rightSeq)
{
List <List <T> > mergedList = new List <List <T> >();
mergeLists(left, right, prefix, mergedList);
result.AddRange(mergedList);
}
}
return(result);
}
public static bool IsBST(TreeBinaryNode <int> tree)
{
Traversal <int> t = new Traversal <int>(TypeTraversal.inOrder, tree);
List <int> inOrderList = t.getTraversalList();
return(inOrderList.Zip(inOrderList.Skip(1)).All(l => l.First < l.Second));
}
private void postOrderTraversal(TreeBinaryNode <T> node)
{
if (node != null)
{
postOrderTraversal(node.left);
postOrderTraversal(node.right);
this.listOrder.Add(node.value);
}
}
public static TreeBinaryNode <T> commonAncestorWithoutLinkParent(TreeBinaryNode <T> root, TreeBinaryNode <T> firstNode, TreeBinaryNode <T> secondNode)
{
if (!cover(root, firstNode) || !cover(root, secondNode))
{
return(null);
}
return(commonAncestor(root, firstNode, secondNode));
}
/// <summary>
/// Calculate the depth of a Binary Tree.
///</summary>
/// <param name="node"> TreeBinaryNode. The root of the Binary Tree.</param>
/// <returns>The length of the Binary Tree.</returns>
public static int getDepth <T>(TreeBinaryNode <T> node)
{
if (node == null)
{
return(-1);
}
return(Max(getDepth(node.left), getDepth(node.right)) + 1);
}
private static bool cover(TreeBinaryNode <T> root, TreeBinaryNode <T> node)
{
if (root == null)
{
return(false);
}
if (root == node)
{
return(true);
}
return(cover(root.left, node) || cover(root.right, node));
}
public static bool isBST(TreeBinaryNode <int> tree)
{
Traversal <int> t = new Traversal <int>(TypeTraversal.inOrder, tree);
List <int> inOrderList = t.getTraversalList();
for (int i = 0; i < inOrderList.Count - 1; i++)
{
if (inOrderList[i + 1] <= inOrderList[i])
{
return(false);
}
}
return(true);
}
public Traversal(TypeTraversal type, TreeBinaryNode <T> t)
{
switch ((int)type)
{
case 0:
preOrderTraversal(t);
break;
case 1:
inOrderTraversal(t);
break;
case 2:
postOrderTraversal(t);
break;
}
}
public static bool isBalanced(TreeBinaryNode <T> tree)
{
if (tree == null)
{
return(true);
}
int diff = getDepth(tree.left) - getDepth(tree.right);
if (Math.Abs(diff) > 1)
{
return(false);
}
else
{
return(isBalanced(tree.left) && isBalanced(tree.right));
}
}
private static TreeBinaryNode <T> commonAncestor(TreeBinaryNode <T> root, TreeBinaryNode <T> firstNode, TreeBinaryNode <T> secondNode)
{
if (root == firstNode || root == secondNode)
{
return(root);
}
bool firstNodeIsOnLeft = cover(root.left, firstNode);
bool secondNodeIsOnLeft = cover(root.left, secondNode);
if (firstNodeIsOnLeft != secondNodeIsOnLeft)
{
return(root);
}
TreeBinaryNode <T> succNode = firstNodeIsOnLeft ? root.left: root.right;
return(commonAncestorWithoutLinkParent(succNode, firstNode, secondNode));
}
private static void addElements <T>(TreeBinaryNode <T> node, ref Queue <NodePrint <T> > queue)
{
if (node != null)
{
if (node.left != null && node.right != null)
{
queue.Enqueue(new NodePrint <T>(node.left, node.right));
}
else if (node.right != null)
{
queue.Enqueue(new NodePrint <T>(null, node.right));
}
else if (node.left != null)
{
queue.Enqueue(new NodePrint <T>(node.left, null));
}
else
{
queue.Enqueue(new NodePrint <T>(null, null));
}
}
}
public static void printDescending <T>(this TreeBinaryNode <T> tree)
{
Utilities.PrintBinaryTree.pretty(tree);
}
public static void pretty <T>(TreeBinaryNode <T> node)
{
if (node == null)
{
return;
}
Queue <NodePrint <T> > oldQ = new Queue <NodePrint <T> >();
Queue <NodePrint <T> > newQ = new Queue <NodePrint <T> >();
oldQ.Enqueue(new NodePrint <T>(node));
NodePrint <T> root = oldQ.Dequeue();
WriteLine(root.pairDesc);
WriteLine();
if (root.left != null || root.right != null)
{
oldQ.Enqueue(new NodePrint <T>(root.left, root.right));
}
while (oldQ.Count > 0)
{
int ind = oldQ.Count;
for (int i = 0; i < ind; i++)
{
NodePrint <T> n = oldQ.Dequeue();
Write(n.pairDesc);
TreeBinaryNode <T> a = n.left;
TreeBinaryNode <T> b = n.right;
addElements(a, ref newQ);
addElements(b, ref newQ);
}
WriteLine();
WriteLine();
ind = newQ.Count;
bool atLeastOne = false;
for (int i = 0; i < ind; i++)
{
NodePrint <T> n = newQ.Dequeue();
if (n.pairDesc != nullNode)
{
atLeastOne = true;
}
oldQ.Enqueue(n);
}
if (!atLeastOne)
{
return;
}
}
}
public NodePrint(TreeBinaryNode <T> root)
{
this.left = root.left;
this.right = root.right;
this.pairDesc = $" --- {root.value} ---";
}
public static bool isBalanced(TreeBinaryNode <T> tree)
{
return(checkDepth(tree) != Int32.MinValue);
}