protected bool InsertNode(NodeAA root, int newData)
{
if (newData == root.data)
{
return(false);
}
if (newData > root.data)
{
if (root.right == null)
{
NodeAA node = new NodeAA(newData);
root.right = node;
return(true);
}
else
{
return(InsertNode(root.right, newData));
}
}
else
{
if (root.left == null)
{
NodeAA node = new NodeAA(newData);
root.left = node;
return(true);
}
else
{
return(InsertNode(root.left, newData));
}
}
}
protected bool BalanceNode(NodeAA node)
{
if (node.level > 1)
{
if (node.left.level == node.level - 2 || node.right.level == node.level - 2)
{
Console.WriteLine("ha node 2: {0}", node.data);
node.level--;
if (node.right.level > node.level)
{
node.right.level--;
}
return(false);
}
}
if (node.left != null && node.level == node.left.level)
{
Console.WriteLine("skew node: {0}", node.data);
Skew(node); return(false);
//skew node;
}
if (node.right != null && node.right.right != null && node.right.right.level == node.level)
{
Console.WriteLine("split node: {0}", node.data);
Split(node);
node.level++; return(false);
//split node;
}
return(true);
}
protected int DeleteBough(TreeAA tree, NodeAA node)
{
NodeAA leftBestChild = FindLeftBestChild(node.left);
NodeAA parentLBC = SearchParent(node, leftBestChild.data);
Console.WriteLine("parent:{0}", parentLBC.data);
node.data = leftBestChild.data;
if (node.data == parentLBC.data)
{
parentLBC.left = null;
}
else
{
parentLBC.right = null;
}
parentLBC.level = 1;
if (parentLBC.left != null)
{
parentLBC.left.level = 1;
}
else
{
parentLBC.right.level = 1;
}
return(parentLBC.data);
}
protected bool DeleteNode(TreeAA tree, int keyDelete)
{
NodeAA node = SearchNode(tree.root, keyDelete);
if (node == null)
{
return(false);
}
else
{
if (node.left == null && node.right == null)
{
//xoa node la
DeleteLeaf(tree, keyDelete);
while (!CheckBalance(tree.root, keyDelete))
{
Console.WriteLine("root: {0}", tree.root.data);
}
return(true);
}
else
{
int numberTest = DeleteBough(tree, node);
while (!CheckBalance(tree.root, numberTest))
{
Console.WriteLine("root: {0}", tree.root.data);
}
//xoa node co 2 con
return(true);
}
}
}
protected bool CheckBalance(NodeAA node, int newData)
{
if (node == null)
{
return(true);
}
else
{
bool check = BalanceNode(node);
if (check)
{
//return CheckBalance(node.right, newData) && CheckBalance(node.left, newData);
if (newData > node.data)
{
return(CheckBalance(node.right, newData));
}
else
{
return(CheckBalance(node.left, newData));
}
}
else
{
return(false);
}
}
}
protected void DeleteLeaf(TreeAA tree, int keyDelete)
{
NodeAA nodeParent = SearchParent(tree.root, keyDelete);
if (nodeParent != null)
{
if (keyDelete < nodeParent.data)
{
nodeParent.left = null;
nodeParent.level--;
if (nodeParent.right.level > nodeParent.level)
{
nodeParent.right.level--;
}
}
else
{
nodeParent.right = null;
nodeParent.level = 1;
}
}
else
{
if (tree.root.data == keyDelete)
{
tree.root = null;
}
}
}
protected void BalanceTree(NodeAA root, int newData)
{
while (!CheckBalance(root, newData))
{
;
}
}
protected NodeAA FindLeftBestChild(NodeAA nodeLeft)
{
if (nodeLeft.right == null)
{
return(nodeLeft);
}
else
{
return(FindLeftBestChild(nodeLeft.right));
}
}
void Skew(NodeAA P)
{
NodeAA Q = P.left;
int temp = P.data;
P.data = Q.data;
Q.data = temp;
P.left = Q.left;
Q.left = Q.right;
Q.right = P.right;
P.right = Q;
}
void Split(NodeAA P)
{
NodeAA Q = P.right;
P.right = Q.right;
Q.right = Q.left;
Q.left = P.left;
P.left = Q;
int temp = P.data;
P.data = Q.data;
Q.data = temp;
}
public bool Insert(int newData)
{
if (root == null)
{
NodeAA node = new NodeAA(newData);
root = node;
return(true);
}
bool insert = InsertTree(this, newData);
BalanceTree(root, newData);
return(insert);
}
protected bool CheckBalanceDeleteBough(NodeAA node)
{
if (node == null)
{
return(true);
}
else
{
bool check = BalanceNode(node);
if (check)
{
return(CheckBalanceDeleteBough(node.left) && CheckBalanceDeleteBough(node.right));
}
else
{
return(false);
}
}
}
protected NodeAA SearchNode(NodeAA node, int keySearch)
{
if (node == null)
{
return(null);
}
else
{
if (node.data == keySearch)
{
return(node);
}
if (keySearch > node.data)
{
return(SearchNode(node.right, keySearch));
}
else
{
return(SearchNode(node.left, keySearch));
}
}
}
protected NodeAA SearchParent(NodeAA node, int keySearch)
{
if (keySearch > node.data)
{
if (node.right != null)
{
if (node.right.data == keySearch)
{
return(node);
}
else
{
return(SearchParent(node.right, keySearch));
}
}
else
{
return(null);
}
}
else
{
if (node.left != null)
{
if (node.left.data == keySearch)
{
return(node);
}
else
{
return(SearchParent(node.left, keySearch));
}
}
else
{
return(null);
}
}
}
public TreeAA(int newData)
{
NodeAA node = new NodeAA(newData);
root = node;
}
public TreeAA()
{
root = null;
}
