public bool AddKeyValue(int key, T val) { if (Root == null) { Root = new BSTNode <T>(key, val, null); } else { BSTFind <T> foundNode = FindNodeByKey(key); if (foundNode.NodeHasKey == false) { BSTNode <T> newNode = new BSTNode <T>(key, val, foundNode.Node); if (foundNode.ToLeft) { foundNode.Node.LeftChild = newNode; newNode.Parent = foundNode.Node; } else { foundNode.Node.RightChild = newNode; newNode.Parent = foundNode.Node; } } else { return(false); } } return(true); }
public bool AddKeyValue(int key, T val) // добавляем ключ-значение в дерево, return false если ключ уже есть { if (Root == null) { Root = new BSTNode <T>(key, val, null); return(true); } BSTFind <T> bst_find = FindNodeByKey(key); if (bst_find.Node != null && !bst_find.NodeHasKey) { if (bst_find.ToLeft) { bst_find.Node.LeftChild = new BSTNode <T>(key, val, bst_find.Node); } else { bst_find.Node.RightChild = new BSTNode <T>(key, val, bst_find.Node); } return(true); } else if (bst_find.Node == null) { if (bst_find.ToLeft) { Root.LeftChild = new BSTNode <T>(key, val, Root); } else { Root.RightChild = new BSTNode <T>(key, val, Root); } return(true); } return(false); }
public bool AddKeyValue(int key, T val) { // добавляем ключ-значение в дерево, если корень не null if (Root != null) { BSTFind <T> foundNode = FindNodeByKey(key); if (!foundNode.NodeHasKey) { if (foundNode.ToLeft) { foundNode.Node.LeftChild = new BSTNode <T>(key, val, foundNode.Node); } else { foundNode.Node.RightChild = new BSTNode <T>(key, val, foundNode.Node); } return(true); } } else { Root = new BSTNode <T>(key, val, null); // создаем корень дерева } return(false); // если ключ уже есть }
private BSTFind <T> FindNodeByKey(int key, BSTNode <T> node, BSTFind <T> bst_find) { bst_find.Node = node; if (node.NodeKey > key) { if (node.LeftChild != null) { return(FindNodeByKey(key, node.LeftChild, bst_find)); } bst_find.ToLeft = true; return(bst_find); } else { if (node.NodeKey == key) { bst_find.NodeHasKey = true; } else if (node.RightChild != null) { return(FindNodeByKey(key, node.RightChild, bst_find)); } return(bst_find); } }
public bool AddKeyValue(int key, T val) { if (Root == null) { Root = new BSTNode <T>(key, val, null); return(true); } BSTFind <T> bst_find = FindNodeByKey(key); if (bst_find.Node != null && !bst_find.NodeHasKey) { if (bst_find.ToLeft) { bst_find.Node.LeftChild = new BSTNode <T>(key, val, bst_find.Node); } else { bst_find.Node.RightChild = new BSTNode <T>(key, val, bst_find.Node); } return(true); } else if (bst_find.Node == null) { if (bst_find.ToLeft) { Root.LeftChild = new BSTNode <T>(key, val, Root); } else { Root.RightChild = new BSTNode <T>(key, val, Root); } return(true); } return(false); }
public bool AddKeyValue(int key, T val) { // добавляем ключ-значение в дерево if (Root == null) { Root = new BSTNode <T>(key, val, null); } else { BSTFind <T> foundNode = FindNodeByKey(key); if (foundNode.NodeHasKey == false) { BSTNode <T> newNode = new BSTNode <T>(key, val, foundNode.Node); if (foundNode.ToLeft == true) { foundNode.Node.LeftChild = newNode; newNode.Parent = foundNode.Node; } else { foundNode.Node.RightChild = newNode; newNode.Parent = foundNode.Node; } } else { return(false); // если ключ уже есть } } return(true); }
public BSTFind <T> FindNodeByKey(int key) { // ищем в дереве узел и сопутствующую информацию по ключу if (Root == null) { return(null); } BSTNode <T> selectedNode = Root; BSTFind <T> newSearch = new BSTFind <T>(); while (newSearch.NodeHasKey == true || newSearch.NodeHasKey == false) { if (key == selectedNode.NodeKey) { newSearch.Node = selectedNode; newSearch.NodeHasKey = true; return(newSearch); } if (key < selectedNode.NodeKey) { if (selectedNode.LeftChild != null) { selectedNode = selectedNode.LeftChild; } else { newSearch.Node = selectedNode; newSearch.NodeHasKey = false; newSearch.ToLeft = true; return(newSearch); } } else { if (selectedNode.RightChild != null) { selectedNode = selectedNode.RightChild; } else { newSearch.Node = selectedNode; newSearch.NodeHasKey = false; newSearch.ToLeft = false; return(newSearch); } } } return(newSearch); }
public BSTFind <T> FindNodeByKey(int key) // find Node in tree with key { if (Root == null) { BSTFind <T> rezult = new BSTFind <T>(); rezult.Node = null; rezult.NodeHasKey = false; return(rezult); } else { if (Root.LeftChild == null && Root.RightChild == null) { if (key != Root.NodeKey) { if (key < Root.NodeKey) { BSTFind <T> node = new BSTFind <T>(); node.Node = null; node.NodeHasKey = false; node.ToLeft = true; return(node); } else { BSTFind <T> node = new BSTFind <T>(); node.Node = null; node.NodeHasKey = false; node.ToLeft = false; return(node); } } else { BSTFind <T> node = new BSTFind <T>(); node.Node = Root; node.NodeHasKey = true; node.ToLeft = false; return(node); } } else { BSTFind <T> node = Find(Root, key); return(node); } } }
public BSTFind <T> FindNodeByKey(int key) // ищем в дереве узел и сопутствующую информацию по ключу { if (Root != null) { BSTFind <T> bst_find = new BSTFind <T>(); if (Root.LeftChild != null || Root.RightChild != null) { return(FindNodeByKey(key, Root, bst_find)); } bst_find.Node = Root; bst_find.NodeHasKey = Root.NodeKey == key; bst_find.ToLeft = Root.NodeKey > key; return(bst_find); } return(null); }
public BSTFind <T> FindNodeByKey(int key) { if (Root != null) { BSTFind <T> bst_find = new BSTFind <T>(); if (Root.LeftChild != null || Root.RightChild != null) { return(FindNodeByKey(key, Root, bst_find)); } bst_find.Node = Root; bst_find.NodeHasKey = Root.NodeKey == key; bst_find.ToLeft = Root.NodeKey > key; return(bst_find); } return(null); }
public BSTFind <T> Find(BSTNode <T> node, int key) // find node by key { if (node.NodeKey == key) { BSTFind <T> rez = new BSTFind <T>(); rez.Node = node; rez.NodeHasKey = true; rez.ToLeft = false; return(rez); } else { if (key > node.NodeKey) { if (node.RightChild == null) { BSTFind <T> rez = new BSTFind <T>(); rez.Node = node; rez.NodeHasKey = false; rez.ToLeft = false; return(rez); } else { BSTFind <T> rez = Find(node.RightChild, key); return(rez); } } else { if (node.LeftChild == null) { BSTFind <T> rez = new BSTFind <T>(); rez.Node = node; rez.NodeHasKey = false; rez.ToLeft = true; return(rez); } else { BSTFind <T> rez = Find(node.LeftChild, key); return(rez); } } } }
public BSTNode <T> FinMinMax(BSTNode <T> FromNode, bool FindMax) // find min/max in tree from someNode { if (FromNode == null) { return(null); } else { BSTFind <T> node = FindNodeByKey(FromNode.NodeKey); if (node.Node == null) { return(Root); } else { if (FindMax) { if (FromNode.RightChild == null) { return(FromNode); } else { BSTNode <T> rez = FinMinMax(FromNode.RightChild, true); return(rez); } } else { if (FromNode.LeftChild == null) { return(FromNode); } else { BSTNode <T> rez = FinMinMax(FromNode.LeftChild, false); return(rez); } } } } }
public bool DeleteNodeByKey(int key) { BSTFind <T> bst_find = FindNodeByKey(key); if (bst_find.NodeHasKey) { if (bst_find.Node.Equals(Root)) { Root = null; } else { BSTNode <T> node = bst_find.Node; BSTNode <T> successor; if (node.RightChild != null) { successor = FindSuccessor(node.RightChild); RemoveBounds(successor); RebindChildren(node, successor); ReplaceChildWith(node, successor); } else if (node.LeftChild != null) { ReplaceChildWith(node, node.LeftChild); } else if (node.NodeKey < node.Parent.NodeKey) { node.Parent.LeftChild = null; } else { node.Parent.RightChild = null; } } return(true); } return(false); }
public bool DeleteNodeByKey(int key) // удаляем узел по ключу, return false если узел не найден { BSTFind <T> bst_find = FindNodeByKey(key); if (bst_find.NodeHasKey) { if (bst_find.Node.Equals(Root)) { Root = null; } else { BSTNode <T> node = bst_find.Node; BSTNode <T> inheritor; if (node.RightChild != null) { inheritor = Find(node.RightChild); Remove(inheritor); RebindChild(node, inheritor); ReplaceNode(node, inheritor); } else if (node.LeftChild != null) { ReplaceNode(node, node.LeftChild); } else if (node.NodeKey < node.Parent.NodeKey) { node.Parent.LeftChild = null; } else { node.Parent.RightChild = null; } } return(true); } return(false); }
public bool AddKeyValue(int key, T val) { // добавляем ключ-значение в дерево BSTNode <T> Node = Root; BSTFind <T> FindNode = FindNodeByKey(key); if (FindNode.Node != null) { if (FindNode.NodeHasKey == false) { if (FindNode.ToLeft == true) { FindNode.Node.LeftChild = new BSTNode <T>(key, val, FindNode.Node); return(true); } else { FindNode.Node.RightChild = new BSTNode <T>(key, val, FindNode.Node); return(true); } } } return(false); }
public bool AddKeyValue(int key, T val) // add key to tree { if (Root == null) { BSTNode <T> node = new BSTNode <T>(key, val, null); Root = node; amount++; return(true); } else { BSTFind <T> node = FindNodeByKey(key); if (node.NodeHasKey) { return(false); } else { Add(Root, key, val); amount++; return(true); } } }
public bool DeleteNodeByKey(int key) { // удаляем узел по ключу BSTFind <T> foundNode = FindNodeByKey(key); if (foundNode.NodeHasKey) { // удаляемый узел не имеет потомков if (foundNode.Node.LeftChild == null && foundNode.Node.RightChild == null) { if (foundNode.Node.Parent.LeftChild != null && foundNode.Node.Parent.LeftChild.Equals(foundNode.Node)) { foundNode.Node.Parent.LeftChild = null; } else if (foundNode.Node.Parent.RightChild != null && foundNode.Node.Parent.RightChild.Equals(foundNode.Node)) { foundNode.Node.Parent.RightChild = null; } } // удаляемый узел имеет только одного потомка else if (foundNode.Node.LeftChild == null ^ foundNode.Node.RightChild == null) { if (foundNode.Node.LeftChild != null) // левый потомок привязываем к родителю удаленного узла { if (foundNode.Node.Parent.LeftChild != null && foundNode.Node.Parent.LeftChild.Equals(foundNode.Node)) { foundNode.Node.Parent.LeftChild = foundNode.Node.LeftChild; } else { foundNode.Node.Parent.RightChild = foundNode.Node.LeftChild; } foundNode.Node.LeftChild.Parent = foundNode.Node.Parent; } else // правый потомок привязываем к родителю удаленного узла { if (foundNode.Node.Parent.LeftChild != null && foundNode.Node.Parent.LeftChild.Equals(foundNode.Node)) { foundNode.Node.Parent.LeftChild = foundNode.Node.RightChild; } else { foundNode.Node.Parent.RightChild = foundNode.Node.RightChild; } foundNode.Node.RightChild.Parent = foundNode.Node.Parent; } } // удаляемый узел имеет двух потомков else { BSTNode <T> successorNode = FinMinMax(foundNode.Node.RightChild, false); // наименьший потомок, который больше удаляемого узла if (successorNode.RightChild != null) // если наименьший потомок не является листом { successorNode.Parent.LeftChild = successorNode.RightChild; // передаем его правого потомка левым узлом родителю successorNode.RightChild.Parent = successorNode.Parent; // правому потомку назначаем родителя } else { if (successorNode.Parent.LeftChild == successorNode) { successorNode.Parent.LeftChild = null; // удаляем левый лист } else { successorNode.Parent.RightChild = null; // удаляем правый лист } } // преемник замещает удаленный узел if (foundNode.Node.Parent.RightChild == foundNode.Node) { foundNode.Node.Parent.RightChild = successorNode; } else { foundNode.Node.Parent.LeftChild = successorNode; } successorNode.Parent = foundNode.Node.Parent; // новый родитель для узла-преемника successorNode.LeftChild = foundNode.Node.LeftChild; // левый потомок удаленного узла становится потомком узла-преемника successorNode.RightChild = foundNode.Node.RightChild; // правый потомок удаленного узла становится потомком узла-преемника // связать потомков удаленного узла с новым родителем if (foundNode.Node.RightChild != null) { foundNode.Node.RightChild.Parent = successorNode; } if (foundNode.Node.LeftChild != null) { foundNode.Node.LeftChild.Parent = successorNode; } } return(true); } return(false); // если узел не найден }
public bool DeleteNodeByKey(int key) { // удаляем узел по ключу BSTFind <T> foundNode = FindNodeByKey(key); BSTNode <T> Node = foundNode.Node; BSTNode <T> successorNode; if (foundNode.NodeHasKey == true) { if (Node.LeftChild != null && Node.RightChild != null) // CASE (node has R & L children) { if (Node == Root) { successorNode = FinMinMax(Node.RightChild, false); // searching for a successor if (GetAllNodes(successorNode).Count == 1) // if successor have 0 children { Node.RightChild.Parent = null; Node.LeftChild.Parent = successorNode; successorNode.LeftChild = Node.LeftChild; Root = Node.RightChild; } else { if (successorNode != Node.RightChild) { successorNode.Parent.LeftChild = null; successorNode.Parent = null; Root.LeftChild.Parent = successorNode; successorNode.LeftChild = Root.LeftChild; Root.RightChild.Parent = successorNode; successorNode.RightChild = Root.RightChild; Root = successorNode; } else { Root.LeftChild.Parent = successorNode; successorNode.LeftChild = Root.LeftChild; Root.RightChild.Parent = null; Root = successorNode; } } } else { successorNode = FinMinMax(Node.RightChild, false); // searching for a successor if (successorNode != Node.RightChild) { successorNode.Parent.LeftChild = null; successorNode.Parent = Node.Parent; if (Node.Parent.LeftChild == Node) { Node.Parent.LeftChild = successorNode; } else { Node.Parent.RightChild = successorNode; } if (Node.LeftChild != null) { Node.LeftChild.Parent = successorNode; successorNode.LeftChild = Node.LeftChild; } if (Node.RightChild != null) { Node.RightChild.Parent = successorNode; successorNode.RightChild = Node.RightChild; } } else { successorNode.Parent = Node.Parent; if (Node.Parent.LeftChild == Node) { Node.Parent.LeftChild = successorNode; } else { Node.Parent.RightChild = successorNode; } successorNode.LeftChild = Node.LeftChild; Node.LeftChild.Parent = successorNode; } } } else // CASE (node has R/L || 0 children) { if (Node == Root) { if (GetAllNodes(Root).Count == 1) // CASE (node = root && has 0 children) { Root = null; } else // CASE (node = root && has 1 child) { if (Node.LeftChild != null) { Node.LeftChild.Parent = null; Root = Node.LeftChild; } else { Node.RightChild.Parent = null; Root = Node.RightChild; } } } else // CASE (node has 1 child) { if (Node.LeftChild == null && Node.RightChild == null) { if (Node.Parent.LeftChild == Node) { Node.Parent.LeftChild = null; } else { Node.Parent.RightChild = null; } Node.Parent = null; } else if (Node.LeftChild != null) { Node.LeftChild.Parent = Node.Parent; if (Node.Parent.LeftChild == Node) { Node.Parent.LeftChild = Node.LeftChild; } else { Node.Parent.RightChild = Node.RightChild; } } else { Node.RightChild.Parent = Node.Parent; if (Node.Parent.LeftChild == Node) { Node.Parent.LeftChild = Node.LeftChild; } else { Node.Parent.RightChild = Node.RightChild; } } } } return(true); } else { return(false); } }
public BSTFind <T> FindNodeByKey(int key) { // ищем в дереве узел и сопутствующую информацию по ключу BSTFind <T> found = new BSTFind <T>(); BSTNode <T> Node = Root; if (Node.NodeKey == key && Node.LeftChild == null && Node.RightChild == null) { found.Node = null; found.NodeHasKey = true; } else { if (Node.LeftChild == null && Node.RightChild == null) { if (key > Node.NodeKey) { found.Node = Node; found.NodeHasKey = false; found.ToLeft = false; } else { found.Node = Node; found.NodeHasKey = false; found.ToLeft = true; } return(found); } while (Node.LeftChild != null || Node.RightChild != null) { if (Node.LeftChild != null && Node.RightChild != null) { if (key == Node.NodeKey) { found.Node = Node; found.NodeHasKey = true; break; } else if (key > Node.NodeKey) { Node = Node.RightChild; } else { Node = Node.LeftChild; } } else if (Node.LeftChild != null && Node.RightChild == null) { if (key == Node.NodeKey) { found.Node = Node; found.NodeHasKey = true; return(found); } else if (key > Node.NodeKey) { found.Node = Node; found.NodeHasKey = false; found.ToLeft = false; return(found); } else { Node = Node.LeftChild; } } else if (Node.LeftChild == null && Node.RightChild != null) { if (key == Node.NodeKey) { found.Node = Node; found.NodeHasKey = true; return(found); } else if (key > Node.NodeKey) { Node = Node.RightChild; } else { found.Node = Node; found.NodeHasKey = false; found.ToLeft = true; return(found); } } } if (Node.LeftChild == null && Node.RightChild == null) { if (key > Node.NodeKey) { found.Node = Node; found.NodeHasKey = false; found.ToLeft = false; } else { found.Node = Node; found.NodeHasKey = false; found.ToLeft = true; } return(found); } else if (Node.LeftChild != null && Node.RightChild == null) { if (key == Node.NodeKey) { found.Node = Node; found.NodeHasKey = true; } else if (key > Node.NodeKey) { found.Node = Node; found.NodeHasKey = false; found.ToLeft = false; } } else if (Node.LeftChild == null && Node.RightChild != null) { if (key == Node.NodeKey) { found.Node = Node; found.NodeHasKey = true; } else if (key > Node.NodeKey) { } else { found.Node = Node; found.NodeHasKey = false; found.ToLeft = true; } } } return(found); }
public bool DeleteNodeByKey(int key) // delete Node from tree { BSTFind <T> findnode = FindNodeByKey(key); if (!findnode.NodeHasKey) { return(false); } else { if (findnode.Node.LeftChild == null && findnode.Node.RightChild == null) // когда лист { if (findnode.Node.Parent == null) { findnode.Node = null; Root = null; amount--; return(true); } else { if (findnode.Node.NodeKey < findnode.Node.Parent.NodeKey) { findnode.Node.Parent.LeftChild = null; amount--; return(true); } else { findnode.Node.Parent.RightChild = null; amount--; return(true); } } } else { if (findnode.Node.LeftChild == null && findnode.Node.RightChild != null) // когда только правый потомок { if (findnode.Node.Parent == null) { Root = Root.RightChild; amount--; return(true); } else { if (findnode.Node.NodeKey < findnode.Node.Parent.NodeKey) { findnode.Node.RightChild.Parent = findnode.Node.Parent; findnode.Node.Parent.LeftChild = findnode.Node.RightChild; amount--; return(true); } else { findnode.Node.RightChild.Parent = findnode.Node.Parent; findnode.Node.Parent.RightChild = findnode.Node.RightChild; amount--; return(true); } } } else { if (findnode.Node.LeftChild != null && findnode.Node.RightChild == null) { if (findnode.Node.Parent == null) { Root = Root.LeftChild; amount--; return(true); } else { if (findnode.Node.NodeKey < findnode.Node.Parent.NodeKey) { findnode.Node.LeftChild.Parent = findnode.Node.Parent; findnode.Node.Parent.LeftChild = findnode.Node.LeftChild; amount--; return(true); } else { findnode.Node.LeftChild.Parent = findnode.Node.Parent; findnode.Node.Parent.RightChild = findnode.Node.LeftChild; amount--; return(true); } } } else // when both children are not null { BSTNode <T> replace = leftTravel(findnode.Node.RightChild); if (findnode.Node.Parent == null) { Root = replace; amount--; return(true); } else { if (findnode.Node.NodeKey < findnode.Node.Parent.NodeKey) { replace.Parent = findnode.Node.Parent; findnode.Node.Parent.LeftChild = replace; amount--; return(true); } else { replace.Parent = findnode.Node.Parent; findnode.Node.Parent.RightChild = replace; amount--; return(true); } } } } } } }