public void Insert (int i) { Node newNode = new Node (); newNode.Data = i; if (root == null) root = newNode; else { Node current = root; Node parent; while (true) { parent = current; if (i < current.Data) { current = current.Left; if (current == null) { parent.Left = newNode; break; } } else { current = current.Right; if (current == null) { parent.Right = newNode; break; } } } } }
/// <summary> /// Balanse binary tree. /// </summary> /// <param name="node">Node.</param> public void Balanse(ref Node node) { if (node == null) throw new ArgumentNullException("Node"); if (node._right != null) Balanse(ref node._right); if (node._left != null) Balanse(ref node._left); int b_factor = balance_factor(node); if (b_factor > 1) { if (balance_factor(node._left) > 0) { node = RotateLL(node); } else { node = RotateLR(node); } } else if (b_factor < -1) { if (balance_factor(node._right) > 0) { node = RotateRL(node); } else { node = RotateRR(node); } } }
public void InOrder(Node theRoot) { if(theRoot != null) { InOrder (theRoot.Left); theRoot.DisplayNode (); InOrder (theRoot.Right); } }
public static void Display(Node n) { if (n == null) return; Display(n.Left); Console.Write(" " + n.Value); Display(n.Right); }
/// <summary> /// Insert the specified data. /// </summary> /// <param name="data">Data for inserting.</param> public void Insert(int data) { if (IsEmpty()) { _head = new Node(data); ++Count; } else { if (_head.Contains(_head, data)) return; if (_head.InsertData(ref _head, data)) ++Count; } }
public bool Insert(int key) { //returns true if insert succeeded Node newValue = new Node (key); try { _nodeLock.EnterWriteLock(); if (_root == null) { _root = newValue; return true; } } finally { _nodeLock.ExitWriteLock (); } Node current = _root; while (true) { try { _nodeLock.EnterWriteLock(); if (key > current.Value) { if (current.RightChild == null) { current.RightChild = newValue; return true; } else { current = current.RightChild; } } else if (key < current.Value) { if (current.LeftChild == null) { current.LeftChild = newValue; return true; } else { current = current.LeftChild; } } else { return false; } } finally { _nodeLock.ExitWriteLock (); } } }
private void insertNode(Node curNode, int value) { Node newNode = new Node(value); if (curNode.Content > value) { if (curNode.Left == null) { curNode.Left = newNode; } else { insertNode(curNode.Left, value); } } else if (curNode.Content == value) return; else // curNode.Content < value { if (curNode.Right == null) curNode.Right = newNode; else insertNode(curNode.Right, value); } }
/// <summary> /// Inserts the data. /// </summary> /// <returns><c>true</c>, if data was inserted, <c>false</c> otherwise.</returns> /// <param name="node">Node.</param> /// <param name="data">Data.</param> public bool InsertData(ref Node node, int data) { if (node == null) { node = new Node(data); return true; } else if (node.Value < data) { if (node._right == null) node._right = new Node(data); else InsertData(ref node._right, data); return true; } else if (node.Value > data) { if (node._left == null) node._left = new Node(data); else InsertData(ref node._left, data); return true; } return false; }
public Node(int value) { Value = value; _right = null; _left = null; }
public void NodeEquality() { var left = new Node<int>(27); var right = new Node<int>(28); var n = new Node<int>(1); n.Left = left; n.Right = right; var equal = new Node<int>(1); equal.Left = left; equal.Right = right; var notEqualItem = new Node<int>(33); notEqualItem.Left = left; notEqualItem.Right = right; var notEqualNodes = new Node<int>(1); notEqualNodes.Left = right; notEqualNodes.Right = left; Assert.IsTrue(n.Equals(equal)); Assert.IsFalse(n.Equals(notEqualItem)); Assert.IsFalse(n.Equals(notEqualNodes)); }
public BinarySearchTree() { root = null; }
/// <summary> /// Determines whether the specified node instance is leaf. /// </summary> /// <returns><c>true</c> if this instance is leaf the specified node; otherwise, <c>false</c>.</returns> /// <param name="node">Node.</param> public bool IsLeaf(Node node) { if (node == null) throw new ArgumentNullException("Node"); return (node._right == null && node._left == null); }
private Node RotateLR(Node parent) { Node pivot = parent._left; parent._left = RotateRR(pivot); return RotateLL(parent); }
public BinarySearchTree(int data) { rootNode = new Node(data); }
/// <summary> /// Initializes a new instance of the <see cref="BinarySearchTree.BinaryTree"/> class. /// </summary> public BinaryTree() { _head = null; Count = 0; }
/// <summary> /// Removes the data. /// </summary> /// <returns><c>true</c>, if data was removed, <c>false</c> otherwise.</returns> /// <param name="node">Node.</param> /// <param name="data">Data.</param> public bool RemoveData(ref Node node, int data) { if (node == null) throw new ArgumentNullException("Node"); if (node.Value == data) { if (node.IsLeaf(node)) { node = null; return true; } if (node._left == null || node._right == null) { node = node._left ?? node._right; return true; } var temp = node._left; while (temp._right != null) temp = temp._right; temp._right = node._right; node = node._left; return true; } else if (node.Value < data) { return RemoveData(ref node._right, data); } else if (node.Value > data) { return RemoveData(ref node._left, data); } return false; }
private void printSubtree(Node node) { if (node == null) return; printSubtree(node.Left); Console.WriteLine(node.Content.ToString()); printSubtree(node.Right); }
public void Add(params T[] values) { if (values == null || !values.Any()) { throw new ArgumentException("Please fill values Parameters!"); } var _values = new List <T>(values); var middle = _values.OrderBy(v => v).Skip(_values.Count / 2).First(); _values.Remove(middle); _values.Insert(0, middle); foreach (var value in values) { if (this.TopNode == null) { TopNode = new Node <T>() { Value = value }; continue; } var current = this.TopNode; var added = false; do { if (Comparer <T> .Default.Compare(value, current.Value) == -1 || Comparer <T> .Default.Compare(value, current.Value) == 0) { if (current.LefNode == null) { current.LefNode = new Node <T>() { Value = value }; added = true; } else { current = current.LefNode; } } else { if (current.RightNode == null) { current.RightNode = new Node <T>() { Value = value }; added = true; } else { current = current.RightNode; } } } while (!added); } }
private int balance_factor(Node current) { int l = getHeight(current._left); int r = getHeight(current._right); int b_factor = l - r; return b_factor; }
private Node RotateRR(Node parent) { Node pivot = parent._right; parent._right = pivot._left; pivot._left = parent; return pivot; }
private Node RotateRL(Node parent) { Node pivot = parent._right; parent._right = RotateLL(pivot); return RotateRR(parent); }
public BinarySearchTree() { _rootNode = new Node(); }
public void Init() { n = new Node(10); }
/// <summary> /// Contains the specified node and data. /// </summary> /// <param name="node">Node.</param> /// <param name="data">Data.</param> public bool Contains(Node node, int data) { if (node == null) throw new ArgumentNullException("Node"); if (node.Value == data) { return true; } else if (node.Value < data) { if (node._right == null) return false; return Contains(node._right, data); } else if (node.Value > data) { if (node._left == null) return false; return Contains(node._left, data); } return false; }
private int getHeight(Node current) { int height = 0; if (current != null) { int l = getHeight(current._left); int r = getHeight(current._right); int m = Math.Max(l, r); height = m + 1; } return height; }
private bool searchNode(Node node, int value) { if (node == null) return false; Console.WriteLine("Node = " + node.Content.ToString()); if (node.Content == value) { Console.WriteLine("Content = " + node.Content.ToString()); return true; } else if (node.Content > value) return searchNode(node.Left, value); else // node.Content < value return searchNode(node.Right, value); }
/// <summary> /// Removes all. /// </summary> public void RemoveAll() { _head = null; GC.Collect(); Count = 0; }