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();
}
