private void PostOrder(int PosicionActual, StringBuilder Ttxt)
{
if (PosicionActual == MetodosNecesarios.NullPointer)
{
return;
}
Nodo <T> node = new Nodo <T>();
node.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
for (int i = 0; i < node.Hijos.Count; i++)
{
PostOrder(node.Hijos[i], Ttxt);
}
EscrituraNodo(node, Ttxt);
}
private void RecorridoPreOrden(int PosicionActual, StringBuilder TTxto)
{
if (PosicionActual == MetodosNecesarios.NullPointer)
{
return;
}
Nodo <T> nodo = new Nodo <T>();
nodo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
EscrituraNodo(nodo, TTxto);
for (int i = 0; i < nodo.Hijos.Count; i++)
{
RecorridoPreOrden(nodo.Hijos[i], TTxto);
}
}
private void ObtenerNodo(int PosicionActual)
{
if (PosicionActual == MetodosNecesarios.NullPointer)
{
return;
}
Nodo <T> nodo = new Nodo <T>();
nodo = nodo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
for (int i = 0; i < nodo.Data.Count; i++)
{
ObtenerNodo(nodo.Hijos[i]);
ElementosBuscados.Add(nodo.Data[i]);
}
}
private void Insert(int ActualPosicion, T data)
{
Nodo <T> node = new Nodo <T>();
node = node.LecturaNodo(this.Ruta, this.Orden, this.Raiz, ActualPosicion, this.createFixedSizeText);
if (node.PosicionDentroNodo(data) != 1)
{
throw new ArgumentException("El valor se encuentra creado con anterioridad dentro del nodo");
}
if (node.EsHoja)
{
UpData(node, data, MetodosNecesarios.NullPointer);
EscrituraEncabezado();
}
}
private void Busqueda(int PosicionActual, T data, T Ndata)
{
if (PosicionActual == MetodosNecesarios.NullPointer)
{
return;
}
Nodo <T> nodo = new Nodo <T>();
nodo = nodo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
for (int i = 0; i < nodo.Data.Count; i++)
{
ObtenerNodo(nodo.Hijos[i]);
if (nodo.Data[i].ToString() == data.ToString())
{
nodo.Data[i] = Ndata;
nodo.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
}
}
}
private void InOrder(int PosicionActual, StringBuilder TTxt)
{
Sucursal _Sucursal = new Sucursal();
if (PosicionActual == MetodosNecesarios.NullPointer)
{
return;
}
Nodo <T> nodo = new Nodo <T>();
nodo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
for (int i = 0; i < nodo.Data.Count; i++)
{
InOrder(nodo.Hijos[i], TTxt);
if ((i < nodo.Data.Count) && (nodo.Data[i].ToFixedSizeString() != _Sucursal.ToFixedSizeString()))
{
TTxt.AppendLine(nodo.Data[i].ToString());
TTxt.AppendLine("---");
}
}
}
private Nodo <T> Obtener(int PosicionActual, out int posicion, T data)
{
Nodo <T> NActual = new Nodo <T>();
NActual.LecturaNodo(this.Ruta, this.Orden, this.Raiz, PosicionActual, this.createFixedSizeText);
posicion = NActual.PosicionDentroNodo(data);
if (posicion != -1)
{
return(NActual);
}
else
{
if (NActual.EsHoja)
{
return(null);
}
else
{
int PosicionAproximada = NActual.PosicionAproximada(data);
return(Obtener(NActual.Hijos[PosicionAproximada], out posicion, data));
}
}
}
private void UpData(Nodo <T> node, T data, int Derecho)
{
if (node.CapacidadMax && node.Padre != MetodosNecesarios.NullPointer)
{
Nodo <T> nPadre = new Nodo <T>();
nPadre.ID = node.Padre;
nPadre = nPadre.LecturaNodo(this.Ruta, this.Orden, this.Raiz, node.Padre, createFixedSizeText);
int posicion = 0;
for (int i = 0; i < nPadre.Hijos.Count(); i++)
{
if (nPadre.Hijos[i] == node.ID)
{
posicion = i;
break;
}
}
Nodo <T> TemporalNode = new Nodo <T>();
if (nPadre.Hijos[posicion + 1] != MetodosNecesarios.NullPointer)
{
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion + 1], createFixedSizeText);
if (!TemporalNode.CapacidadMax)
{
node.Data.Add(data);
node.Data.Sort();
T TemporalData = node.Data[node.Data.Count() - 1];
node.Data.Remove(TemporalData);
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
T TemporalData2 = nPadre.Data[posicion - 1];
nPadre.Data.Insert(posicion - 1, TemporalData2);
TemporalNode.Data.Add(data);
TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
}
}
if (posicion > 0)
{
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion - 1], createFixedSizeText);
if (!TemporalNode.CapacidadMax)
{
node.Data.Add(data);
node.Data.Sort();
T TemporalData = node.Data[0];
node.Data.Remove(TemporalData);
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
T TemporalData2 = nPadre.Data[posicion - 1];
nPadre.Data.Insert(posicion - 1, TemporalData2);
TemporalNode.Data.Add(data);
TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
return;
}
}
List <T> SNodo = new List <T>();
foreach (var item in node.Data)
{
SNodo.Add(item);
}
if (nPadre.Hijos[posicion + 1] != MetodosNecesarios.NullPointer)
{
SNodo.Add(nPadre.Data[posicion]);
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion + 1], createFixedSizeText);
}
else if (posicion > 0)
{
SNodo.Add(nPadre.Data[posicion - 1]);
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion - 1], createFixedSizeText);
}
foreach (var item in TemporalNode.Data)
{
SNodo.Add(item);
}
SNodo.Add(data);
SNodo.Sort();
int min = (2 * (this.Orden - 1)) / 3;
node.Data.Clear();
TemporalNode.Data.Clear();
int contador = 0;
for (int i = 0; i < this.Orden - 1; i++)
{
if (contador < min)
{
node.Data.Add(SNodo[i]);
}
else
{
node.Data.Add(createFixedSizeText.CreateNull());
}
contador++;
}
nPadre.Data.Insert(posicion, SNodo[min]);
nPadre.Data.Insert(posicion + 1, SNodo[(min * 2) + 1]);
contador = 0;
for (int i = 0; i < this.Orden - 1; i++)
{
if (contador < min)
{
TemporalNode.Data.Add(SNodo[i + min + 1]);
}
else
{
TemporalNode.Data.Add(createFixedSizeText.CreateNull());
}
contador++;
}
contador = 0;
Nodo <T> NNode = new Nodo <T>();
NNode.Padre = nPadre.ID;
NNode.ID = UltimaPosicion;
NNode.Data = new List <T>();
NNode.Hijos = new List <int>();
UltimaPosicion++;
for (int i = 0; i < this.Orden - 1; i++)
{
if (contador < min)
{
NNode.Data.Add(SNodo[i + (2 * min) + 2]);
}
else
{
NNode.Data.Add(createFixedSizeText.CreateNull());
}
}
for (int i = 0; i < this.Orden; i++)
{
NNode.Hijos.Add(MetodosNecesarios.NullPointer);
}
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
nPadre.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
EscrituraEncabezado();
}
else if (true)
{
node.InsertarDatos(data);
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
return;
}
Nodo <T> _NNode = new Nodo <T>(this.Orden, this.UltimaPosicion, node.Padre, createFixedSizeText);
this.UltimaPosicion++;
T TUData = createFixedSizeText.CreateNull();
node.SeparacionNodo(data, Derecho, _NNode, TUData, createFixedSizeText);
Nodo <T> NodoHijo = new Nodo <T>();
for (int i = 0; i < _NNode.Hijos.Count; i++)
{
if (_NNode.Hijos[i] != MetodosNecesarios.NullPointer)
{
NodoHijo = NodoHijo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, _NNode.Hijos[i], createFixedSizeText);
NodoHijo.Padre = _NNode.ID;
NodoHijo.EscrituraEnDiscoNodo(Ruta, this.Raiz);
}
else
{
break;
}
}
if (node.Padre == MetodosNecesarios.NullPointer)
{
Nodo <T> NRaiz = new Nodo <T>(this.Orden, this.UltimaPosicion, MetodosNecesarios.NullPointer, createFixedSizeText);
this.UltimaPosicion++;
NRaiz.Hijos[0] = node.ID;
NRaiz.Hijos[1] = _NNode.ID;
NRaiz.InsertarDatos(data, _NNode.ID);
node.Padre = NRaiz.ID;
NRaiz.Padre = MetodosNecesarios.NullPointer;
_NNode.Padre = NRaiz.ID;
this.Raiz = NRaiz.ID;
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
_NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
NRaiz.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
}
else
{
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
_NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
Nodo <T> Padre = new Nodo <T>();
Padre = Padre.LecturaNodo(this.Ruta, this.Orden, this.Raiz, node.Padre, createFixedSizeText);
UpData(Padre, data, _NNode.ID);
}
}
