static void Main(string[] args) { BinaryTree bt = new BinaryTree(); //bt.AddNode("18", 18); //bt.AddNode("7", 7); //bt.AddNode("6", 6); //bt.AddNode("9", 9); //bt.AddNode("2", 2); //bt.AddNode("2", 2); //bt.AddNode("18", 18); var rand = new Random(DateTime.UtcNow.Millisecond); for (int i = 0; i < 100; i++) { //int randInt = (int)(rand.NextDouble() * 1000000); //bt.AddNode(randInt.ToString(), randInt); bt.AddNode("1", 1); } int a = 5; }
public void InOrder_Enumerator() { BinaryTree<int> tree = new BinaryTree<int>(); // 4 // / \ // 2 5 // / \ \ // 1 3 7 // / \ // 6 8 tree.Add(4); tree.Add(5); tree.Add(2); tree.Add(7); tree.Add(3); tree.Add(6); tree.Add(1); tree.Add(8); int[] expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8 }; int index = 0; foreach (int actual in tree) { Assert.AreEqual(expected[index++], actual, "The item enumerated in the wrong order"); } }
public void InOrder_Delegate() { BinaryTree<int> tree = new BinaryTree<int>(); // 4 // / \ // 2 5 // / \ \ // 1 3 7 // / \ // 6 8 tree.Add(4); tree.Add(5); tree.Add(2); tree.Add(7); tree.Add(3); tree.Add(6); tree.Add(1); tree.Add(8); int[] expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8 }; int index = 0; tree.InOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order")); }
static void Main(string[] args) { BinaryTree<string> tree = new BinaryTree<string>(); string input = string.Empty; while (!input.Equals("quit", StringComparison.CurrentCultureIgnoreCase)) { // read the line from the user Console.Write("> "); input = Console.ReadLine(); // split the line into words (on space) string[] words = input.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // add each word to the tree foreach (string word in words) { tree.Add(word); } // print the number of words Console.WriteLine("{0} words", tree.Count); // and print each word using the default (in-order) enumerator foreach (string word in tree) { Console.Write("{0} ", word); } Console.WriteLine(); tree.Clear(); } }
static void Main() { var binaryTree = new BinaryTree<int> { 90, 50, 150, 20, 75, 5, 66, 80, 68 }; Console.WriteLine("Created tree:"); PrintTree(binaryTree); var nodeToRemove = binaryTree[(new Random()).Next(0, binaryTree.Count)]; binaryTree.Remove(nodeToRemove); Console.WriteLine("\nTree with removed node [ {0} ]:", nodeToRemove); PrintTree(binaryTree); Console.WriteLine("\n5th element is: {0}", binaryTree[4]); // creating more interesting tree var tree = new BinaryTree<int> { 90, 50, 150, 20, 75, 95, 175, 5, 25, 66, 80, 92, 111, 166, 200 }; Console.WriteLine("\n\nPreorder traverse:"); tree.Traverse(node => Console.Write("[{1}]:{0} ", node, node.Level), "Preorder"); Console.WriteLine("\n\nInorder Traverse:"); tree.Traverse(node => Console.Write("[{1}]:{0} ", node, node.Level), "Inorder"); Console.WriteLine("\n\nPostorder Traverse:"); tree.Traverse(node => Console.Write("[{1}]:{0} ", node, node.Level), "Postorder"); Console.WriteLine("\n\nWidth Traverse (foreach use this method):"); tree.Traverse(node => Console.Write("[{1}]:{0} ", node, node.Level), "Width"); Console.WriteLine(); Console.ReadKey(); }
static void BinaryTreeTest() { Console.WriteLine("Binary Search Tree test"); var tree = new BinaryTree.BinaryTree(); foreach (int v in arr) { tree.Insert(new Node(v)); } //tree.Print(); Console.WriteLine("Inorder walk of binary search tree"); tree.PrintSorted(); Console.WriteLine("Print successor of each node"); foreach (int v in arr) { Node node = tree.Find(v); node.Print(); Node successor = tree.FindSuccessor(node); if (successor != null) successor.Print(); Console.WriteLine(); } Console.WriteLine("Delete each of the nodes and print resulting tree"); foreach (int v in arr) { tree.Delete(v); tree.PrintSorted(); Console.WriteLine(); } }
private void btnCreate_Click(object sender, EventArgs e) { _tree = new BinaryTree(); //lblEvents.Text = @"new binary tree"; Node root = new Node(25); _tree.Add(root); _tree.Add(new Node(20)); _tree.Add(new Node(30)); _tree.Add(new Node(10)); _tree.Add(new Node(23)); _tree.Add(new Node(35)); _tree.Add(new Node(5)); _tree.Add(new Node(4)); _tree.Add(new Node(6)); _tree.Add(new Node(21)); _tree.Add(new Node(19)); _tree.Add(new Node(24)); _tree.Add(new Node(32)); _tree.Add(new Node(50)); _tree.Add(new Node(33)); PaintTree(); }
public void Remove_Head_Line_Left() { BinaryTree<int> tree = new BinaryTree<int>(); // 3 // / // 2 // / // 1 tree.Add(3); tree.Add(2); tree.Add(1); tree.Remove(3); // 2 // / // 1 int[] expected = new[] { 1, 2 }; int index = 0; tree.PostOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order")); }
static void Main(string[] args) { TreeNode root = CreateTree(); BinaryTree tree = new BinaryTree(); tree.BFSTreeWithLevel(root); Console.ReadLine(); }
public void Test_ContainsInTree() { var tree = new BinaryTree<int>() { 1, 5, 3, 4, 9 }; Assert.AreEqual(tree.Contains(new BinaryTreeNode<int>(5)), true); Assert.AreEqual(tree.Contains(new BinaryTreeNode<int>(77)), false); Assert.AreEqual(tree.Contains(5), true); Assert.AreEqual(tree.Contains(77), false); }
public void BreadthFirstElementDoesNotExist() { BinaryTree<int> tree = new BinaryTree<int>(); tree.Root = new BinaryTreeNode<int>(1); tree.Root.Left = new BinaryTreeNode<int>(2); tree.Root.Right = new BinaryTreeNode<int>(3); tree.Root.Left.Left = new BinaryTreeNode<int>(4); tree.Root.Left.Right = new BinaryTreeNode<int>(5); tree.BreadthFirstSearch(8); }
public void BreadthFirstFind() { BinaryTree<int> tree = new BinaryTree<int>(); tree.Root = new BinaryTreeNode<int>(1); tree.Root.Left = new BinaryTreeNode<int>(2); tree.Root.Right = new BinaryTreeNode<int>(3); tree.Root.Left.Left = new BinaryTreeNode<int>(4); tree.Root.Left.Right = new BinaryTreeNode<int>(5); int expected = 3; Assert.AreEqual(expected, tree.BreadthFirstSearch(3)); }
public void Test_Enumerator_OfEmptyTree() { var tree = new BinaryTree<int>(); INode<int> nullNode = null; foreach (var node in tree) { nullNode = node; } Assert.IsNull(nullNode); }
public void Test_ClearingTree() { var tree = new BinaryTree<int>() {1, 5, 3, 4, 9}; Assert.AreEqual(tree.Count, 5); tree.Clear(); Assert.AreEqual(tree.Count, 0); var count = tree.Count(); Assert.AreEqual(count, 0); }
public void Test_Enumerator() { var tree = new BinaryTree<int>() { new BinaryTreeNode<int>(5) }; INode<int> test = null; foreach (INode<int> node in ((IEnumerable)tree)) { test = node; } Assert.AreNotEqual(null, test); Assert.AreEqual(5, test.Data); }
static void PrintTree(BinaryTree<int> bt) { foreach (var node in bt) { var sb = new StringBuilder("."); for (var i = 0UL; i < node.Level; i++) { sb.Append("."); } Console.WriteLine(sb.ToString() + node.Data); } }
public void AddNodesToTree() { BinaryTree<int> tree = new BinaryTree<int>(); tree.Root = new BinaryTreeNode<int>(1); tree.Root.Left = new BinaryTreeNode<int>(2); tree.Root.Right = new BinaryTreeNode<int>(3); tree.Root.Left.Left = new BinaryTreeNode<int>(4); tree.Root.Left.Right = new BinaryTreeNode<int>(5); BinaryTreeNode<int>[] expected = { tree.Root.Left, tree.Root.Right }; BinaryTreeNode<int>[] expected2 = { tree.Root.Left.Left, tree.Root.Left.Right }; CollectionAssert.AreEqual(expected, tree.Root.Children); CollectionAssert.AreEqual(expected2, tree.Root.Left.Children); }
public void BreadthFirstFindBiggerTree() { BinaryTree<int> tree = new BinaryTree<int>(); tree.Root = new BinaryTreeNode<int>(1); tree.Root.Left = new BinaryTreeNode<int>(2); tree.Root.Right = new BinaryTreeNode<int>(3); tree.Root.Left.Left = new BinaryTreeNode<int>(4); tree.Root.Left.Right = new BinaryTreeNode<int>(5); tree.Root.Left.Left.Left = new BinaryTreeNode<int>(6); tree.Root.Left.Left.Right = new BinaryTreeNode<int>(7); tree.Root.Left.Right.Left = new BinaryTreeNode<int>(8); tree.Root.Left.Right.Right = new BinaryTreeNode<int>(9); int expected = 9; Assert.AreEqual(expected, tree.BreadthFirstSearch(9)); }
public void BeforEachTest() { System.Diagnostics.Debug.WriteLine("Before {0}", TestContext.CurrentContext.Test.Name); tree = new BinaryTree<int>(); tree.Head = new BinaryTreeNode<int>(101, 2); tree.Head.Left = new BinaryTreeNode<int>(102, 7); tree.Head.Left.Left = new BinaryTreeNode<int>(103, 2); tree.Head.Left.Right = new BinaryTreeNode<int>(104, 6); tree.Head.Left.Right.Left = new BinaryTreeNode<int>(105, 5); tree.Head.Left.Right.Right = new BinaryTreeNode<int>(106, 11); tree.Head.Right = new BinaryTreeNode<int>(107, 5); tree.Head.Right.Right = new BinaryTreeNode<int>(108, 9); tree.Head.Right.Right.Left = new BinaryTreeNode<int>(109, 4); }
internal static void Main() { var random = new Random(); BinaryTree<int, string> tree = new BinaryTree<int, string>(); // Включва 10 върха с произволни ключове for (int i = 0; i < 10; i++) { int key = (random.Next() % 20) + 1; Console.WriteLine("Вмъква се елемент с ключ {0}", key); tree.Add(key, "someinfo"); } Console.WriteLine("Дърво: "); tree.Print(); Console.WriteLine(); // Претърсва за елемента с ключ 5 TreeNode<int, string> result = tree.Search(5); if (result != null) { Console.WriteLine("Намерен е: {0}", result.Value); } // Изтрива произволни 10 върха от дървото for (int i = 0; i < 10; i++) { try { int key = (random.Next() % 20) + 1; Console.WriteLine("Изтрива се елемента с ключ {0}", key); tree.Remove(key); } catch (InvalidOperationException ioe) { Console.WriteLine(ioe.Message); } } Console.WriteLine("Дърво: "); tree.Print(); Console.WriteLine(); }
public void AddTest(BinaryTree.iTree tr) { tr.Add(12); tr.Add(45); tr.Add(10); tr.Add(25); tr.Add(75); tr.Add(39); tr.Add(11); tr.Add(2); tr.Add(5); tr.Add(1); tr.Add(22); tr.Add(42); tr.Add(40); tr.Add(43); tr.Add(3); tr.Add(6); int expected = 16; NUnit.Framework.Assert.AreEqual(expected, tr.Size()); }
private void btnRnd_Click(object sender, EventArgs e) { var val = int.Parse(textBox1.Text); var val2 = int.Parse(textBox2.Text); Node n1 = new Node(val); Node n2 = new Node(val2); BinaryTree i = new BinaryTree(); Node root = i.RootNode; if (_tree.Exists(val) && _tree.Exists(val2)) { MessageBox.Show("The parent node is " + i.LCA(root, n1, n2).Value, "Please Hire Me!"); } else { MessageBox.Show("Node values are invalid please try again","Error"); } }
public void Creation_Of_Single() { BinaryTree<int> tree = new BinaryTree<int>(); foreach (int item in tree) { Assert.Fail("An empty tree should not enumerate any values"); } Assert.IsFalse(tree.Contains(10), "Tree should not contain 10 yet"); tree.Head = new BinaryTreeNode<int>(10); Assert.IsTrue(tree.Contains(10), "Tree should contain 10"); int count = 0; foreach (int item in tree) { count++; Assert.AreEqual(1, count, "There should be exactly one item"); Assert.AreEqual(item, 10, "The item value should be 10"); } }
public void Remove_Head() { BinaryTree<int> tree = new BinaryTree<int>(); // 4 // / \ // 2 5 // / \ \ // 1 3 7 // / \ // 6 8 tree.Add(4); tree.Add(5); tree.Add(2); tree.Add(7); tree.Add(3); tree.Add(6); tree.Add(1); tree.Add(8); tree.Remove(4); // 5 // / \ // 2 7 // / \ / \ // 1 3 6 8 int[] expected = new[] { 1, 3, 2, 6, 8, 7, 5, }; int index = 0; tree.PostOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order")); }
public void Test_CopyTo() { var tree = new BinaryTree<int>() { 90, 50,150, 20, 75 }; var arr = new INode<int>[5]; tree.CopyTo(arr,0); INode<int>[] expected = { new BinaryTreeNode<int>(90), new BinaryTreeNode<int>(50), new BinaryTreeNode<int>(150), new BinaryTreeNode<int>(20), new BinaryTreeNode<int>(75), }; for (var i = 0; i < arr.Length; i++) { Assert.AreEqual(arr[i].Data, expected[i].Data); } var arr2 = new INode<int>[1]; tree.CopyTo(arr2,0); Assert.AreEqual(arr2[0].Data, 90); Assert.AreEqual(arr2.Length, 1); }
static void Main(string[] args) { bool endConsole = false; int insertNumber; int deleteNumber; Console.WriteLine("Please enter one value at a time, whenever you are done type 'Done'"); BinaryTree tree = new BinaryTree(); while (true) { string values = Console.ReadLine(); if (values == "Done") { break; } int newValues = Convert.ToInt32(values); tree.insert(newValues); Console.WriteLine("Inorder traversal "); tree.inOrderTraversal(tree.returnRoot()); tree.printCounter(); } while (endConsole == false) { Console.WriteLine("Would you like to edit the tree? Reply Y or N"); string answertwo = Console.ReadLine(); if (answertwo == "Y") { Console.WriteLine("Insert or Delete a value? Type either Insert or Delete depending on what you would like"); string answerthree = Console.ReadLine(); if (answerthree == "Insert") { Console.WriteLine("Please enter the number you would like to insert:"); insertNumber = Convert.ToInt32(Console.ReadLine()); tree.insert(insertNumber); Console.WriteLine("Inorder traversal "); tree.inOrderTraversal(tree.returnRoot()); } else if (answerthree == "Delete") { Console.WriteLine("Please enter the number you would like to delete"); deleteNumber = Convert.ToInt32(Console.ReadLine()); tree.delete(deleteNumber); Console.WriteLine("Inorder traversal"); tree.inOrderTraversal(tree.returnRoot()); } else { Console.WriteLine("Sorry! I didn't recognise your input. Please try again!"); Console.WriteLine("---------------"); break; } } else if (answertwo == "N") { Console.WriteLine("Alright then, if you change your mind you can go again!"); Console.WriteLine("---------------"); break; } else { Console.WriteLine("Sorry! I didn't recognise your input. Please try again!"); Console.WriteLine("---------------"); break; } } }
public void InOrder_Enumerator_String() { // "a" // / \ // "c" " d" // / \ // "g" "b" // BinaryTree<string> tree3 = new BinaryTree<string>(); tree3.Head = new BinaryTreeNode<string>("a"); tree3.Head.Left = new BinaryTreeNode<string>("c"); tree3.Head.Left.Left = new BinaryTreeNode<string>("g"); tree3.Head.Left.Right = new BinaryTreeNode<string>("b"); tree3.Head.Right = new BinaryTreeNode<string>("d"); string[] expected = new[] { "g", "c", "b", "a", "d" }; int index = 0; foreach (string actual in tree3) { Assert.AreEqual(expected[index++], actual, "The item enumerated in the wrong order"); System.Diagnostics.Debug.WriteLine(actual); } }
public void InOrder_Enumerator_Char() { // a // / \ // c d // / \ // g b // BinaryTree<char> tree2 = new BinaryTree<char>(); tree2.Head = new BinaryTreeNode<char>('a'); tree2.Head.Left = new BinaryTreeNode<char>('c'); tree2.Head.Left.Left = new BinaryTreeNode<char>('g'); tree2.Head.Left.Right = new BinaryTreeNode<char>('b'); tree2.Head.Right = new BinaryTreeNode<char>('d'); char[] expected = new[] { 'g', 'c', 'b', 'a', 'd' }; int index = 0; foreach (int actual in tree2) { Assert.AreEqual(expected[index++], actual, "The item enumerated in the wrong order"); System.Diagnostics.Debug.WriteLine(actual); } }
public BinaryTree(T value, BinaryTree <T> leftChild = null, BinaryTree <T> rightChild = null) { this.Value = value; this.LeftChild = leftChild; this.RightChild = rightChild; }
public void Enumerator_Of_Single() { // 2 // / \ // tree = new BinaryTree<int>(); foreach (int item in tree) { Assert.Fail("An empty tree should not enumerate any values"); } Assert.IsFalse(tree.Contains(2), "Tree should not contain 2 yet"); tree.Head = new BinaryTreeNode<int>(2); Assert.IsTrue(tree.Contains(2), "Tree should contain 10"); int count = 0; foreach (int item in tree) { count++; Assert.AreEqual(1, count, "There should be exactly one item"); Assert.AreEqual(item, 2, "The item value should be 2"); } }
private BinaryTree <T> Contain(T x) //此下三个函数功能为不太完美的运算符重载 { BinaryTree <T> aa = new BinaryTree <T>(x); return(aa); }
/// <summary> /// Create a binary tree /// </summary> private void CreateTree() { //Init the tree _tree = new BinaryTree(); lblMsg.Text = @"Random binary tree created"; //Add a new node, to the right side of the root node Node currentNode = new Node(0); _tree.Add(currentNode, false); //Populate its children nodes PopulateLeftRightNode(currentNode, 0); //Draw the tree PaintTree(); //Update label lblCount.Text = _tree.Count.ToString(); }
static void Main(string[] args) { BinaryTree tree = new BinaryTree(80); //דוגמה //tree.Left = new TreeNode(10); //tree.Right = new TreeNode(5); //tree.Right.Left = new TreeNode(100); //BinaryTree bt = new BinaryTree(50); tree.Add(5); tree.Add(25); tree.Add(20); tree.Add(55); tree.Add(50); tree.Add(70); tree.PrintTree(); Console.WriteLine("Add 75 to the tree :"); tree.Add(75); tree.PrintTree(); Console.WriteLine("************************************"); Console.WriteLine("max: " + tree.GetMax()); Console.WriteLine(); Console.WriteLine("max: " + tree.GetMax2()); Console.WriteLine("min: " + tree.GetMin()); Console.WriteLine(); Console.WriteLine("************************************"); TreeNode myNode = tree.Find(0); if (myNode != null) { Console.WriteLine(myNode.Value + " is Found :)"); } else { Console.WriteLine("Not Found!!!!!"); } Console.WriteLine("************************************"); Console.WriteLine(); Console.Write("delete 5: \n" + tree.Delete(5)); tree.PrintTree(); Console.WriteLine(); Console.Write("delete 20: \n" + tree.Delete(20)); tree.PrintTree(); Console.WriteLine(); Console.Write("delete 75: \n" + tree.Delete(75)); tree.PrintTree(); Console.WriteLine(); Console.Write("delete 70: \n" + tree.Delete(70)); tree.PrintTree(); Console.WriteLine(); Console.Write("delete 55: \n" + tree.Delete(55)); tree.PrintTree(); //if head was public!!!!! //bt.head.Left = new TreeNode(20); //bt.head.Left.Left = new TreeNode(5); //bt.head.Left.Right = new TreeNode(25); //bt.head.Right = new TreeNode(70); //bt.PrintTree(); }
private static void Print(BinaryTreeNode root) { BinaryTree.Traverse(root, n => Console.WriteLine(n.Value)); }
public BinaryTree(int data, BinaryTree lesserTree, BinaryTree greaterTree) { this.Data = data; this.LesserTree = lesserTree; this.GreaterTree = greaterTree; }
public void Remove_Missing_From_Tree() { BinaryTree<int> tree = new BinaryTree<int>(); // 4 // / \ // 2 8 // / \ / // 1 3 6 // / \ // 5 7 int[] values = new[]{4, 2, 1, 3, 8, 6, 7, 5}; foreach(int i in values) { Assert.IsFalse(tree.Contains(10), "Tree should not contain 10"); tree.Add(i); } }
public void leftOrder(BinaryTree tree) { tree.preOrder(root); }
static void Main(string[] args) { const int min = 0; const int max = 100; var tree = new BinaryTree <int>(); var rnd = new int[10]; Node <int> root = null; var rndNo = new Random(); for (var i = 0; i < rnd.Length; i++) { rnd[i] = rndNo.Next(min, max); } foreach (var r in rnd) { tree.InsertNode(r); } Console.WriteLine("input array: "); Console.WriteLine(string.Join(",", rnd)); var values = tree.PreorderTraverseTree().ToList(); Console.WriteLine("\nthe trees preorder traversal: "); Console.WriteLine(string.Join(",", values)); var vals = tree.InOrderTraverseTree().ToList(); Console.WriteLine("\nthe trees inorder traversal: "); Console.WriteLine(string.Join(",", vals)); var rndItem = rnd[rndNo.Next(0, rnd.Length)]; Console.WriteLine("\n" + rndItem + " will be deleted from tree"); tree.DeleteNode(rndItem); var restTree = tree.PreorderTraverseTree().ToList(); Console.WriteLine("\ntree after deletion: "); Console.WriteLine(string.Join(",", restTree)); var treeContent = tree.PreorderTraverseTree().ToList(); var rndItem1 = treeContent[2]; Console.WriteLine("\ntry to find: " + rndItem1); var test = tree.FindNode(rndItem1); Console.WriteLine("Found: " + test); Console.WriteLine("Balancing tree now"); var balancedTree = tree.BalancedTree(); var balancedPreOrder = balancedTree.PreorderTraverseTree().ToList(); Console.WriteLine("\npreorder traversal of balanced tree: "); Console.WriteLine(string.Join(",", balancedPreOrder)); Console.ReadLine(); }