public void Delete(BNode <T> root, T value, int pos, int idParent)
{
if (Contains(root, value))
{
var posValues = IndexOf(root.Values, value);//
if (IsLeaf(root))
{
root.Values.RemoveAt(posValues);
if (IsUnderflow(root))
{
Balance(root);
}
else
{
Fm.WriteNode(root);
}
return;
}
else
{
var newRoot = GetNode(root.Childs[posValues]);
Delete(newRoot, value, 0, root.Id);
newRoot = GetNode(root.Id);
if (IsUnderflow(newRoot))
{
Balance(newRoot);
}
return;
}
}
else if (!IsLeaf(root))
{
if ((int)Comparer.DynamicInvoke(value, root.Values[pos]) == -1)
{
BNode <T> newRoot;
newRoot = GetNode(root.Childs[pos]);
Delete(newRoot, value, 0, idParent);
newRoot = GetNode(root.Id);
if (IsUnderflow(newRoot))
{
Balance(newRoot);
}
}
else if ((int)Comparer.DynamicInvoke(value, root.Values[pos]) == 1)
{
pos++;
if (pos < root.Values.Count)
{
Delete(root, value, pos, idParent);
}
else
{
BNode <T> newRoot;
newRoot = GetNode(root.Childs[pos]);
Delete(newRoot, value, 0, idParent);
newRoot = GetNode(root.Id);
if (IsUnderflow(newRoot))
{
Balance(newRoot);
}
}
}
return;
}
else
{
if ((int)Comparer.DynamicInvoke(value, root.Values[root.Values.Count - 1]) == 1)
{
var valueSuplit = root.Values[root.Values.Count - 1]; //obtengo ultimo valor
root.Values.Remove(valueSuplit); //quito de la hoja
var changeInParent = GetNode(idParent); //llamo al padre donde sustituire
var posDel = IndexOf(changeInParent.Values, value); //index del valor eliminado
changeInParent.Values.RemoveAt(posDel); //elimino de la raiz sonde se quedo contenido
changeInParent.Values.Insert(posDel, valueSuplit); //incerto el valor en la raiz donde lo encontre
Fm.WriteNode(changeInParent);
if (IsUnderflow(root))
{
root.Father = changeInParent.Id;
Balance(root);
}
else
{
Fm.WriteNode(root);
}
return;
}
return; //caso en el que no se encontro el valor eliminado
}
}
public bool Exist(T value)
{
BNode <T> nodef = Fm.CastNode(Root);
return(Exist(nodef, value));
}
private void SplitParent(BNode <T> parentToSplit)
{
var middleValPos = (Grade - 1) / 2;
var middleValue = parentToSplit.Values[middleValPos];
BNode <T> parent;
BNode <T> newParent = new BNode <T>(Grade);
if (parentToSplit.Father == -1)
{
parent = new BNode <T>(Grade)
{
Father = -1, Id = SetNextId()
};
newParent.Father = parent.Id;
newParent.Id = SetNextId();
UpdateTree(parent.Id, Next_Id);
parentToSplit.Father = parent.Id;
newParent.Childs.Add(-1);
parent.Childs.RemoveAt(0);
parent.Childs.Insert(0, parentToSplit.Id);
parent.Values.Add(middleValue);
SortNode(parent);
}
else
{
parent = GetNode(parentToSplit.Father);
newParent.Father = parentToSplit.Father;
newParent.Id = SetNextId();
newParent.Childs.Add(-1);
parent.Values.Add(middleValue);
SortNode(parent);
}
//Extraer valores mayores del nodo y los agrega ala nueva hoja
for (int i = (middleValPos + 1); i < parentToSplit.Values.Count; i++)
{
newParent.Values.Add(parentToSplit.Values[i]);
}
// Quita los valores desde la mitad hasta el ultimo mayor
while (middleValPos != parentToSplit.Values.Count)
{
parentToSplit.Values.RemoveAt(middleValPos);
}
// pasa los hijos desde la mitad hasta el ultimo
for (int i = 0; i < parentToSplit.Childs.Count; i++)
{
newParent.Childs.RemoveAt(i);
newParent.Childs.Insert(i, parentToSplit.Childs[middleValPos + 1]);
parentToSplit.Childs.RemoveAt(middleValPos + 1);
parentToSplit.Childs.Add(-1);
}
BNode <T> tempNode;
foreach (var item in newParent.Childs)
{
if (item != -1)
{
tempNode = GetNode(item);
tempNode.Father = newParent.Id;
removeChild(tempNode);
Fm.WriteNode(tempNode);
}
}
SortChilds(parent, newParent.Id, middleValue);
removeChild(parentToSplit);
removeChild(parent);
removeChild(newParent);
Fm.WriteNode(parentToSplit);
Fm.WriteNode(parent);
Fm.WriteNode(newParent);
}
