public BinaryTree RecoverTree(BinaryTree root) { BinaryTree n1 = null; BinaryTree n2 = null; bool findingN2 = false; int last = int.MinValue; foreach (var cur in root.InOrderBinaryTree()) { if (cur.Value <= last) // desending { n2 = cur; findingN2 = true; } else { if (!findingN2) { n1 = cur; } } last = cur.Value; } int tmp = n1.Value; n1.Value = n2.Value; n2.Value = tmp; return root; }
public static void AddNumber(BinaryTree<int> tree, int number) { tree.Add(number); Console.WriteLine("Added " + number); Traverse(tree.Root, ""); Console.WriteLine("----------------------"); }
public int MaxDepth(BinaryTree root) { if (root == null) return 0; return Math.Max(MaxDepth(root.Left), MaxDepth(root.Right)) + 1; }
public void TreeWithPointProvider(CustomPoint[] point, CustomPoint[] resultPoint, IComparer<CustomPoint> comparer) { var tree = new BinaryTree<CustomPoint>(point, comparer); var pointCompare = new PointComparer(); var enumeratorBook = tree.Preorder().ToArray(); CollectionAssert.AreEqual(enumeratorBook, resultPoint, pointCompare); }
private void InorderTraversalNonRec(BinaryTree root, List<int> result) { if (root == null) { return; } Stack<BinaryTree> stack = new Stack<BinaryTree>(); stack.Push(root); while (root.Left != null) { stack.Push(root.Left); root = root.Left; } while (stack.Count > 0) { var tmp = stack.Pop(); result.Add(tmp.Value); if (tmp.Right != null) { stack.Push(tmp.Right); tmp = tmp.Right; while (tmp.Left!= null) { stack.Push(tmp.Left); tmp = tmp.Left; } } } }
public void ExceptionNull() { var binaryTree = new BinaryTree<string>("asdasd"); Assert.AreEqual(binaryTree.Data, "asdasd"); binaryTree.Data = null; }
public void TestMethod_remove() { BinaryTree<int> bt = new BinaryTree<int>(); bt.Add(10); Assert.AreEqual(true, bt.Remove(10)); }
public TreesAndGraphsTests() { var _J = new Node<char>('J'); var _I = new Node<char>(_J, null, 'I'); var _H = new Node<char>(null, _I, 'H'); var _D = new Node<char>(_H, null, 'D'); var _M = new Node<char>(null, null, 'M'); var _L = new Node<char>(null, _M, 'L'); var _K = new Node<char>(_L, null, 'K'); var _E = new Node<char>(_K, null, 'E'); var _B = new Node<char>(_D, _E, 'B'); var _F = new Node<char>(null, null, 'F'); var _S = new Node<char>(null, null, 'S'); var _R = new Node<char>(_S, null, 'R'); var _N = new Node<char>(_R, null, 'N'); var _Q = new Node<char>(null, null, 'Q'); var _P = new Node<char>(null, _Q, 'P'); var _O = new Node<char>(null, _P, 'O'); var _G = new Node<char>(_N, _O, 'G'); var _C = new Node<char>(_F, _G, 'C'); var _A = new Node<char>(_B, _C, 'A'); treeLetters = new BinaryTree<char>(_A); treeLetter["tree"] = treeLetters; treeLetter["bf_traversal_char_array"] = "ABCDEFGHKNOILRPJMSQ".ToCharArray(); }
public void Simple() { var binaryTree = new BinaryTree<int>(5); Assert.AreEqual(binaryTree.Count, 0); Assert.AreEqual(binaryTree.Degree, 0); Assert.AreEqual(binaryTree.Data, 5); binaryTree = new BinaryTree<int>(5, new BinaryTree<int>(3), new BinaryTree<int>(4)); Assert.AreEqual(binaryTree.Count, 2); Assert.AreEqual(binaryTree.Degree, 2); Assert.AreEqual(binaryTree.Data, 5); Assert.AreEqual(binaryTree.Left.Data, 3); Assert.AreEqual(binaryTree.Right.Data, 4); binaryTree = new BinaryTree<int>(5, 3, 4); Assert.AreEqual(binaryTree.Count, 2); Assert.AreEqual(binaryTree.Degree, 2); Assert.AreEqual(binaryTree.Data, 5); Assert.AreEqual(binaryTree.Left.Data, 3); Assert.AreEqual(binaryTree.Right.Data, 4); }
// http://leetcode.com/2011/07/lowest-common-ancestor-of-a-binary-tree-part-i.html // this solution doesn't work if node1 or node2 doesn't exist in the tree. public BinaryTree FindLowestCommonAncestor(BinaryTree tree, int node1, int node2) { var result = LCA(tree, node1, node2); if (result != null) result.Left = result.Right = null; return result; }
public List<BinaryTree> GenerateTree(int[] input, int start, int end) { if (start > end) { return new List<BinaryTree> { null }; } if (start == end) { BinaryTree tree = new BinaryTree(input[start]); return new List<BinaryTree> { tree }; } List<BinaryTree> results = new List<BinaryTree>(); for (int i = start; i <= end; i++) { List<BinaryTree> left = GenerateTree(input, start, i - 1); List<BinaryTree> right = GenerateTree(input, i + 1, end); foreach (var leftTree in left) { foreach (var rightTree in right) { BinaryTree current = new BinaryTree(input[i]); current.Left = leftTree; current.Right = rightTree; results.Add(current); } } } return results; }
public void Simple() { var binaryTree = new BinaryTree<int>(5); Assert.AreEqual(binaryTree.Count, 0); Assert.AreEqual(binaryTree.Degree, 0); Assert.AreEqual(binaryTree.Data, 5); binaryTree.Add(3); Assert.AreEqual(binaryTree.Count, 1); Assert.AreEqual(binaryTree.Degree, 1); Assert.AreEqual(binaryTree.Data, 5); Assert.AreEqual(binaryTree.Left.Data, 3); Assert.IsNull(binaryTree.Right); binaryTree.Add(4); Assert.AreEqual(binaryTree.Count, 2); Assert.AreEqual(binaryTree.Degree, 2); Assert.AreEqual(binaryTree.Data, 5); Assert.AreEqual(binaryTree.Left.Data, 3); Assert.AreEqual(binaryTree.Right.Data, 4); }
public void DuplicateKeysNotAllowed() { BinaryTree<int, string> tree = new BinaryTree<int, string>(); tree.Add(3, "a"); tree.Add(3, "a"); }
public BinaryTree RecoverTree(BinaryTree root) { BinaryTree first = null, second = null; int last = int.MinValue; Stack<BinaryTree> stack = new Stack<BinaryTree>(); PushLeftNodesIntoStack(root, stack); while (stack.Count != 0) { var item = stack.Pop(); if (item.Value < last) { second = item; } else if (second == null) { first = item; } last = item.Value; PushLeftNodesIntoStack(item.Right, stack); } int tempValue = first.Value; first.Value = second.Value; second.Value = tempValue; return root; }
/// <summary> /// Static method for building a binary tree with Employees and returning it /// </summary> /// <param name="employee">Current employee(at the start the root)</param> /// <param name="employees">Dictionary with employees</param> /// <returns>Binary tree</returns> public static BinaryTree<Employee> recursiveTreeBuilder(Employee employee, Dictionary<Employee, List<Employee>> employees) { BinaryTree<Employee> tree; //When the node is found the recursion goes deeper foreach (var pair in employees) { //searching for perticular node, so it can build the tree correctly if (pair.Key.FirstName == employee.FirstName) { //taking the left and right child of this node if (pair.Value.Count == 2) { var employeeLeftSubordinate = pair.Value[0]; var employeeRightSubordinate = pair.Value[1]; //building the tree recursively by building first the left subtree and then the right tree = new BinaryTree<Employee>(employee, recursiveTreeBuilder(employeeLeftSubordinate, employees), recursiveTreeBuilder(employeeRightSubordinate, employees)); return tree; } else { var employeeLeftSubordinate = pair.Value[0]; //building the tree recursively by building first the left subtree and then the right tree = new BinaryTree<Employee>(employee, recursiveTreeBuilder(employeeLeftSubordinate, employees), null); return tree; } } } //When it reaches a leaf(node with no children) it returns it as tree with only a root and no children return tree = new BinaryTree<Employee>(employee); }
public void DeleteTest() { var tree = new BinaryTree<float>(); tree.Add(4.21f); tree.Add(421); tree.Add(42); tree.Add(1); tree.Add(1000.500f); tree.Delete(4.21f); Assert.IsFalse(tree.Contains(4.21f)); Assert.IsTrue(tree.Contains(421)); Assert.IsTrue(tree.Contains(42)); Assert.IsTrue(tree.Contains(1)); tree.Delete(421); Assert.IsFalse(tree.Contains(421)); Assert.IsTrue(tree.Contains(1)); tree.Delete(1); Assert.IsFalse(tree.Contains(1)); Assert.IsFalse(tree.Contains(421)); Assert.IsTrue(tree.Contains(42)); tree.Delete(42); Assert.IsFalse(tree.Contains(42)); Assert.IsTrue(tree.Contains(1000.500f)); tree.Delete(1000.500f); Assert.IsFalse(tree.Contains(1000.500f)); Assert.IsTrue(tree.IsEmpty()); }
public static void AddElements(BinaryTree<int> binaryTree, int count) { for (int i = 1; i <= count; i++) { binaryTree.Add(i); } }
private static void BinaryTreeWalks() { BinaryTree<int> t = new BinaryTree<int>(1) { LeftChild = new BinaryTree<int>(2), RightChild = new BinaryTree<int>(3) }; t.LeftChild.LeftChild = new BinaryTree<int>(4); t.LeftChild.RightChild = new BinaryTree<int>(5); t.RightChild.LeftChild = new BinaryTree<int>(6); t.RightChild.RightChild = new BinaryTree<int>(7); foreach (var nodeValue in t.PreorderTreeWalk()) { Console.WriteLine(nodeValue); } foreach (var nodeValue in t.PostorderTreeWalk()) { Console.WriteLine(nodeValue); } foreach (var nodeValue in t.InorderTreeWalk()) { Console.WriteLine(nodeValue); } }
public void BuildBinaryTree_PrintIndentedPreOrder_ShouldWorkCorrectly() { // Arrange var binaryTree = new BinaryTree<string>("*", new BinaryTree<string>("-", new BinaryTree<string>("+", new BinaryTree<string>("3"), new BinaryTree<string>("2")), new BinaryTree<string>("*", new BinaryTree<string>("9"), new BinaryTree<string>("6"))), new BinaryTree<string>("8")); // Act var outputStream = new MemoryStream(); using (var outputWriter = new StreamWriter(outputStream)) { Console.SetOut(outputWriter); binaryTree.PrintIndentedPreOrder(); } var output = Encoding.UTF8.GetString(outputStream.ToArray()); // Assert var expectedOutput = "*\n -\n +\n 3\n 2\n *\n 9\n 6\n 8\n"; output = output.Replace("\r\n", "\n"); Assert.AreEqual(expectedOutput, output); }
public BinaryTree<Script> Create() { var tree = new BinaryTree<Script>(ScriptType.Quali_Email.ToString()) { Root = new BinaryTreeNode<Script> { Value = new Script { Question = "Is it okay if we can send you our company profile by email?" }, Right = new BinaryTreeNode<Script> { Value = new Script { Question = "Could I get your email address?", Actions = new Collection<ScriptAction> { new UpdateEmail() } }, Right = End(true), Left = End(true) }, Left = End(true) } }; return tree; }
public void Point2D_InOrderTraversal_CustomComparerTest() { BinaryTree<Point2D> bt = new BinaryTree<Point2D>(); Point2D[] elemToAdd = { new Point2D{X = 1, Y = 2}, new Point2D{X = 10, Y = 2}, new Point2D{X = 2, Y = 1}, new Point2D{X = 4, Y = 4} }; bt.Comparer = new CustomComparer<Point2D>((p1,p2) => (p1.X + p1.Y) - (p2.X+p2.Y)); foreach (var item in elemToAdd) bt.Add(item); List<Point2D> actual = new List<Point2D>(); foreach (var item in bt.Inorder()) { actual.Add(item); } Point2D[] expected = { new Point2D{X = 2, Y = 1}, new Point2D{X = 1, Y = 2}, new Point2D{X = 4, Y = 4}, new Point2D{X = 10, Y = 2} }; CollectionAssert.AreEqual(expected, actual); }
public void Book_PostOrderTraversal_DefaultComparerTest() { List<Book> booksList = new List<Book>() { new Book(){Author = "Mark Twen", Title = "Oliver Twist", Year = 1935, Publisher = "WilliamsPublish.", PagesQuantity = 350}, new Book(){Author = "Andew Tanenbaum", Title = "Computer Networks", Year = 2010, Publisher = "ClassicOfComputerScience.", PagesQuantity = 750}, new Book(){Author = "Gang Of Fours", Title = "Design Patterns", Year = 1995, Publisher = "O'Realy.", PagesQuantity = 520} }; BinaryTree<Book> bt = new BinaryTree<Book>(); foreach (var item in booksList) { bt.Add(item); } List<Book> expectedList = new List<Book>() { new Book(){Author = "Gang Of Fours", Title = "Design Patterns", Year = 1995, Publisher = "O'Realy.", PagesQuantity = 520}, new Book(){Author = "Andew Tanenbaum", Title = "Computer Networks", Year = 2010, Publisher = "ClassicOfComputerScience.", PagesQuantity = 750}, new Book(){Author = "Mark Twen", Title = "Oliver Twist", Year = 1935, Publisher = "WilliamsPublish.", PagesQuantity = 350}, }; List<Book> actualList = new List<Book>(); foreach (var item in bt.Postorder()) { actualList.Add(item); } CollectionAssert.AreEqual(expectedList,actualList); }
public static void Main() { // JFK BinaryTree<string> jfkFamilyTree = new BinaryTree<string>( "John Fitzgerald Kennedy"); jfkFamilyTree.SubItems = new Pair<BinaryTree<string>>( new BinaryTree<string>("Joseph Patrick Kennedy"), new BinaryTree<string>("Rose Elizabeth Fitzgerald")); // Grandparents (Father's side) jfkFamilyTree.SubItems.First.SubItems = new Pair<BinaryTree<string>>( new BinaryTree<string>("Patrick Joseph Kennedy"), new BinaryTree<string>("Mary Augusta Hickey")); // Grandparents (Mother's side) jfkFamilyTree.SubItems.Second.SubItems = new Pair<BinaryTree<string>>( new BinaryTree<string>("John Francis Fitzgerald"), new BinaryTree<string>("Mary Josephine Hannon")); foreach(string name in jfkFamilyTree) { Console.WriteLine(name); } }
private BinaryTree BuildTreeRec(int[] inOrder, int[] postOrder, int startInOrder, int endInOrder, int startPostOrder, int endPostOrder) { if (startPostOrder > endPostOrder) { return null; } if (startPostOrder == endPostOrder) { return new BinaryTree(postOrder[endPostOrder]); } int rootValue = postOrder[endPostOrder]; BinaryTree root = new BinaryTree(rootValue); int indexInInOrder = startInOrder; for (; indexInInOrder <= endInOrder; indexInInOrder++) { if (rootValue == inOrder[indexInInOrder]) { break; } } int leftLength = indexInInOrder - startInOrder; root.Left = BuildTreeRec(inOrder, postOrder, startInOrder, indexInInOrder - 1, startPostOrder, startPostOrder + leftLength - 1); root.Right = BuildTreeRec(inOrder, postOrder, indexInInOrder + 1, endInOrder, startPostOrder + leftLength, endPostOrder - 1); return root; }
public void Simple_Create() { var list = new List<int> { 1, 2, 3, 4, 5, 6, 7 }; var tree = new BinaryTree<int>(); tree.Add(list[3]); tree.Add(list[1]); tree.Add(list[0]); tree.Add(list[2]); tree.Add(list[5]); tree.Add(list[4]); tree.Add(list[6]); Assert.AreEqual(4, tree.Root.Value); Assert.AreEqual(2, tree.Root.Left.Value); Assert.AreEqual(1, tree.Root.Left.Left.Value); Assert.AreEqual(3, tree.Root.Left.Right.Value); Assert.AreEqual(null, tree.Root.Left.Left.Left); Assert.AreEqual(null, tree.Root.Left.Left.Right); Assert.AreEqual(null, tree.Root.Left.Right.Left); Assert.AreEqual(null, tree.Root.Left.Right.Right); Assert.AreEqual(6, tree.Root.Right.Value); Assert.AreEqual(5, tree.Root.Right.Left.Value); Assert.AreEqual(7, tree.Root.Right.Right.Value); Assert.AreEqual(null, tree.Root.Right.Left.Left); Assert.AreEqual(null, tree.Root.Right.Left.Right); Assert.AreEqual(null, tree.Root.Right.Right.Left); Assert.AreEqual(null, tree.Root.Right.Right.Right); }
public TreeNodeWithNext Connect(BinaryTree input) { TreeNodeWithNext root = input.ConvertToTreeNodeWithNext(); Connect(root); return root; }
public BinaryTree[] GenerateTrees(int n) { cachedResults[0] = new BinaryTree[1] { null }; cachedResults[1] = new BinaryTree[1] { new BinaryTree(1) }; for (int i = 2; i <= n; i++) // get answer i: i+1 nodes { if (cachedResults.ContainsKey(i)) { continue; } // left part can have 0 - i-1 nodes, if i nodes in all List<BinaryTree> trees = new List<BinaryTree>(); for (int left = 0; left <= i - 1; left++) { var root = new BinaryTree(left + 1); foreach (var possibleLeft in cachedResults[left]) { foreach (var possibleRight in cachedResults[i - 1 - left]) { root.Left = possibleLeft; root.Right = CloneTree(possibleRight, left + 1); trees.Add(CloneTree(root, 0)); } } } cachedResults[i] = trees.ToArray(); } return cachedResults[n]; }
static void Main(string[] args) { //BinarySearchTree<int> tree = new BinarySearchTree<int>(); //tree.Add(5); //tree.PrintInorder(); //tree.Add(5); //tree.PrintInorder(); //tree.Add(50); //tree.PrintInorder(); // tree.Add(14); //tree.Add(4); //tree.PrintInorder(); //Console.WriteLine(); // Console.WriteLine(tree.FindLowestCommonAncesterLoop(tree.Root, 0, 100).Data); //Console.WriteLine(tree.DoesNodeExist(50)); //Console.WriteLine(new BSTValidator().Check(tree.Root)); BinaryTree<int> tree = new BinaryTree<int>(); tree.Root = new BinaryTree<int>.Node<int>(null, null, 10); tree.Root.Left = new BinaryTree<int>.Node<int>(null, null, 100); tree.Root.Right = new BinaryTree<int>.Node<int>(null, null, 50); tree.Root.Left.Right = new BinaryTree<int>.Node<int>(null, null, 2); Console.WriteLine(tree.FindLCS(2, 100)); //Stack<int> path = new Stack<int>(); //bool hasItem = tree.FindPath(tree.Root, path, 2); //Console.WriteLine(hasItem + string.Join(",", path.ToArray())); Console.ReadLine(); }
public void GetDeepFirstOrder_ShouldReturnExpectedList() { //Arrange var sut = new BinaryTree(1); var root = sut.GetRoot(); var node2 = sut.AddLeftChild(2, root); var node3 = sut.AddRightChild(3, root); var node4 = sut.AddLeftChild(4, node2); var node5 = sut.AddRightChild(5, node3); var node6 = sut.AddLeftChild(6, node4); var node7 = sut.AddRightChild(7, node4); var node8 = sut.AddRightChild(8, node5); var node9 = sut.AddLeftChild(9, node8); var node10 = sut.AddRightChild(10, node8); var controlList = new List<int> { 1, 2, 4, 6, 7, 3, 5, 8, 9, 10 }; //Act var resultsList = new List<int>(); resultsList = sut.GetDeepFirstOrder(resultsList, root); //Assert CollectionAssert.AreEqual(controlList, resultsList); }
static void Main(string[] args) { BinaryTree<int> tree = new BinaryTree<int>(); tree.Insert(2); tree.Insert(3); tree.Insert(5); tree.Insert(8); tree.Insert(11); tree.Insert(200); tree.Insert(120); tree.Insert(600); Console.WriteLine(tree); Console.WriteLine(tree.Count); tree.Remove(2); tree.Remove(5); tree.Remove(8); Console.WriteLine(tree); tree.Remove(11); tree.Remove(200); tree.Remove(120); tree.Remove(600); tree.Remove(3); Console.WriteLine(tree); Console.WriteLine(tree.Count); tree.Insert(10); tree.Insert(20); tree.Insert(30); tree.Insert(60); tree.Insert(1); tree.Insert(500); tree.Insert(2); Console.WriteLine(tree); Console.WriteLine(tree.Count); var newTree = new BinaryTree<int>(); newTree.Insert(10); newTree.Insert(20); newTree.Insert(30); newTree.Insert(60); newTree.Insert(1); newTree.Insert(500); newTree.Insert(2); Console.WriteLine(newTree); Console.WriteLine(newTree.Count); Console.WriteLine(tree.Equals(newTree)); foreach (var value in tree) { Console.WriteLine(value); } BinaryTree<int> r = null; Console.WriteLine(tree.Equals(r)); int a = 5; Console.WriteLine(a.Equals(null)); }
public ActionResult CargaManualPais(Pais pais) { ABBPais = (BinaryTree <Pais>)Session["ABBPais"]; ABBPais.Insert(pais); return(View()); }
public ActionResult LecturaArchivo(HttpPostedFileBase File) { if (File == null || File.ContentLength == 0) { ViewBag.Error = "El archivo seleccionado está vacío o no hay archivo seleccionado"; return(View("Index")); } else { if (!isValidContentType(File)) { ViewBag.Error = "Solo archivos Json son válidos para la entrada"; return(View("Index")); } if (File.ContentLength > 0) { var fileName = Path.GetFileName(File.FileName); var path = Path.Combine(Server.MapPath("~/Content/JsonFiles/" + fileName)); if (System.IO.File.Exists(path)) { System.IO.File.Delete(path); } File.SaveAs(path); using (StreamReader reader = new StreamReader(path)) { //Seleccion de tipo de lista utilizar opciones = (bool[])Session["Opcion"]; ABBCadena = (BinaryTree <string>)Session["ABBCadena"]; ABBint = (BinaryTree <int>)Session["ABBint"]; ABBPais = (BinaryTree <Pais>)Session["ABBPais"]; //Realizar if donde dependiendo el booleano es la lista que se va a seleccionar if (opciones[0] == true) // arbol de cadenas { string info = reader.ReadToEnd(); List <string> lista = JsonConvert.DeserializeObject <List <string> >(info); for (int i = 0; i < lista.Count; i++) { ABBCadena.Insert(lista.ElementAt(i).ToString()); } Session["ABBCadena"] = ABBCadena; } else if (opciones[1] == true) //Arbol de enteros { string info = reader.ReadToEnd(); List <int> lista = JsonConvert.DeserializeObject <List <int> >(info); for (int i = 0; i < lista.Count; i++) { ABBint.Insert(Convert.ToInt32(lista.ElementAt(i))); } Session["ABBint"] = ABBint; } else if (opciones[2] == true) //Arbol de paises { string info = reader.ReadToEnd(); List <Pais> lista = JsonConvert.DeserializeObject <List <Pais> >(info); for (int i = 0; i < lista.Count; i++) { Pais newPais = new Pais() { NombrePais = lista.ElementAt(i).NombrePais, Grupo = lista.ElementAt(i).Grupo }; ABBPais.Insert(newPais); } BinTree.Nodo <Pais> nodoDesbalanceado = ABBPais.DegeneratedOrBalanced(ABBPais.cabeza); } // no es ninguno de los 2 else { return(RedirectToRoute("Paises/Index")); } } } } if (opciones[0] == true) { ABBCadena = (BinaryTree <string>)Session["ABBCadena"]; List <Nodo <string> > inOrder = ABBCadena.InOrder(ABBCadena.cabeza); Session["ABBPais"] = ABBPais; return(View("StringSuccess", inOrder)); } else if (opciones[1] == true) { ABBint = (BinaryTree <int>)Session["ABBint"]; List <Nodo <int> > inOrder = ABBint.InOrder(ABBint.cabeza); Session["ABBPais"] = ABBPais; return(View("IntSuccess", inOrder)); } else if (opciones[2] == true) { ABBPais = (BinaryTree <Pais>)Session["ABBPais"]; List <Nodo <Pais> > inOrder = ABBPais.InOrder(ABBPais.cabeza); Session["ABBPais"] = ABBPais; return(View("TreeSuccess", inOrder)); } else { return(View("Index")); } }
public void Setup() { _filePath = @"..\..\..\..\EPAM_Task5\Task1\BinaryTree\BinaryTree.xml"; var studentTests = new List <Student> { new Student { StudentName = "aaa", Test = "bbb", Date = new DateTime(2012, 10, 23), Score = 87 }, new Student { StudentName = "aaa", Test = "bbb", Date = new DateTime(2012, 10, 23), Score = 45 }, new Student { StudentName = "aaa", Test = "bbb", Date = new DateTime(2012, 10, 23), Score = 13 }, new Student { StudentName = "aaa", Test = "bbb", Date = new DateTime(2012, 10, 23), Score = 92 }, new Student { StudentName = "aaa", Test = "bbb", Date = new DateTime(2012, 10, 23), Score = 33 }, }; _binaryTree = new BinaryTree <Student>(studentTests); _xmlFileContent = "<?xml version=\"1.0\"?>\r\n" + "<ArrayOfStudent xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\r\n" + " <Student>\r\n" + " <StudentName>aaa</StudentName>\r\n" + " <Test>bbb</Test>\r\n" + " <Date>2012-10-23T00:00:00</Date>\r\n" + " <Score>87</Score>\r\n" + " </Student>\r\n" + " <Student>\r\n" + " <StudentName>aaa</StudentName>\r\n" + " <Test>bbb</Test>\r\n" + " <Date>2012-10-23T00:00:00</Date>\r\n" + " <Score>45</Score>\r\n" + " </Student>\r\n" + " <Student>\r\n" + " <StudentName>aaa</StudentName>\r\n" + " <Test>bbb</Test>\r\n" + " <Date>2012-10-23T00:00:00</Date>\r\n" + " <Score>13</Score>\r\n" + " </Student>\r\n" + " <Student>\r\n" + " <StudentName>aaa</StudentName>\r\n" + " <Test>bbb</Test>\r\n" + " <Date>2012-10-23T00:00:00</Date>\r\n" + " <Score>33</Score>\r\n" + " </Student>\r\n" + " <Student>\r\n" + " <StudentName>aaa</StudentName>\r\n" + " <Test>bbb</Test>\r\n" + " <Date>2012-10-23T00:00:00</Date>\r\n" + " <Score>92</Score>\r\n" + " </Student>\r\n" + "</ArrayOfStudent>"; }
private void CalculateMinimumDistance(NodeGraphDTO evaluationNode, double edgeWeigh, NodeGraphDTO sourceNode, BinaryTree unsettledTree) { double sourceDistance = sourceNode.CurrentDistance; if (sourceDistance + edgeWeigh < evaluationNode.CurrentDistance) { if (evaluationNode.Unsettled) { evaluationNode.Unsettled = false; unsettledTree.Remove(evaluationNode); } evaluationNode.CurrentDistance = sourceDistance + edgeWeigh; evaluationNode.PreviousNode = sourceNode; if (!evaluationNode.Unsettled) { unsettledTree.Add(evaluationNode); evaluationNode.Unsettled = true; } } }
private Branch SearchValue(int key, out BinaryTree <int?, SelfOrganizeIndexNode> upper, out BinaryTree <int?, SelfOrganizeIndexNode> value) { var p = _tree; BinaryTree <int?, SelfOrganizeIndexNode> parent = null; var res = Branch.Root; if (p.Key == null) { throw new Exception("Деревце-то пустое!"); } while (true) { if (key < p.Key()) { if (p.LLink() != null) { parent = p; p = p.LLink(); res = Branch.Left; continue; } else { break; } } if (key > p.Key()) { if (p.RLink() != null) { parent = p; p = p.RLink(); res = Branch.Right; continue; } else { break; } } if (key == p.Key()) { upper = parent; value = p; return(res); } } throw new Exception("Значение " + key + " не найдено!"); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); BinaryTree <int> tree = new BinaryTree <int>(); }
public BinaryTree(T value, BinaryTree <T> leftChild = null, BinaryTree <T> rightChild = null) { this.Value = value; this.LeftChild = leftChild; this.RightChild = rightChild; }
private void CalculateMinimumDistance(NodeGraphDTO evaluationNode, double edgeWeigh, NodeGraphDTO sourceNode, NodeGraphDTO endNode, BinaryTree unsettledTree) { double sourceDistance = sourceNode.CurrentDistance; if (sourceDistance + edgeWeigh < evaluationNode.CurrentDistance) { if (evaluationNode.Unsettled) { evaluationNode.Unsettled = false; unsettledTree.Remove(evaluationNode); } evaluationNode.CurrentDistance = sourceDistance + edgeWeigh; evaluationNode.EstimateDistanceToEnd = Utils.Distance(evaluationNode.Node, endNode.Node); evaluationNode.FScore = evaluationNode.CurrentDistance + evaluationNode.EstimateDistanceToEnd; evaluationNode.PreviousNode = sourceNode; } }
public BinaryTree(int value) { Value = value; Left = null; Right = null; }
public void LocateControls(Form form, ConsoleHandler console) { form.Text = "Задание № 2"; form.SetDefaultVals(new System.Drawing.Size(800, 500)); var tmpbutt = BeautyfyForms.AddButton("Очистить дерево", new Point(0, 10), (o, k) => { _tree = new BinaryTree <int?, SelfOrganizeIndexNode>(null, default(SelfOrganizeIndexNode)); treeViewer.Clear(); }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); form.Controls.Add(BeautyfyForms.AddButton(" Суть ", new Point(200, 10), (o, k) => { MessageBox.Show("Задача № 2. Параграф 6.2.2, алгоритм D (удаление узла дерева)"); })); tmpbutt = BeautyfyForms.AddButton("Сгенерировать дерево (N элементное)", new Point(0, 40), (o, k) => { if (string.IsNullOrEmpty(_randomInput.Text)) { MessageBox.Show("Введите кол-во элементов для добавления"); return; } if (string.IsNullOrEmpty(_randomMin.Text)) { MessageBox.Show("Введите минимальное число"); return; } if (string.IsNullOrEmpty(_randomMax.Text)) { MessageBox.Show("Введите максимальное число"); return; } int min = 0, max = 0; try { min = int.Parse(_randomMin.Text); max = int.Parse(_randomMax.Text); } catch { MessageBox.Show("Пределы не валидны"); return; } var text = _randomInput.Text; int res; if (int.TryParse(text, out res)) { if (Math.Abs(min - max) < res) { MessageBox.Show("Cлющай, став нармалные пределы, окда?"); return; } _buttonsToHide.ForEach(x => x.Enabled = false); _timerProgress.Start(); treeViewer.Clear(); Task.Run(() => { _tree = new BinaryTree <int?, SelfOrganizeIndexNode>(null, default(SelfOrganizeIndexNode)); GenerateRandomTree(res, min, max); }).ContinueWith(result => { treeViewer.BeginInvoke(new MethodInvoker(() => treeViewer.Text = (_tree != null) ? _tree.getTreeView(_addXToEnd.Checked) : "")); }); _buttonsToHide.ForEach(x => x.Enabled = true); _timerProgress.Stop(); _progress.Value = _progress.Maximum; MessageBox.Show("Сгенерили!"); } else { MessageBox.Show("Это было не число, да?.."); return; } }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); tmpbutt = BeautyfyForms.AddButton("Удалить значение", new Point(0, 70), (o, k) => { if (string.IsNullOrEmpty(_singleInput.Text)) { MessageBox.Show("Нет текста для поиска"); return; } var text = _singleInput.Text; int res; if (int.TryParse(text, out res)) { //RemoveNode(res); RemoveNodeRewritten(res); if (_tree == null) { _tree = new BinaryTree <int?, SelfOrganizeIndexNode>(null, default(SelfOrganizeIndexNode)); } //funny but let`s skip this~ treeViewer.Text = (_tree != null) ? _tree.getTreeView(_addXToEnd.Checked) : ""; } else { MessageBox.Show("Это было не число, да?.."); return; } }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); tmpbutt = BeautyfyForms.AddButton("Отобразить деревце", new Point(0, 100), (o, k) => { treeViewer.Text = (_tree != null) ? _tree.getTreeView(_addXToEnd.Checked) : ""; }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); tmpbutt = BeautyfyForms.AddButton(" Импорт ", new Point(0, 140), (o, k) => { var keys = new List <int>(); Helper.LoadFile("Список ключей", "keylst", keys); foreach (var key in keys) { AddNewValue(key, default(SelfOrganizeIndexNode)); } treeViewer.Text = (_tree != null) ? _tree.getTreeView(_addXToEnd.Checked) : ""; }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); tmpbutt = BeautyfyForms.AddButton(" Экспорт ", new Point(80, 140), (o, k) => { SaveFileDialog saveFile = new SaveFileDialog(); saveFile.Filter = string.Format("{0} (*.{1})|*.{1}", "Бинарное деревце", "btree"); if (saveFile.ShowDialog() == DialogResult.OK) { _buttonsToHide.ForEach(x => x.Enabled = false); _timerProgress.Start(); Task.Run(() => { System.IO.File.WriteAllText(saveFile.FileName, _tree.getTreeView(_addXToEnd.Checked, false)); }); _buttonsToHide.ForEach(x => x.Enabled = true); _timerProgress.Stop(); _progress.Value = _progress.Maximum; MessageBox.Show("Сохранено!"); } }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); tmpbutt = BeautyfyForms.AddButton(" Импорт .index ", new Point(160, 140), async(o, k) => { OpenFileDialog openDic = new OpenFileDialog(); openDic.Multiselect = false; openDic.Filter = string.Format("{0} (*.{1})|*.{1}", "Index файл", "index"); if (openDic.ShowDialog() == DialogResult.OK) { _buttonsToHide.ForEach(x => x.Enabled = false); var openedFile = System.IO.Path.ChangeExtension(openDic.FileName, null); var indexFile = openedFile + ".index"; var baseFile = openedFile + ".base"; _timerProgress.Start(); var state = await Task.Run(() => LoadIndexFile(indexFile, baseFile)); if (state != false) { MessageBox.Show("Готово! Дерево загружено."); } else { MessageBox.Show("Ошибка загрузки дерева."); return; } _timerProgress.Stop(); _progress.Value = _progress.Maximum; _buttonsToHide.ForEach(x => x.Enabled = true); } }); _buttonsToHide.Add(tmpbutt); form.Controls.Add(tmpbutt); _progress = BeautyfyForms.AddProgressBar(new Point(300, 140), form.Size, 0, 10); form.Controls.Add(_progress); _timerProgress = BeautyfyForms.CreateTimer((sender, EventArgs) => { if (_progress.Value >= _progress.Maximum) { _progress.Value = 0; } else { _progress.Value = _progress.Value + 1; } }); _randomInput = BeautyfyForms.CreateTextBox(new Point(290, 43), false); _randomInput.Text = "20"; form.Controls.Add(_randomInput); _randomMin = BeautyfyForms.CreateTextBox(new Point(400, 43), false); _randomMin.Text = "1"; form.Controls.Add(_randomMin); _randomMax = BeautyfyForms.CreateTextBox(new Point(510, 43), false); _randomMax.Text = "100"; form.Controls.Add(_randomMax); _singleInput = BeautyfyForms.CreateTextBox(new Point(150, 73), false); form.Controls.Add(_singleInput); treeViewer = BeautyfyForms.CreateMLTextBox(new Point(5, 250 + 5), 780, 200); form.Controls.Add(treeViewer); form.Controls.Add(BeautyfyForms.CreateLabel(new Point(150, 105), "Добавлять Х в качестве null-ветвей", true, 190)); form.Controls.Add(BeautyfyForms.CreateLabel(new Point(330, 20), "N", true, 10)); form.Controls.Add(BeautyfyForms.CreateLabel(new Point(430, 20), "Min", true, 25)); form.Controls.Add(BeautyfyForms.CreateLabel(new Point(540, 20), "Max", true, 30)); _addXToEnd = BeautyfyForms.CreateCheckBox(new Point(340, 100), false); form.Controls.Add(_addXToEnd); }
public void TreeWithNoNode() { BinaryTree bt = new BinaryTree(); Assert.Equal("", Program.BreadthFirst(bt)); }
static public void Main(String[] args) { BinaryTree tree = new BinaryTree(); tree.root = new Node(10); tree.root.left = new Node(2); tree.root.right = new Node(13); tree.root.left.left = new Node(1); tree.root.left.right = new Node(15); tree.root.right.left = new Node(11); tree.root.right.right = new Node(25); Console.WriteLine("Preorder traversal "); tree.printPreorder(tree.root); /* * Console.WriteLine("\n-----------------"); * if (tree.isBST(tree.root, 0, 20)) * Console.WriteLine("The tree is BST"); * else * Console.WriteLine("The tree not is BST"); */ //Console.WriteLine ("\nInorder traversal "); //tree.printInorder (tree.root); //Console.WriteLine ("\nPostorder traversal "); //tree.printPostorder (tree.root); //-------------iterative------searching---- Console.WriteLine("\n-------------------"); int key = 5; Console.WriteLine("I am looking for " + key); Console.WriteLine(tree.search(tree.root, key)); key = 11; Console.WriteLine("I am looking for " + key); Console.WriteLine(tree.search(tree.root, key)); key = 12; Console.WriteLine("I am looking for " + key); Console.WriteLine(tree.search(tree.root, key)); //-------------recursive------searching----- key = 17; Console.WriteLine("I am looking for " + key); Node what = tree.searchRec(tree.root, key); if (what != null) { Console.WriteLine("I found " + what.data); } else { Console.WriteLine("I didn't find " + key); } Console.WriteLine("The min is: " + tree.getMin(tree.root)); Console.WriteLine("The max is: " + tree.getMax(tree.root)); }
private NodeGraphDTO GetLowestDistanceNode(BinaryTree unsettledTree) { return(unsettledTree.GetMin()); }
public Files_Task2_2() { _subSystemType = Helpers.TaskAppType.GUI; _tree = new BinaryTree <int?, SelfOrganizeIndexNode>(null, default(SelfOrganizeIndexNode)); random = new Random(); }
public void CheckThatZeroIsReturnedWithEmptyTree() { BinaryTree binaryTree = new BinaryTree(new Node(0)); Assert.Equal(0, Program.FindMaximumValue(binaryTree)); }
public BinaryTree(int _data) { data = _data; left = null; right = null; }
public void WhenIFindElementAndElementNotExist() { tree.Add(5, "Иванов"); t2 = tree.Find(7); }
public BinaryTree(T value, BinaryTree <T> leftChild = null, BinaryTree <T> rightChild = null) { }
static void Main(string[] args) { //Create BinaryTree instance BinaryTree <Student> inst = new BinaryTree <Student>(); //Initialize Events inst.AddNode += Inst_AddNode; inst.RemoveNode += Inst_AddNode; //Test student instance Student testStudent = new Student() { Mark = 80 }; Random rand = new Random(); //First step Console.WriteLine("STEP-1-------------------\n"); //Initializing Tree by Students for (int i = 0; i < 10; i++) { int t = rand.Next(60, 100); inst.Add(new Student { Name = $"Vlad_{i}", Mark = rand.Next(60, 100) }); //Will be invoken event - inst.AddNode //Console.WriteLine($"Vlad_{i}----{t}\t"); } //Next step Console.WriteLine("STEP-2-------------------\n"); inst.Add(testStudent); Console.WriteLine($"The Tree contain this student? Answer is {inst.Contains(testStudent)}\n"); //true Console.WriteLine($"There are {inst.Count} in the tree"); //11 inst.Remove(testStudent); Console.WriteLine($"The Tree contain this student? Answer is {inst.Contains(testStudent)}"); //false Console.WriteLine($"There are {inst.Count} in the tree"); //10 //Next step Console.WriteLine("STEP-3-------------------\n"); try { foreach (var element in inst) //Not implemented { } } catch (NotImplementedException) { Console.WriteLine("try-catch was succesfully work"); //will work } Console.WriteLine("STEP-4-------------------\n"); foreach (var element in inst.InOrderTraversal()) // Work right { Console.WriteLine(element.ToString()); } Console.WriteLine("STEP-5-------------------\n"); foreach (var element in inst.PreOrderTraversal()) // Work right { Console.WriteLine(element.ToString()); } Console.WriteLine("STEP-6-------------------\n"); Console.WriteLine($"There are {inst.Count} in the tree"); //10 inst.Clear(); Console.WriteLine($"There are {inst.Count} in the tree"); //0 Console.ReadKey(); }
public void CanInstantiateBT() { BinaryTree testTree = new BinaryTree(); Assert.IsType <BinaryTree>(testTree); }
public BinaryTree(int value, BinaryTree parent) { this.value = value; this.parent = parent; }
public static void Main(string[] args) { System.Console.WriteLine("LinkList Sample"); SinglyLinkedList <int> primeNumbers = new SinglyLinkedList <int>(); // first we'll add the middle element. Then try the AddToFront with 3 and then try the AddToBack with 7 // generating the final sequence as 3, 5, 7 primeNumbers.AddToFront(5); primeNumbers.AddToFront(3); primeNumbers.AddToBack(7); primeNumbers.AddToBack(9); primeNumbers.AddToBack(8); primeNumbers.AddToBack(7); primeNumbers.Remove(8); primeNumbers.RemoveLast(); PrintHelpers.PrintFromNode(primeNumbers.Head); System.Console.WriteLine("Stack Sample: "); PostfixCalculator postfixCalculator = new PostfixCalculator(); int result = postfixCalculator.calculate("5 6 7 * + 1 -"); System.Console.WriteLine($"The postfix expression result is: {result}"); System.Console.WriteLine("Binary Search Tree Sample:"); BinaryTree <int> binaryTree = new BinaryTree <int>(); binaryTree.Add(3); binaryTree.Add(7); binaryTree.Add(5); binaryTree.Add(4); binaryTree.Add(6); binaryTree.Add(8); binaryTree.Add(11); binaryTree.Add(1); System.Console.WriteLine($"Contains 5: {binaryTree.Contains(5)}"); System.Console.WriteLine($"Contains 6: {binaryTree.Contains(6)}"); System.Console.WriteLine($"Contains 1: {binaryTree.Contains(1)}"); System.Console.WriteLine($"Remove 9 op result: {binaryTree.Remove(9)}"); System.Console.WriteLine($"Remove 7 op result: {binaryTree.Remove(7)}"); System.Console.WriteLine("Traversal Outputs:"); Traversals <int> traversals = new Traversals <int>(); IReadOnlyCollection <int> preOrder = traversals.PreorderTraversal(binaryTree); IReadOnlyCollection <int> inOrder = traversals.InorderTraversal(binaryTree); IReadOnlyCollection <int> postOrder = traversals.PostorderTraversal(binaryTree); System.Console.WriteLine($"Postorder: {string.Join(", ", preOrder)}"); System.Console.WriteLine($"Inorder: {string.Join(", ", inOrder)}"); System.Console.WriteLine($"Postorder: {string.Join(", ", postOrder)}"); }
public VerticalSum(BinaryTree tree) { this.tree = tree; }
public static void TestTree() { const string testWord1 = "cat"; const string testWord2 = "remove me"; var text = System.IO.File.ReadAllText(@"C:\Users\thoma\source\repos\AlgorithmsAndDataStructures\AlgorithmsAndDataStructures\words.txt"); var words = text.Split('\n'); var shuffledWords = words.OrderBy(a => Guid.NewGuid()).ToList(); var wordList1 = shuffledWords.Take(shuffledWords.Count / 2).ToArray(); var wordList2 = shuffledWords.Skip(shuffledWords.Count / 2).ToArray(); var tree = new BinaryTree <string>(); var stopwatch = new Stopwatch(); Debug.WriteLine($"Inserting {wordList1.Length} words..."); stopwatch.Start(); tree.Add(wordList1); stopwatch.Stop(); Debug.WriteLine($"Completed after {stopwatch.ElapsedMilliseconds} ms"); Debug.WriteLine($"Inserting {wordList2.Length} words..."); stopwatch.Restart(); tree.Add(wordList2); stopwatch.Stop(); Debug.WriteLine($"Completed after {stopwatch.ElapsedMilliseconds} ms"); Debug.WriteLine($"Inserting {wordList2.Length} duplicate words..."); stopwatch.Restart(); tree.Add(wordList2); stopwatch.Stop(); Debug.WriteLine($"Completed after {stopwatch.ElapsedMilliseconds} ms"); Debug.WriteLine($"Inserting '{testWord1}'..."); stopwatch.Restart(); tree.Add(testWord1); tree.Add(testWord1); tree.Add(testWord1); tree.Add(testWord1); stopwatch.Stop(); Debug.WriteLine($"Completed after {stopwatch.ElapsedMilliseconds} ms"); Debug.WriteLine("\n\n----To List----\n"); Debug.WriteLine("InOrder count : " + tree.ToList(Traversal.InOrder).Count); Debug.WriteLine("InOrder (unique) count : " + tree.ToList(Traversal.InOrder, true).Count); Debug.WriteLine("\n\n----Statistics----\n"); Debug.WriteLine("Count: " + tree.Count); Debug.WriteLine("Unique count: " + tree.CountUnique); Debug.WriteLine("Balance: " + tree.Balance); Debug.WriteLine("Unique balance: " + tree.BalanceUnique); Debug.WriteLine($"Contains '{testWord1}'? {tree.Contains(testWord1)}"); Debug.WriteLine($"{testWord1}' count: {tree.CountItem(testWord1)}"); Debug.WriteLine($"Inserting '{testWord2}'..."); tree.Add(testWord2); Debug.WriteLine($"Contains '{testWord2}'? {tree.Contains(testWord2)}"); Debug.WriteLine($"Removing '{testWord2}'..."); tree.Remove(testWord2); Debug.WriteLine($"Contains '{testWord2}'? {tree.Contains(testWord2)}"); }
public void CanInstantiateAnEmptyTree() { BinaryTree tree = new BinaryTree(); Assert.Null(tree.Root); }
public BinaryTree(int value) { this.value = value; this.left = null; this.right = null; }
public void Test_DeserializeBinaryTree() { BinaryTree <Student> newBinaryTree = FileExtension.DeserializeTree(_filePath); Assert.AreEqual(newBinaryTree, _binaryTree); }
static void Main(string[] args) { Console.WriteLine("Задание №1" + "\r\n"); int[] MyArray = new int[10] { 1, 5, 8, 9, 34, 98, 23, 1, 45, 28 }; Console.Write("Исходный массив: "); for (int i = 0; i < 10; i++) { Console.Write(Convert.ToString(MyArray[i]) + " "); } //демонстрация бинарного поиска Console.WriteLine("\r\n" + "1.Нахождение индекса элемента 98 с помощью бинарного поиска: " + BinarySearch(MyArray, 98, 0, MyArray.Length).ToString()); //демонстрация поиска по бинарному дереву var binaryTree = new BinaryTree(); Random rand = new Random(); for (int i = 0; i < 9; i++) { binaryTree.Add(new BinaryTreeNode(rand.Next(0, 50))); } Console.WriteLine("\r\n" + "2.Бинарное дерево, поиск элемента и его удаление"); binaryTree.PrintTree(); Console.WriteLine("Добавим новый элемент"); binaryTree.Add(new BinaryTreeNode(66)); binaryTree.PrintTree(); Console.WriteLine("Удалим его"); binaryTree.Remove(66); binaryTree.PrintTree(); //демонстрация фиббоначиева поиска Console.WriteLine("\r\n" + "3.Фиббоначиев поиск" + "\r\n"); FibonacciNumber fib = Fibonacci.find(21); FibonacciNumber fib2 = new FibonacciNumber(8); Console.WriteLine("Индекс числа 21 = " + fib.Index); Console.WriteLine("Значение элемента с индексм 8 = " + fib2.Number); Console.WriteLine("\r\n" + "4.Интерпаляционный поиск" + "\r\n"); Console.Write("Исходный массив: "); for (int i = 0; i < 10; i++) { Console.Write(Convert.ToString(MyArray[i]) + " "); } Console.WriteLine("\r\n" + "Индекс числа 9 = " + InterpolationSearch(MyArray, 9)); Console.WriteLine("\r\n" + "Задание №2" + "\r\n"); Console.WriteLine("1.Поиск по map, в которой коллизии решаются простым рехэшированием"); Map <int, string> MyMap = new Map <int, string>(); MyMap.Add(new ItemMap <int, string>(1, "Один")); MyMap.Add(new ItemMap <int, string>(1, "Один")); MyMap.Add(new ItemMap <int, string>(2, "Два")); MyMap.Add(new ItemMap <int, string>(3, "Три")); MyMap.Add(new ItemMap <int, string>(4, "Четыре")); MyMap.Add(new ItemMap <int, string>(5, "Пять")); MyMap.Add(new ItemMap <int, string>(101, "Сто один")); Console.WriteLine("Исходная карта:"); foreach (var item in MyMap) { Console.WriteLine(item); } Console.WriteLine("\r\n" + "Ищем число c ключем 7 " + (MyMap.Search(7) ?? "Не найдено")); Console.WriteLine("Ищем число c ключем 101 " + (MyMap.Search(101) ?? "Не найдено")); MyMap.Remove(1); MyMap.Remove(101); Console.WriteLine("\r\n" + "Удалили 1 и 101 "); foreach (var item in MyMap) { Console.WriteLine(item); } Console.WriteLine("\r\n" + "2.Поиск по map, в которой коллизии решаются случайным рехэшированием"); Map <int, string> MyMap2 = new Map <int, string>(); MyMap2.Add(new ItemMap <int, string>(2, "Два")); MyMap2.Add(new ItemMap <int, string>(2, "Два")); MyMap2.Add(new ItemMap <int, string>(9, "Девять")); MyMap2.Add(new ItemMap <int, string>(3, "Три")); MyMap2.Add(new ItemMap <int, string>(4, "Четыре")); MyMap2.Add(new ItemMap <int, string>(5, "Пять")); MyMap2.Add(new ItemMap <int, string>(102, "Сто два")); Console.WriteLine("Исходная карта:"); foreach (var item in MyMap2) { Console.WriteLine(item); } Console.WriteLine("\r\n" + "Ищем число c ключем 7 " + (MyMap2.Search(7) ?? "Не найдено")); Console.WriteLine("Ищем число c ключем 102 " + (MyMap2.Search(102) ?? "Не найдено")); MyMap2.Remove(2); MyMap2.Remove(102); Console.WriteLine("\r\n" + "Удалили 2 и 102 "); foreach (var item in MyMap2) { Console.WriteLine(item); } Console.WriteLine("\r\n" + "3.Поиск по хэш таблице, в которой коллизии решаются методом цепочек"); Console.WriteLine("Исходная таблица:"); HashTable <int> MyHashTable = new HashTable <int>(5); MyHashTable.Add(2); MyHashTable.Add(24); MyHashTable.Add(65); MyHashTable.Add(8); MyHashTable.Add(51); MyHashTable.Add(61); MyHashTable.PrintHashTable(); Console.WriteLine("\r\n" + "Содержит ли хэш таблица число 42 " + MyHashTable.Search(42)); Console.WriteLine("Содержит ли хэш таблица число 8 " + MyHashTable.Search(8)); MyHashTable.Delate(24); MyHashTable.Delate(51); Console.WriteLine("\r\n" + "Удалили 24 и 51 "); MyHashTable.PrintHashTable(); Console.WriteLine("\r\n" + "Задание №3"); Console.WriteLine("Расстановка ферзей на поле : (ферзь = 1)" + "\r\n"); Chess MyChess = new Chess(); MyChess.Arrange(); Console.ReadLine(); }
public BinaryTree() { Value = 0; Left = null; Right = null; }
public void Remove_From_Empty() { BinaryTree <int> tree = new BinaryTree <int>(); tree.Remove(10).ShouldBeFalse(); }