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