static void Main(string[] args)
{
BinarySearchTree<int> bst = new BinarySearchTree<int>(16);
bst.AddNode(8);
bst.AddNode(18);
bst.AddNode(30);
bst.AddNode(2);
bst.AddNode2(10);
bst.AddNode2(21);
bst.AddNode2(9);
bst.AddNode2(1);
bst.AddNode2(3);
bst.AddNode2(32);
//bst.AddNode2(9);
//int p = 0;
//Console.WriteLine(bst.FindInOrderSuccessorPredecessor(15, ref p));
//Console.WriteLine(p);
//Console.WriteLine(bst.GetLevelOfNode(2));
//Console.WriteLine(bst.GetLevelOfNode(16));
//Console.WriteLine(bst.GetLevelOfNode(2));
//Console.WriteLine(bst.GetLevelOfNode(1));
//Console.WriteLine(bst.GetLevelOfNode(9));
//Console.WriteLine(bst.GetLevelOfNode(30));
//Console.WriteLine(bst.GetLevelOfNode(21));
bst.GetCounsinofKey(32);
int[] i = { 4, 8, 2, 5, 1, 6, 3, 7 };
int[] p = { 8, 4, 5, 2, 6, 7, 3, 1 };
var result = BSTExtension.ConstrucTreefromInorderPostOrder(i, p);
var listDepthWise = bst.GetNodeListByLevel();
var listDepthWiseDFS = bst.GetNodeListByLevelUsingDFS();
Console.ReadLine();
}
static void Main(string[] args)
{
//Node root = new Node(10);
BinarySearchTree bst = new BinarySearchTree();
bst.Insert(bst.Root, bst.AddNode(10));
bst.Insert(bst.Root, bst.AddNode(5));
bst.Insert(bst.Root, bst.AddNode(15));
bst.Insert(bst.Root, bst.AddNode(7));
bst.Insert(bst.Root, bst.AddNode(12));
bst.Insert(bst.Root, bst.AddNode(18));
bst.Insert(bst.Root, bst.AddNode(14));
bst.Print();
bst.InsertNewer(bst.Root, new Node(3));
bst.InsertNewer(bst.Root, new Node(6));
bst.InsertNewer(bst.Root, new Node(11));
bst.InsertNewer(bst.Root, new Node(16));
bst.InsertNewer(bst.Root, new Node(20));
bst.Print();
//if(bst.Search(133, bst.Root) != null)
//{
// Console.WriteLine("Found!");
//}
//else
//{
// Console.WriteLine("Not Found!");
//}
Console.ReadLine();
}
public void OneElement_SearchExistingElement()
{
//Arrange
var tree = new BinarySearchTree <int>(DataComparers.NewByType <int>());
tree.AddNode(50);
//Act
Assert.True(tree.Search(50) != null);
}
public void Contains_WorksAsExpected(int[] values, int testValue, bool expectedResult)
{
var binarySearchTree = new BinarySearchTree();
foreach (var value in values)
{
binarySearchTree.AddNode(value);
}
binarySearchTree.Contains(testValue).Should().Be(expectedResult);
}
public void InOrder()
{
//Arrange
var tree = new BinarySearchTree <int>(DataComparers.NewByType <int>());
tree.AddNode(50);
tree.AddNode(20);
tree.AddNode(60);
tree.AddNode(30);
tree.AddNode(40);
tree.AddNode(55);
//Act
var inorder = new List <int>();
tree.InOrder((v) => inorder.Add(v.Value));
Assert.Equal(6, inorder.Count);
Assert.Equal(20, inorder[0]);
Assert.Equal(30, inorder[1]);
Assert.Equal(40, inorder[2]);
Assert.Equal(50, inorder[3]);
Assert.Equal(55, inorder[4]);
Assert.Equal(60, inorder[5]);
}
public void SearchExistingElement()
{
//Arrange
var tree = new BinarySearchTree <int>(DataComparers.NewByType <int>());
var item = tree.AddNode(50);
item = tree.AddNode(20);
item = tree.AddNode(60);
item = tree.AddNode(30);
item = tree.AddNode(40);
item = tree.AddNode(55);
//Act
var res = tree.Search(50);
Assert.True(res != null);
res = tree.Search(20);
Assert.True(res != null);
res = tree.Search(60);
Assert.True(res != null);
res = tree.Search(30);
Assert.True(res != null);
res = tree.Search(40);
Assert.True(res != null);
res = tree.Search(55);
Assert.True(res != null);
}
public void BSTtest()
{
BinarySearchTree BST = new BinarySearchTree(new Node(50));
BST.AddNode(35, BST.Root);
BST.AddNode(60, BST.Root);
BST.AddNode(15, BST.Root);
Assert.Equal(25, BST.AddNode(25, BST.Root).Value);
// because it already exists
Assert.Null(BST.AddNode(60, BST.Root));
Assert.Equal(75, BST.AddNode(75, BST.Root).Value);
}
static void Main(string[] args)
{
var tree = new BinarySearchTree <int>(DataComparers.NewByType <int>());
tree.AddNode(50);
tree.AddNode(30);
tree.AddNode(60);
tree.AddNode(20);
tree.AddNode(40);
tree.AddNode(55);
var newTree = tree.Clone();
System.Console.ReadLine();
}
public void SearchNotExistingElement()
{
//Arrange
var tree = new BinarySearchTree <int>(DataComparers.NewByType <int>());
tree.AddNode(50);
tree.AddNode(20);
tree.AddNode(60);
tree.AddNode(30);
tree.AddNode(40);
tree.AddNode(55);
//Act
Assert.True(tree.Search(255) == null);
}
static void Main(string[] args)
{
LinkedList <int> ll = new LinkedList <int>();
TimerPerformance tp = new TimerPerformance();
tp.StartTiming();
ll.AddNode(1);
Console.WriteLine($"Time for adding \"1\": {tp.StopTiming()}");
ll.AddNode(2);
ll.AddNode(3);
ll.AddNode(4);
ll.AddNode(5);
ll.AddNode(6);
ll.AddNode(7);
ll.AddNode(8);
tp.StartTiming();
ll.AddNode(9);
Console.WriteLine($"Time for adding \"9\": {tp.StopTiming()}");
ll.AddNode(10);
ll.AddNode(11);
ll.AddNode(12);
ll.AddNode(13);
ll.AddNode(14);
ll.AddNode(15);
ll.AddNode(16);
ll.AddNode(17);
tp.StartTiming();
ll.AddNode(18);
Console.WriteLine($"Time for adding \"18\": {tp.StopTiming()}");
Console.WriteLine("-------------------------DOUBLY LINKED LISTS-------------");
var doubleLL = new DoublyLinkedList <int>();
doubleLL.AddNode(1);
doubleLL.AddNode(2);
doubleLL.AddNode(3);
doubleLL.AddNode(4);
doubleLL.AddNode(5);
doubleLL.AddNode(6);
doubleLL.AddNode(7);
doubleLL.AddNode(8);
doubleLL.AddNode(9);
doubleLL.AddNode(10);
doubleLL.AddNode(11);
doubleLL.AddNode(12);
doubleLL.AddNode(13);
doubleLL.AddNode(14);
doubleLL.AddNode(15);
doubleLL.AddNode(16);
doubleLL.AddNode(17);
doubleLL.AddNode(18);
foreach (var item in doubleLL)
{
Console.WriteLine(item);
}
Console.WriteLine();
Console.WriteLine("-----------Previous value of node with value \"3\"------------");
Console.WriteLine(((DoubleNode <int>)doubleLL.HeadNode.NextNode.NextNode).PreviousNode.Value);
Console.WriteLine($"\nDeleteAt(3)");
doubleLL.DeleteAt(3);
//foreach(var item in doubleLL)
// Console.WriteLine(item);
foreach (var item in doubleLL)
{
Console.WriteLine(item);
}
Console.WriteLine("\nPrevious node of element at 3rd index: ");
Console.Write((doubleLL.HeadNode.NextNode.NextNode.NextNode as DoubleNode <int>).PreviousNode.Value);
Console.WriteLine();
Console.WriteLine("Merge nodes and multiply values for singly linked list -----------------");
Console.WriteLine();
MergeNodesAndMultValues(ll.HeadNode);
foreach (var item in ll.ReadValues())
{
Console.WriteLine(item);
}
//Console.WriteLine($"\nValue of the previous node in singly linked list: {ll.HeadNode.NextNode.NextNode.Value}");
Console.WriteLine("STACK DATA STRUCTURE ----------------------");
CStack <int> stack = new CStack <int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
stack.Push(4);
stack.Push(5);
stack.Push(7);
stack.Push(8);
stack.Push(9);
stack.Push(10);
stack.Push(11);
stack.Push(12);
Console.WriteLine("\ncontinuous .Pop() calls");
Console.WriteLine();
foreach (var item in stack)
{
Console.WriteLine(item);
}
Console.WriteLine();
stack.Pop();
foreach (var item in stack)
{
Console.WriteLine(item);
}
Console.WriteLine();
stack.Pop();
foreach (var item in stack)
{
Console.WriteLine(item);
}
Console.WriteLine();
stack.Pop();
foreach (var item in stack)
{
Console.WriteLine(item);
}
Console.WriteLine("\nSTACK DATA STRUCTURE WITH LINKED LIST ----------------------");
LLStack <int> llStack = new LLStack <int>();
llStack.Push(1);
llStack.Push(2);
llStack.Push(3);
llStack.Push(4);
llStack.Push(5);
llStack.Push(6);
llStack.Push(7);
llStack.Push(8);
llStack.Push(9);
llStack.Push(10);
Console.WriteLine("Read llStack values----------");
Console.WriteLine();
foreach (var item in llStack)
{
Console.WriteLine(item);
}
Console.WriteLine("llStack.Pop()");
llStack.Pop();
foreach (var item in llStack)
{
Console.WriteLine(item);
}
Console.WriteLine("llStack.Pop()");
llStack.Pop();
foreach (var item in llStack)
{
Console.WriteLine(item);
}
Console.WriteLine("llStack.Push(11)");
llStack.Push(11);
foreach (var item in llStack)
{
Console.WriteLine(item);
}
Console.WriteLine();
Console.WriteLine("Intersecting node------");
LinkedList <int> l1 = new LinkedList <int>(), l2 = new LinkedList <int>();
l1.AddNode(1);
l1.AddNode(2);
l1.AddNode(3);
l1.AddNode(4);
l1.AddNode(7);
l1.AddNode(8);
l1.AddNode(9);
l2.AddNode(2);
l2.AddNode(4);
Console.WriteLine(LinkedList <int> .FindIntesectingNode(l1, l2));
l1.GetNthReverseNode(1);
foreach (var item in l1)
{
Console.WriteLine(item);
}
//QUEUE
//Console.WriteLine("\nQUEUE DATA STRUCTURE USAGE\n");
//CQueue<int> queue = new CQueue<int>();
//queue.Enqueue(1);
//queue.Enqueue(3);
//queue.Enqueue(2);
//queue.Enqueue(4);
//queue.Enqueue(5);
//queue.Enqueue(6);
//queue.Enqueue(7);
//queue.Enqueue(8);
//queue.Enqueue(7);
//queue.Dequeue();
//queue.Dequeue();
//queue.Enqueue(9);
//queue.Enqueue(10);
//queue.Enqueue(11);
//foreach (var item in queue)
// Console.WriteLine(item);
//Console.WriteLine("queue.Dequeue() * 3");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"ITEM REMOVED: {queue.Dequeue()}");
//Console.WriteLine($"\nqueue.IsEmpty(): {queue.IsEmpty()}");
//foreach (var item in queue)
// Console.WriteLine(item);
//Console.WriteLine("LLQueue USAGE----------------\n");
//LLQueue<int> queue2 = new LLQueue<int>();
//queue2.Enqueue(1);
//queue2.Enqueue(2);
//queue2.Enqueue(3);
//queue2.Enqueue(4);
//queue2.Enqueue(5);
//queue2.Enqueue(6);
//queue2.Enqueue(7);
//queue2.Enqueue(8);
//queue2.Enqueue(9);
//Console.WriteLine();
//queue2.PrintElems();
//Console.WriteLine();
//queue2.Dequeue();
//queue2.Dequeue();
//queue2.PrintElems();
//Console.WriteLine();
//queue2.Enqueue(10);
//queue2.PrintElems();
//BST
Console.WriteLine("Binary Search Tree in ACTION!----------");
BinarySearchTree bst = new BinarySearchTree();
//bst.AddNode(6);
//bst.AddNode(3);
//bst.AddNode(9);
//bst.AddNode(1);
//bst.AddNode(8);
//bst.AddNode(4);
//bst.AddNode(10); ITERATIVE APROACH, BETTER
bst.AddNodeRecursive(6);
bst.AddNodeRecursive(3);
bst.AddNodeRecursive(9);
bst.AddNodeRecursive(1);
bst.AddNodeRecursive(8);
bst.AddNodeRecursive(4);
bst.AddNodeRecursive(10);
bst.AddNodeRecursive(7);
Console.Write("\nbst.ExistNode(4)? -> ");
Console.WriteLine(bst.ExistNode(4));
tp.StartTiming();
Console.Write("\nbst.ExistNode(11)? -> ");
Console.WriteLine(bst.ExistNode(11));
Console.WriteLine($"TIME TAKEN IN ExistNode() OPERATION: {tp.StopTiming()}");
Console.Write("\nbst.ExistNode(10)? -> ");
Console.WriteLine(bst.ExistNode(10));
//USE OF BFS AND DFS ALGORITHMS TO TRAVERSE THE TREE
Console.WriteLine("using BFS and DFS ---------------------------");
List <int> bfs = new List <int>();
bst.TraverseDFSPreorder(bfs, bst.Root);
foreach (var item in bfs)
{
Console.WriteLine(item);
}
Console.WriteLine();
bfs.Clear();
bst.TraverseDFSPreorderIterative(bfs);
foreach (var item in bfs)
{
Console.WriteLine(item);
}
Console.WriteLine("\nGiven a BT, return the sum of all the depths for all the nodes in it\nSOLUTION");
BinarySearchTree bst2 = new BinarySearchTree();
bst2.AddNode(4);
bst2.AddNode(2);
bst2.AddNode(6);
bst2.AddNode(1);
bst2.AddNode(3);
bst2.AddNode(7);
bst2.AddNode(5);
Console.WriteLine(bst2.SumDepths());
BSTNode <int> rootNode = new BSTNode <int>(5);
rootNode.LeftRoot = new BSTNode <int>(3);
rootNode.RightRoot = new BSTNode <int>(8);
rootNode.RightRoot.LeftRoot = new BSTNode <int>(7);
rootNode.RightRoot.RightRoot = new BSTNode <int>(9);
rootNode.LeftRoot.RightRoot = new BSTNode <int>(4);
rootNode.LeftRoot.LeftRoot = new BSTNode <int>(2);
Console.WriteLine($"\nIs Binary Search Tree the following tree?: {bst2.IsBST(rootNode)}");
Console.WriteLine($"\nBinarySearchTreee.GetPredecessor(4): {bst2.GetPredecessor(4).Value}");
Console.WriteLine($"\nBinarySearchTreee.GetSucessor(3): {bst2.GetSuccesor(3).Value}");
Console.WriteLine("\nBinarySearchTree.DeleteNode(6)");
bst2.DeleteNode(bst2.Root, 6);
bst2.AddNode(6);
Console.WriteLine("\nBinarySearchTree.DeleteNodeMCD(6)");
bst2.DeleteNodeMCD(bst2.Root, 6);
bst2.AddNode(6);
//Graphs
Console.WriteLine("Graphs---------------------------");
EdgeListGraph <int> undirectedGraph = new EdgeListGraph <int>();
undirectedGraph.vertices = new int[] { 1, 2, 3, 4 };
undirectedGraph.edges = new Edge[] { new Edge(0, 1), new Edge(0, 3), new Edge(2, 1), new Edge(2, 3) };
Console.WriteLine("undirectedGraph.GetAdyacentNodes(4): ");
undirectedGraph.GetAdyacentNodes(4);
//Heaps
Console.WriteLine("Min Heap ds-----------");
MinHeap minHeap = new MinHeap(10);
minHeap.Insert(7);
minHeap.Insert(3);
minHeap.Insert(6);
minHeap.Remove();
minHeap.Insert(1);
minHeap.Insert(2);
minHeap.Remove();
minHeap.Insert(5);
minHeap.Insert(4);
foreach (var item in minHeap)
{
Console.WriteLine(item);
}
Console.WriteLine("-Max Heap--------------------------------");
MaxHeap maxHeap = new MaxHeap(10);
maxHeap.Insert(2);
maxHeap.Insert(1);
maxHeap.Insert(4);
maxHeap.Remove();
maxHeap.Insert(2);
maxHeap.Insert(1);
maxHeap.Insert(9);
maxHeap.Remove();
Console.WriteLine(maxHeap.Peek() == 2);
foreach (var item in maxHeap)
{
Console.WriteLine(item);
}
}
public void Given3Nodes_WhenAddedToBinaryTree_ShouldReturnSizeTh()
{
BinaryTree.AddNode(56);
BinaryTree.AddNode(30);
BinaryTree.AddNode(70);
Assert.AreEqual(56, BinaryTree.GetRoot);
Assert.AreEqual(30, BinaryTree.GetRootLeft);
Assert.AreEqual(70, BinaryTree.GetRootRight);
}
static void Main(string[] args)
{
BinarySearchTree bst = new BinarySearchTree();
// Inserting Nodes to Binary search Tree
bst.Insert(bst.Root, bst.AddNode(50));
bst.Insert(bst.Root, bst.AddNode(40));
bst.Insert(bst.Root, bst.AddNode(60));
bst.Insert(bst.Root, bst.AddNode(35));
bst.Insert(bst.Root, bst.AddNode(45));
bst.Insert(bst.Root, bst.AddNode(42));
bst.Insert(bst.Root, bst.AddNode(30));
bst.Insert(bst.Root, bst.AddNode(70));
bst.Insert(bst.Root, bst.AddNode(58));
bst.Insert(bst.Root, bst.AddNode(59));
bst.Insert(bst.Root, bst.AddNode(65));
bst.Insert(bst.Root, bst.AddNode(75));
//Traversing BST in Inorder fashion
bst.Print();
bst.Inorder(bst.Root);
Console.WriteLine();
bst.IterativeInorder(bst.Root);
Console.ReadKey();
}
public void StackTest()
{
IBinarySearchTree <int> BST = new BinarySearchTree <int>();
//IBinarySearchTreeNode<int> node100 = new BinarySearchTreeNode<int>(100);
//IBinarySearchTreeNode<int> node110 = new BinarySearchTreeNode<int>(110);
//IBinarySearchTreeNode<int> node120 = new BinarySearchTreeNode<int>(120);
//IBinarySearchTreeNode<int> node130 = new BinarySearchTreeNode<int>(130);
//IBinarySearchTreeNode<int> node140 = new BinarySearchTreeNode<int>(140);
//IBinarySearchTreeNode<int> node150 = new BinarySearchTreeNode<int>(150);
//IBinarySearchTreeNode<int> node90 = new BinarySearchTreeNode<int>(90);
//IBinarySearchTreeNode<int> node80 = new BinarySearchTreeNode<int>(80);
//IBinarySearchTreeNode<int> node70 = new BinarySearchTreeNode<int>(70);
//IBinarySearchTreeNode<int> node60 = new BinarySearchTreeNode<int>(60);
//IBinarySearchTreeNode<int> node50 = new BinarySearchTreeNode<int>(50);
var root = BST.AddNode(12);
BST.AddNode(5);
BST.AddNode(3);
BST.AddNode(7);
BST.AddNode(9);
BST.AddNode(8);
BST.AddNode(11);
BST.AddNode(15);
BST.AddNode(13);
BST.AddNode(14);
BST.AddNode(17);
BST.AddNode(20);
BST.AddNode(18);
string s = BST.DrawTree();
Debug.WriteLine(s);
var n = BST.RemoveNode(5);
//BST.RemoveNode(170);
//Debug.WriteLine(BST.DrawTree());
//BST.RemoveNode(140);
//Debug.WriteLine(BST.DrawTree());
//BST.RemoveNode(60);
//Debug.WriteLine(BST.DrawTree());
}
static void Main(string[] args)
{
BinarySearchTree bst = new BinarySearchTree();
// Inserting Nodes to Binary search Tree
bst.Insert(bst.Root, bst.AddNode(50));
bst.Insert(bst.Root, bst.AddNode(40));
bst.Insert(bst.Root, bst.AddNode(60));
bst.Insert(bst.Root, bst.AddNode(35));
bst.Insert(bst.Root, bst.AddNode(45));
bst.Insert(bst.Root, bst.AddNode(30));
bst.Insert(bst.Root, bst.AddNode(48));
bst.Insert(bst.Root, bst.AddNode(70));
bst.Insert(bst.Root, bst.AddNode(58));
bst.Insert(bst.Root, bst.AddNode(55));
bst.Insert(bst.Root, bst.AddNode(65));
bst.Insert(bst.Root, bst.AddNode(75));
// Traversing BST in Inorder fashion
//bst.Inorder(bst.Root);
bst.Print();
bst.SumOfAllPaths(bst.Root, 0);
Console.ReadKey();
}
static void Main(string[] args)
{
MinHeap mh = new MinHeap();
HeapNode hNode = new HeapNode();
mh.AddItem(10);
mh.AddItem(100);
mh.AddItem(30);
mh.AddItem(40);
mh.AddItem(55);
mh.AddItem(25);
mh.AddItem(27);
mh.AddItem(5);
mh.Print();
mh.RemoveItem(40);
mh.Print();
mh.PopMin();
mh.Print();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
//ReferenceEquals:
//https://msdn.microsoft.com/en-us/library/ms379572(v=vs.80).aspx
BinarySearchTree bst = new BinarySearchTree();
bst.InitializeBST(5);
bst.AddNode(9);
bst.AddNode(3);
bst.AddNode(4);
bst.AddNode(2);
bst.AddNode(6);
bst.AddNode(2);
bst.AddNode(7);
bst.AddNode(8);
bst.AddNode(10);
bst.AddNode(1);
BinarySearchTree bst2 = new BinarySearchTree();
bst2.InitializeBST(9);
bst2.AddNode(6);
bst2.AddNode(10);
bst2.AddNode(7);
bst2.AddNode(8);
bst2.AddNode(2);
BSTcalc cal = new BSTcalc();
int height = cal.getHeight(bst.root);
Console.WriteLine("Tree Height = {0}", height);
cal.IsBalanced(bst.root);
cal.LCA(bst.root, 4, 7);
cal.bstLCA(bst.root, 4, 7);
cal.containsTree(bst.root, bst2.root);
cal.getPaths(bst.root);
Console.WriteLine("Printing Pre Order ...");
PrintBST_PreOrder(bst.root);
Console.WriteLine();
Console.WriteLine("--------------------");
Console.WriteLine("Printing In Order ...");
PrintBST_InOrder(bst.root);
Console.WriteLine();
Console.WriteLine("--------------------");
Console.WriteLine("Printing Post Order ...");
PrintBST_PostOrder(bst.root);
Console.WriteLine();
Console.WriteLine("--------------------");
Console.WriteLine("END ---");
Console.ReadLine();
}
