/**
* Method declaration
*
*
* @param x
* @param w
* @param n
*
* @throws Exception
*/
private void set(Node x, bool w, Node n)
{
if (w)
{
x.setLeft(n);
}
else
{
x.setRight(n);
}
if (n != null)
{
n.setParent(x);
}
}
/**
* Method declaration
*
*
* @param x
* @param n
*
* @throws Exception
*/
private void replace(Node x, Node n)
{
if (x.Equals(root))
{
root = n;
if (n != null)
{
n.setParent(null);
}
}
else
{
set(x.getParent(), from(x), n);
}
}
/**
* Method declaration
*
*
* @param x
* @param w
* @param n
*
* @throws Exception
*/
private void set(Node x, bool w, Node n)
{
if (w)
{
x.setLeft(n);
}
else
{
x.setRight(n);
}
if (n != null)
{
n.setParent(x);
}
}
/**
* Method declaration
*
*
* @param row
* @param datatoo
*
* @throws Exception
*/
public void delete(object[] row, bool datatoo)
{
Node x = search(row);
if (x == null)
{
return;
}
Node n;
if (x.getLeft() == null)
{
n = x.getRight();
}
else if (x.getRight() == null)
{
n = x.getLeft();
}
else
{
Node d = x;
x = x.getLeft();
// todo: this can be improved
while (x.getRight() != null)
{
if (Trace.STOP)
{
Trace.stop();
}
x = x.getRight();
}
// x will be replaced with n later
n = x.getLeft();
// swap d and x
int b = x.getBalance();
x.setBalance(d.getBalance());
d.setBalance(b);
// set x.parent
Node xp = x.getParent();
Node dp = d.getParent();
if (d == root)
{
root = x;
}
x.setParent(dp);
if (dp != null)
{
if (dp.getRight().Equals(d))
{
dp.setRight(x);
}
else
{
dp.setLeft(x);
}
}
// for in-memory tables we could use: d.rData=x.rData;
// but not for cached tables
// relink d.parent, x.left, x.right
if (xp == d)
{
d.setParent(x);
if (d.getLeft().Equals(x))
{
x.setLeft(d);
x.setRight(d.getRight());
}
else
{
x.setRight(d);
x.setLeft(d.getLeft());
}
}
else
{
d.setParent(xp);
xp.setRight(d);
x.setRight(d.getRight());
x.setLeft(d.getLeft());
}
x.getRight().setParent(x);
x.getLeft().setParent(x);
// set d.left, d.right
d.setLeft(n);
if (n != null)
{
n.setParent(d);
}
d.setRight(null);
x = d;
}
bool way = from(x);
replace(x, n);
n = x.getParent();
x.delete();
if (datatoo)
{
x.rData.delete();
}
while (n != null)
{
if (Trace.STOP)
{
Trace.stop();
}
x = n;
int sign = way ? 1 : -1;
switch (x.getBalance() * sign)
{
case -1:
x.setBalance(0);
break;
case 0:
x.setBalance(sign);
return;
case 1:
Node r = child(x, !way);
int b = r.getBalance();
if (b * sign >= 0)
{
replace(x, r);
set(x, !way, child(r, way));
set(r, way, x);
if (b == 0)
{
x.setBalance(sign);
r.setBalance(-sign);
return;
}
x.setBalance(0);
r.setBalance(0);
x = r;
}
else
{
Node l = child(r, way);
replace(x, l);
b = l.getBalance();
set(r, way, child(l, !way));
set(l, !way, r);
set(x, !way, child(l, way));
set(l, way, x);
x.setBalance((b == sign) ? -sign : 0);
r.setBalance((b == -sign) ? sign : 0);
l.setBalance(0);
x = l;
}
}
way = from(x);
n = x.getParent();
}
}
/**
* Method declaration
*
*
* @param x
* @param n
*
* @throws Exception
*/
private void replace(Node x, Node n)
{
if (x.Equals(root))
{
root = n;
if (n != null)
{
n.setParent(null);
}
}
else
{
set(x.getParent(), from(x), n);
}
}