public string mostrar(nodoB <TKey, TData> Current)
{
string chain = "";
chain += Generador.tamanioPosicionesFijas(Current.posicionPrincipal) + "|" + listaCadenas(Current.nodoLlaves) + listaCadenas(Current.datosNodo) + Generador.tamanioPosicionesFijas(Current.Padre) + "|" + stringOfList(Current.Hijos) + Environment.NewLine;
return(chain);
}
private int saltarLinea(int LengthOfData, int LengthOfKeys)
{
int NullLength = Generador.contadorCaracteresNulos();
int MaxKeys = (Orden - 1);
return(1 + ((NullLength + 1) + (MaxKeys * LengthOfKeys + MaxKeys) + (MaxKeys * LengthOfData + MaxKeys) + (NullLength + 1) + (NullLength * Orden + Orden)) + 1);
}
private string listaCadenas(List <TData> s)
{
string chain = "";
for (int i = 0; i < Orden - 1; i++)
{
string aux = "";
if (i < s.Count)
{
IList <string> valuesFromData = retornarDatos(s[i]);
IList <int> valuesLenght = retornarTamanioDatos();
for (int j = 0; j < valuesFromData.Count; j++)
{
aux += Generador.tamanioDatosFijos(valuesFromData[j], valuesLenght[j]) + "#";
}
chain += aux.Remove(aux.Length - 1) + "|";
}
else
{
IEnumerable <int> valuesFromData = retornarTamanioDatos();
foreach (var item in valuesFromData)
{
aux += Generador.hacerNuloDatos(item) + "~";
}
chain += aux.Remove(aux.Length - 1) + "|";
}
}
return(chain);
}
public void limpiar()
{
limpiarHijos();
datosNodo.Clear();
nodoLlaves.Clear();
Padre = Generador.hacerNulo();
}
public void Insert(TKey newKey, TData newData)
{
cerrarArchivo();
archivoArbol = File.Open(rutaArchivo, FileMode.Open);
if (Raiz == null)
{
nodoB <TKey, TData> newnodoB = NewnodoB();
newnodoB.insertar(newKey, newData);
Raiz = newnodoB;
archivoArbol.Seek(saltarEncabezado(), SeekOrigin.Begin);
archivoArbol.Write(ConvertStringTo_ByteChain(mostrar(Raiz)), 0, mostrar(Raiz).Length);
Cuenta++;
Altura++;
}
else
{
insertarRecursivamente(newKey, newData, Raiz);
}
archivoArbol.Seek(0, SeekOrigin.Begin);
if (Raiz == null)
{
Encabezado = Generador.armarEncabezado(Generador.hacerNulo().ToString(), Generador.tamanioPosicionesFijas(ultimaPosicion), Orden, Altura);
}
else
{
Encabezado = Generador.armarEncabezado(Generador.tamanioPosicionesFijas(Raiz.posicionPrincipal), Generador.tamanioPosicionesFijas(ultimaPosicion), Orden, Altura);
}
archivoArbol.Write(ConvertStringTo_ByteChain(Encabezado), 0, Encabezado.Length);
cerrarArchivo();
}
public bool hijosLlenos()
{
for (int i = 0; i < Hijos.Count; i++)
{
if (Hijos[i] == Generador.hacerNulo())
{
return(false);
}
}
return(true);
}
public void insertarHijoUltimo(int hijo)
{
for (int i = 0; i < Hijos.Count; i++)
{
if (Hijos[i] == Generador.hacerNulo())
{
Hijos[i] = hijo;
return;
}
}
}
public int obtenerUltimoHijo()
{
for (int i = Hijos.Count - 1; i >= 0; i--)
{
if (Hijos[i] != Generador.hacerNulo())
{
return(Hijos[i]);
}
}
return(Generador.hacerNulo());
}
public void insertarHijos(int posicion, int direccionHijo)
{
if (Hijos[posicion] != Generador.hacerNulo())
{
for (int i = Hijos.Count - 1; i > posicionPrincipal; i--)
{
Hijos[i] = Hijos[i - 1];
}
}
Hijos[posicionPrincipal] = direccionHijo;
}
public nodoB(int orden, int posicion, int tamanioMaximo)
{
nodoLlaves = new List <TKey>();
datosNodo = new List <TData>();
Hijos = new List <int>();
Orden = orden;
Count = 0;
Padre = Generador.hacerNulo();
posicionPrincipal = posicion;
tamanioMaximoLlave = tamanioMaximo;
limpiarHijos();
}
public static string armarEncabezado(string direccionRaiz, string ultimaDireccion, int ordenArbol, int altura)
{
string encabezado = "";
encabezado += direccionRaiz + Environment.NewLine;
encabezado += ultimaDireccion + Environment.NewLine;
encabezado += Generador.tamanioPosicionesFijas(Math.Abs(ordenArbol - 1)) + Environment.NewLine;
encabezado += tamanioPosicionesFijas(ordenArbol) + Environment.NewLine;
encabezado += tamanioPosicionesFijas(altura) + Environment.NewLine;
return(encabezado);
}
private nodoB <TKey, TData> prestamoHermano(nodoB <TKey, TData> Padre, nodoB <TKey, TData> actual)
{
int index = Padre.Hijos.IndexOf(actual.posicionPrincipal);
List <int> Hijos = new List <int>();
for (int i = 0; i < Padre.Hijos.Count; i++)
{
if (Padre.Hijos[i] != Generador.hacerNulo())
{
Hijos.Add(Padre.Hijos[i]);
}
}
if (index == 0)
{
nodoB <TKey, TData> right = AccessTonodoB(Hijos[index + 1]);
if (right.nodoLlaves.Count > (Orden % 2 == 0 ? Orden / 2 - 1 : Orden / 2))
{
return(right);
}
}
else if (index == Hijos.Count - 1)
{
nodoB <TKey, TData> left = AccessTonodoB(Hijos[index - 1]);
if (left.nodoLlaves.Count > (Orden % 2 == 0 ? Orden / 2 - 1 : Orden / 2))
{
return(left);
}
}
else
{
nodoB <TKey, TData> left = AccessTonodoB(Hijos[index - 1]);
nodoB <TKey, TData> right = AccessTonodoB(Hijos[index + 1]);
if (left != null && right != null)
{
if (left.nodoLlaves.Count >= right.nodoLlaves.Count)
{
if (left.nodoLlaves.Count > (Orden % 2 == 0 ? Orden / 2 - 1 : Orden / 2) && left.posicionPrincipal != actual.posicionPrincipal)
{
return(left);
}
}
else
{
if (right.nodoLlaves.Count > (Orden % 2 == 0 ? Orden / 2 - 1 : Orden / 2) && right.posicionPrincipal != actual.posicionPrincipal)
{
return(right);
}
}
}
}
return(null);
}
public void FixHijos(int posicionAMover)
{
if (!hijosLlenos())
{
posicionAMover++;
for (int i = Hijos.Count - 1; i > posicionAMover; i--)
{
Hijos[i] = Hijos[i - 1];
}
Hijos[posicionAMover] = Generador.hacerNulo();
Count++;
}
}
public bool esHoja()
{
int esNulo = Generador.hacerNulo();
for (int i = 0; i < Hijos.Count; i++)
{
if (Hijos[i] != esNulo)
{
return(false);
}
}
return(true);
}
private void actualizarGrupoHijos(nodoB <TKey, TData> rightSon, List <int> HijosForNewnodoB)
{
nodoB <TKey, TData> hijo;
for (int i = 0; i < HijosForNewnodoB.Count; i++)
{
if (HijosForNewnodoB[i] != Generador.hacerNulo())
{
rightSon.Hijos[i] = HijosForNewnodoB[i];
hijo = AccessTonodoB(HijosForNewnodoB[i]);
hijo.Padre = rightSon.posicionPrincipal;
actaulizarNodo(hijo);
}
}
actaulizarNodo(rightSon);
}
private nodoB <TKey, TData> SearchRecursive(nodoB <TKey, TData> currentnodoB, TKey key)
{
if (currentnodoB.nodoLlaves.Exists(x => key.CompareTo(x) == 0))
{
return(currentnodoB);
}
else
{
int index = currentnodoB.posicionAproximada(key);
if (currentnodoB.obtenerNodoIndice(index) == Generador.hacerNulo())
{
return(null);
}
return(SearchRecursive(AccessTonodoB(currentnodoB.Hijos[index]), key));
}
}
private string listaCadenas(List <TKey> s)
{
string chain = "";
for (int i = 0; i < Orden - 1; i++)
{
if (i < s.Count)
{
chain += Generador.tamanioFijoLlaves(s[i].ToString(), tamanioMaximoLlave) + "|";
}
else
{
chain += Generador.hacerNuloLlaves(tamanioMaximoLlave) + "|";
}
}
return(chain);
}
private string stringOfList(List <int> s)
{
string chain = "";
for (int i = 0; i < Orden; i++)
{
if (i < s.Count)
{
chain += Generador.tamanioPosicionesFijas(s[i]) + "|";
}
else
{
chain += Generador.hacerNulo() + "|";
}
}
return(chain);
}
public void limpiarHijos()
{
if (Hijos.Count != 0)
{
for (int i = 0; i < Hijos.Count; i++)
{
Hijos[i] = Generador.hacerNulo();
}
}
else
{
for (int i = 0; i < Orden; i++)
{
Hijos.Add(Generador.hacerNulo());
}
}
}
private nodoB <TKey, TData> ultimoNodoDerecho(nodoB <TKey, TData> LeftSonOfCurrentnodoB)
{
if (LeftSonOfCurrentnodoB.Hijos[0] == Generador.hacerNulo())
{
return(LeftSonOfCurrentnodoB);
}
else
{
for (int j = LeftSonOfCurrentnodoB.Hijos.Count - 1; j >= 0; j--)
{
if (LeftSonOfCurrentnodoB.Hijos[j] != Generador.hacerNulo())
{
return(ultimoNodoDerecho(AccessTonodoB(LeftSonOfCurrentnodoB.Hijos[j])));
}
}
return(null);
}
}
public static string tamanioPosicionesFijas(int posicion1)
{
string esNulo = Generador.hacerNulo().ToString();
if (posicion1.ToString().Length == esNulo.Length)
{
return(posicion1.ToString());
}
else
{
string posicionNueva = posicion1.ToString();
for (int i = posicion1.ToString().Length; i < esNulo.Length; i++)
{
posicionNueva = "0" + posicionNueva;
}
return(posicionNueva);
}
}
public arbolBAsterisco(int TreeOrder, string archivoArbolName, string archivoArbolPath, ConvertStringToKey KeyConverter, ConvertStringToData StringConverter, GetData DataConverter, int KeyMaxLength, GetDataLength DataMaxLength)
{
Raiz = null;
Orden = TreeOrder;
Cuenta = 0;
Altura = 0;
ultimaPosicion = 0;
rutaArchivo = archivoArbolPath + archivoArbolName;
archivoArbol = File.Create(rutaArchivo);//Se creará en la carpeta del proyecto
espaciosDisponibles = new List <int>();
Encabezado = Generador.armarEncabezado(Generador.hacerNulo().ToString(), Generador.tamanioPosicionesFijas(0), Orden, 0) + Environment.NewLine;
archivoArbol.Write(ConvertStringTo_ByteChain(Encabezado), 0, Encabezado.Length);
ConverterStringToTkey = KeyConverter;
ConverterStringToTData = StringConverter;
retornarDatos = DataConverter;
tamanioMaximoLlave = KeyMaxLength;
retornarTamanioDatos = DataMaxLength;
cerrarArchivo();
}
public nodoB <TKey, TData> AccessTonodoB(int posicionPrincipal)
{
if (posicionPrincipal == Generador.hacerNulo())
{
return(null);
}
int saltos = 0;
saltos = saltarLineasYEncabezados(posicionPrincipal);
StreamReader reader = new StreamReader(archivoArbol);
reader.BaseStream.Seek(saltos, SeekOrigin.Begin);
string[] nodoBLine = reader.ReadLine().Split('|');
nodoB <TKey, TData> AuxnodoB = new nodoB <TKey, TData>(Orden, int.Parse(nodoBLine[0]), tamanioMaximoLlave);
for (int i = 1; i < Orden; i++)
{
if (nodoBLine[i] != Generador.hacerNuloLlaves(tamanioMaximoLlave))
{
AuxnodoB.nodoLlaves.Add(ConverterStringToTkey(Generador.retornarLlaveOriginal(nodoBLine[i])));
}
}
int condicion = (Orden);
for (int i = condicion; i < condicion + (Orden - 1); i++)
{
if (nodoBLine[i] != Generador.hacerNuloDatos(GetMaxLenghtData(retornarTamanioDatos())) || nodoBLine[i].Contains('#'))
{
AuxnodoB.datosNodo.Add(ConverterStringToTData(Generador.retornarDatosOriginales(nodoBLine[i])));
}
}
condicion += (Orden - 1);
AuxnodoB.Padre = int.Parse(nodoBLine[condicion]);
condicion += 1;
int c = 0;
for (int i = condicion; i < condicion + Orden; i++)
{
AuxnodoB.Hijos[c++] = int.Parse(nodoBLine[i]);
}
return(AuxnodoB);
}
public List <TKey> hijosyvaloresActuales(TKey llaveAComparar, ref List <TData> datos, ref List <int> hijos)
{
int condition = nodoLlaves.Count;
List <TKey> Maximuns = new List <TKey>();
for (int i = 0; i < condition; i++)
{
if (nodoLlaves[i].CompareTo(llaveAComparar) == 1)
{
Maximuns.Add(nodoLlaves[i]);
datos.Add(datosNodo[i]);
Hijos.Add(Hijos[i + 1]);
Hijos[i + 1] = Generador.hacerNulo();
}
}
for (int i = 0; i < Maximuns.Count; i++)
{
nodoLlaves.Remove(Maximuns[i]);
datosNodo.Remove(datos[i]);
}
return(Maximuns);
}
public void insertarGrupoDeHijos(List <int> grupoHijos, int inicio, int posicionDeInsercion)
{
inicio++;
for (int i = 0; i < grupoHijos.Count; i++)
{
Hijos.Add(Generador.hacerNulo());
}
int temporal = 0;
int GroupCount = 0;
for (int i = inicio; i < Hijos.Count - 1; i++)
{
temporal = Hijos[i];
Hijos[i] = grupoHijos[GroupCount];
grupoHijos[GroupCount] = temporal;
if (GroupCount == grupoHijos.Count)
{
GroupCount = 0;
}
}
Hijos[Count - 1] = temporal;
Hijos[inicio] = posicionDeInsercion;
}
public List <TKey> HijosAndValuesToBrother(TKey llaveAComparar, ref List <TData> datos, ref List <int> hijos)
{
int condicionPrincipal = nodoLlaves.Count;
List <TKey> maximos = new List <TKey>();
for (int i = 0; i < condicionPrincipal; i++)
{
if (nodoLlaves[i].CompareTo(llaveAComparar) == 1)
{
maximos.Add(nodoLlaves[i]);
datos.Add(datosNodo[i]);
Hijos.Add(Hijos[i]);
Hijos[i] = Generador.hacerNulo();
}
}
Hijos.Add(Hijos[condicionPrincipal]);
Hijos[condicionPrincipal] = Generador.hacerNulo();
for (int i = 0; i < maximos.Count; i++)
{
nodoLlaves.Remove(maximos[i]);
datosNodo.Remove(datos[i]);
}
return(maximos);
}
private int saltarEncabezado()
{
return((Generador.contadorCaracteresNulos() * 5) + (5 * 2));
}