public static void Main()
{
System.Console.WriteLine("Running tree app");
BinaryTree tree = new Tree.BinaryTree();
tree.insert(tree.r, 2);
tree.insert(tree.r, 3);
tree.insert(tree.r, 1);
tree.insert(tree.r, 4);
tree.insert(tree.r, 5);
tree.postOrder(tree.r);
// should print pre order
tree.traverseIteratively(tree.r);
}
public static void TreeExample()
{
Node node7 = new Node(null, null, 70);
Node node6 = new Node(null, null, 60);
Node node5 = new Node(null, null, 50);
Node node4 = new Node(null, null, 40);
Node node3 = new Node(node6, node7, 30);
Node node2 = new Node(node4, node5, 20);
Node node1 = new Node(node2, node3, 10);
BinaryTree BT1 = new BinaryTree(node1);
BT1.nodes = new List <Node>();
BinaryTree BT2 = new BinaryTree(node1);
BT2.nodes = new List <Node>();
BinaryTree BT3 = new BinaryTree(node1);
BT3.nodes = new List <Node>();
List <Node> preOrder = BT1.PreOrder(node1);
List <Node> inOrder = BT2.InOrder(node1);
List <Node> postOrder = BT3.PostOrder(node1);
Console.WriteLine("PreOrder search results");
foreach (Node item in preOrder)
{
Console.WriteLine($"{item.Value}");
}
BT1.nodes.Clear();
Console.WriteLine("===========================");
Console.WriteLine("InOrder search results");
foreach (Node item in inOrder)
{
Console.WriteLine($"{item.Value}");
}
BT2.nodes.Clear();
Console.WriteLine("===========================");
Console.WriteLine("PostOrder search results");
foreach (Node item in postOrder)
{
Console.WriteLine($"{item.Value}");
}
BT3.nodes.Clear();
Console.WriteLine("===========================");
Node nodeSeven = new Node(null, null, 70);
Node nodeSix = new Node(null, null, 50);
Node nodeFive = new Node(null, null, 30);
Node nodeFour = new Node(null, null, 10);
Node nodeThree = new Node(nodeSix, nodeSeven, 60);
Node nodeTwo = new Node(nodeFour, nodeFive, 20);
Node nodeOne = new Node(nodeTwo, nodeThree, 40);
BinarySearchTree BTS = new BinarySearchTree(nodeOne);
BinaryTree BT = new BinaryTree(nodeOne);
BT.nodes = new List <Node>();
List <Node> search = BT.InOrder(nodeOne);
Console.WriteLine("BinarySearchTree results");
foreach (Node item in search)
{
Console.WriteLine($"{item.Value}");
}
BT.nodes.Clear();
Console.WriteLine("===========================");
Console.WriteLine("Binary Search: searching for 50");
Console.WriteLine($"Search result: {BTS.Search(50, nodeOne).Value}");
Console.WriteLine("===========================");
Console.WriteLine("Adding to Binary Search Tree");
Node nodeEight = new Node(null, null, 25);
Console.WriteLine($"Node to add: {nodeEight.Value}");
BTS.Add(nodeOne, nodeEight);
List <Node> add = BT.InOrder(nodeOne);
foreach (Node item in add)
{
Console.WriteLine($"{item.Value}");
}
}
public static void Test()
{
BinaryTree <int> tree = new BinaryTree <int>();
// tree.Add(1, 5, 7, 2, 3, 8);
tree.RecursiveAdd(4, 2, 6, 1, 3, 5, 7);
BinaryTree <string> tree2 = new BinaryTree <string>();
tree2.RecursiveAdd("d", "b", "f", "a", "c", "e", "g");
BinaryTree <int> tree3 = new BinaryTree <int>();
Random rnd = new Random();
int[] varios = new int[1000];
for (int i = 0; i < 1000; i++)
{
int a = rnd.Next(0, 1000000);
varios[i] = a;
}
// tree3.Add(7, 1, 9, 0, 3, 8, 10, 2, 5, 4, 6);
tree3.Add(varios);
Console.WriteLine(string.Join(", ", tree.RecursiveInOrder()));
Console.WriteLine(string.Join(", ", tree2.RecursiveInOrder()));
Console.WriteLine();
System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
s.Start();
string xxa = string.Join(", ", tree3.RecursiveInOrder());
s.Stop();
Console.WriteLine("RecursiveInOrder:".MetricJoin(s.Elapsed.ToString(), 19));
Thread.Sleep(100);
s.Restart();
string xa = string.Join(", ", tree3.RecursiveInOrder());
s.Stop();
Console.WriteLine("RecursiveInOrder:".MetricJoin(s.Elapsed.ToString(), 19));
Thread.Sleep(100);
s.Restart();
tree3.PrintInOrder2();
string xbaa = string.Join(", ", tree3.z);
s.Stop();
Console.WriteLine("Print in order 2:".MetricJoin(s.Elapsed.ToString(), 19));
tree3.z.Clear();
// BinaryTree<int> tre = new BinaryTree<int>();
//tre.RecursiveAdd(5, 1, 4, 9, 2, 3, 8, 6, 7);
Thread.Sleep(100);
s.Restart();
tree3.PrintInOrder2();
string ax = string.Join(", ", tree3.z);
s.Stop();
Console.WriteLine("Print in order 2:".MetricJoin(s.Elapsed.ToString(), 19));
tree3.x.Clear();
GC.Collect();
Thread.Sleep(100);
s.Restart();
tree3.PrintInOrder1();
string pt3 = string.Join(", ", tree3.x);
s.Stop();
Console.WriteLine("Print in order 1:".MetricJoin(s.Elapsed.ToString(), 19));
Thread.Sleep(100);
s.Restart();
//tree3.PreOrder();
string pt4 = string.Join(", ", tree3.PreOrder());
s.Stop();
Console.WriteLine("Pre order:".MetricJoin(s.Elapsed.ToString(), 19));
// Console.WriteLine(pt4);
BinaryTree <string> STR = new BinaryTree <string>();
STR.RecursiveAdd("F", "B", "A", "D", "C", "E", "G", "I", "H");
// Console.WriteLine(string.Join(", ", STR.PreOrder()));
}
public bool AreIdentical(BinaryTree <T> other)
{
return(AreIdenticalInternalRecursiveUtil(this.Root, other.Root));
}
public string ToString(BinaryTree <T> tree, FormatInfo info)
{
return(ToString(tree.Root, info));
}
public string ToString(BinaryTree <T> tree, ShowType showType)
{
var formatInfo = new FormatInfo(showType);
return(ToString(tree.Root, formatInfo));
}
static void Main(string[] args)
{
Console.WriteLine("Binary Tree!");
BinaryTree myTree = new BinaryTree(1);
myTree.root.Left = new Node(2);
myTree.root.Right = new Node(3);
myTree.root.Left.Left = new Node(4);
myTree.root.Left.Right = new Node(5);
List <int> PreOrderList = new List <int>();
List <int> InOrderList = new List <int>();
List <int> PostOrderList = new List <int>();
myTree.PreOrder(myTree.root, PreOrderList);
/// <summary>
/// Pre-order tree traversal
/// </summary>
foreach (int val in PreOrderList)
{
Console.Write($"{val} ");
}
Console.WriteLine("Print PreOrder data traversal values");
/// <summary>
/// In-order tree traversal
/// </summary>
myTree.InOrder(myTree.root, InOrderList);
foreach (int val in InOrderList)
{
Console.Write($"{val} ");
}
Console.WriteLine("Print InOrder data traversal values");
/// <summary>
/// Post-order tree traversal
/// </summary>
myTree.PostOrder(myTree.root, PostOrderList);
foreach (int val in PostOrderList)
{
Console.Write($"{val} ");
}
Console.WriteLine("Print PostOrder data traversal values");
Console.WriteLine();
int[] bstValues = { 1, 2, 3, 4, 5 };
/// <summary>
/// Print values of binary search tree
/// </summary>
BinarySearchTree BST = new BinarySearchTree();
foreach (int num in bstValues)
{
BST.root = BST.Add(BST.root, num);
}
List <int> bstInOrder = new List <int>();
BST.InOrder(BST.root, bstInOrder);
foreach (int num in bstInOrder)
{
Console.Write($"{num}");
}
Console.WriteLine(" Binary Search Tree InOrder data traversal values");
}
public void Run()
{
BinaryTree <int> btree = new BinaryTree <int>();
btree.Root = new BinaryTreeNode <int>(1);
btree.Root.Left = new BinaryTreeNode <int>(2);
btree.Root.Right = new BinaryTreeNode <int>(3);
btree.Root.Left.Left = new BinaryTreeNode <int>(4);
btree.Root.Right.Right = new BinaryTreeNode <int>(5);
btree.Root.Left.Left.Right = new BinaryTreeNode <int>(6);
btree.Root.Right.Right.Right = new BinaryTreeNode <int>(7);
btree.Root.Right.Right.Right.Right = new BinaryTreeNode <int>(8);
BinaryTree <int> btreeOther = new BinaryTree <int>();
btreeOther.Root = new BinaryTreeNode <int>(1);
btreeOther.Root.Left = new BinaryTreeNode <int>(2);
btreeOther.Root.Right = new BinaryTreeNode <int>(3);
btreeOther.Root.Left.Left = new BinaryTreeNode <int>(4);
btreeOther.Root.Right.Right = new BinaryTreeNode <int>(5);
btreeOther.Root.Left.Left.Right = new BinaryTreeNode <int>(6);
btreeOther.Root.Right.Right.Right = new BinaryTreeNode <int>(7);
btreeOther.Root.Right.Right.Right.Right = new BinaryTreeNode <int>(8);
btree.PreorderTraversalRecursive();
btree.PreOrderTraversalIterative();
btree.PreOrderTraversalIterativeCompilerMimic();
btree.PostorderTraversalRecursive();
btree.PostOrderTraversalIterative();
btree.PostOrderTraversalIterativeCompilerMimic();
btree.InorderTraversalRecursive();
btree.InorderTraversalIterative();
btree.InOrderTraversalIterativeCompilerMimic();
btree.PrintLevelOrderTranversal();
Console.WriteLine("Size of tree:" + btree.GetSizeOfTree());
Console.WriteLine("Are identical: " + btree.AreIdentical(btreeOther));
Console.WriteLine("Max depth of tree: " + btree.MaxDepth());
Console.WriteLine("Tree contains 5: " + btree.Contains(5));
Console.WriteLine("Tree contains 10: " + btree.Contains(10));
//btree.MirrorTree();
//btree.PrintLevelOrderTranversal();
btree.PrintRootToLeafPaths();
Console.WriteLine("LCA for binary tree: " + btree.FindLowestCommonAncestor(7, 6).Data);
Console.WriteLine("Largest BST subtree size: " + btree.LargestBstSubtree());
Console.WriteLine("----------------BST----------------");
BinarySearchTree <int> binarySearchTree = new BinarySearchTree <int>();
binarySearchTree.Insert(50);
binarySearchTree.Insert(30);
binarySearchTree.Insert(20);
binarySearchTree.Insert(40);
binarySearchTree.Insert(70);
binarySearchTree.Insert(60);
binarySearchTree.Insert(80);
int temp = binarySearchTree.Root.Left.Data;
binarySearchTree.Root.Left.Data = binarySearchTree.Root.Right.Data;
binarySearchTree.Root.Right.Data = temp;
binarySearchTree.InorderTraversalRecursive();
binarySearchTree.CorrectBst();
binarySearchTree.InorderTraversalRecursive();
binarySearchTree.InorderTraversalRecursive();
Console.WriteLine("BST contain 60 : " + binarySearchTree.Contains(60));
Console.WriteLine("BST contain 66 : " + binarySearchTree.Contains(66));
Console.WriteLine("MinValue in BST: " + binarySearchTree.MinValue());
Console.WriteLine("Is BST: " + binarySearchTree.IsBst());
Console.WriteLine("InOrderSuccessor of root(50): " + binarySearchTree.InOrderSuccessor(binarySearchTree.Root).Data);
Console.WriteLine("5th node: " + binarySearchTree.KthSmallestNode(5).Data);
Console.WriteLine("Largest BST subtree size: " + binarySearchTree.LargestBstSubtree());
Console.WriteLine("Ceil for 50:" + binarySearchTree.Ceil(50));
Console.WriteLine("CeilIterative for 51:" + binarySearchTree.CeilIterative(51));
Console.WriteLine("FloorIterative for 49:" + binarySearchTree.FloorIterative(49));
SinglyLinkedList <int> sortedLinkedList = new SinglyLinkedList <int>();
sortedLinkedList.PushToHead(70);
sortedLinkedList.PushToHead(60);
sortedLinkedList.PushToHead(50);
sortedLinkedList.PushToHead(40);
sortedLinkedList.PushToHead(30);
sortedLinkedList.PushToHead(20);
sortedLinkedList.PushToHead(10);
BinarySearchTree <int> bstFromSll = BinarySearchTree <int> .GetBstFromSortedList(sortedLinkedList);
bstFromSll.InorderTraversalRecursive();
BinarySearchTree <int> .PrintCommonNodes(binarySearchTree, bstFromSll);
binarySearchTree.AddGreaterNodeSum();
binarySearchTree.InorderTraversalRecursive();
int[] sortedArray = new int[7] {
1, 2, 3, 4, 5, 6, 7
};
BinarySearchTree <int> bstFromArray = BinarySearchTree <int> .GetBstFromSortedArray(sortedArray);
bstFromArray.InorderTraversalRecursive();
binarySearchTree.GetInorderTraversal();
BinarySearchTree <int> mergeBst = BinarySearchTree <int> .GetMergeTree(bstFromSll, bstFromArray);
mergeBst.InorderTraversalRecursive();
int[] preOrderOfSomeTreeWithOnlyONeChildAtEachNode = new int[] { 20, 10, 11, 13, 12 };
Console.WriteLine("preOrderOfSomeTreeWithOnlyONeChildAtEachNode:" +
BinarySearchTree <int> .IsPreOrderWithOnlyOneChildSatisfyBstProperty(preOrderOfSomeTreeWithOnlyONeChildAtEachNode));
int[] preOrderOfTree = new int[] { 8, 10, 12, 15, 16, 20, 25 };
BinarySearchTree <int> bstFromPreOrder = BinarySearchTree <int> .ConstructBstFromPreOrder(preOrderOfTree);
bstFromPreOrder.InorderTraversalRecursive();
//bstFromPreOrder.BstToDll();
//dll.Print();
BinarySearchTree <int> .FindPairWithSumAs(bstFromPreOrder.Root, 33);
bstFromPreOrder.RemoveOutsideRangeNodes(10, 26);
bstFromPreOrder.InorderTraversalRecursive();
AugmentedBst <int> augmentedBst = new AugmentedBst <int>();
augmentedBst.Insert(50);
augmentedBst.Insert(30);
augmentedBst.Insert(20);
augmentedBst.Insert(40);
augmentedBst.Insert(70);
augmentedBst.Insert(60);
augmentedBst.Insert(80);
augmentedBst.InorderTraversalRecursive();
Console.WriteLine("5th element: " + augmentedBst.KthSmallestNodeInOrderOfHeightTime(5).Data);
Console.ReadLine();
}
