internal void SepararNodo(string llave, T dato, int hijoDerecho, Nodo <T> nuevoNodo, ref string llavePorSubir, ref T datoPorSubir)
{
if (!Lleno)
{
throw new Exception("Uno nodo solo puede separarse si está lleno");
}
Llaves.Add("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
Datos.Add(dato);
Hijos.Add(Utilidades.apuntadoVacio);
AgregarDato(llave, dato, hijoDerecho, false);
int mitad = (Orden / 2);
llavePorSubir = Utilidades.FormatearLlave(Llaves[mitad]);
datoPorSubir = Datos[mitad];
Llaves[mitad] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
int j = 0;
for (int i = mitad + 1; i < Llaves.Count; i++)
{
nuevoNodo.Llaves[j] = Llaves[i];
nuevoNodo.Datos[j] = Datos[i];
Llaves[i] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
j++;
}
j = 0;
for (int i = mitad + 1; i < Hijos.Count; i++)
{
nuevoNodo.Hijos[j] = Hijos[i];
Hijos[i] = Utilidades.apuntadoVacio;
j++;
}
Llaves.RemoveAt(Llaves.Count - 1);
Datos.RemoveAt(Datos.Count - 1);
Hijos.RemoveAt(Hijos.Count - 1);
}
public void InsertEdge(Nodo hijo1)
{
for (int x = 0; x < Hijos.Count; x++)
{
if (Hijos[x].Keys[0] > hijo1.Keys[0])
{
Hijos.Insert(x, hijo1);
return;
}
}
Hijos.Add(hijo1);
hijo1.Padres = this;
}
public void InsertarHijo(NodoB son)
{
for (int x = 0; x < Hijos.Count; x++)
{
if (this.CompareTo(son, x) > 0)
{
Hijos.Insert(x, son);
return;
}
}
Hijos.Add(son);
son.Padre = this;
}
public void insertarNodo(Nodo nodo)
{
for (int x = 0; x < Hijos.Count; x++)
{
if (compararMedicamentos(Hijos[x].Llaves[0], nodo.Llaves[0]))
{
Hijos.Insert(x, nodo);
return;
}
}
Hijos.Add(nodo);
nodo.Padre = this;
}
public void InsertarHijo(Nodo hijo)
{
for (int x = 0; x < Hijos.Count; x++)
{
if (this.CompareTo(hijo, x) > 0)
{
Hijos.Insert(x, hijo);
return;
}
}
Hijos.Add(hijo);
hijo.Padre = this;
}
public void InsertarHijo(Nodo Hijo)
{
for (int x = 0; x < Hijos.Count; x++)
{
if (Hijos[x].Valores[0].CompareTo(Hijo.Valores[0]) > 0)
{
Hijos.Insert(x, Hijo);
return;
}
}
Hijos.Add(Hijo);
Hijo.Padre = this;
}
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());
}
}
}
internal void SepararNodo(string llave, T dato, int hijoDerecho, NodoB <T> nuevoNodo, ref string llavePorSubir, ref T datoPorSubir)
{
if (!Lleno)
{
throw new Exception("Uno nodo solo puede separarse si está lleno");
}
// Incrementar el tamaño de las listas en una posición
Llaves.Add("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
Datos.Add(dato);
Hijos.Add(Utilidades.ApuntadorVacio);
// Agregar los nuevos elementos en orden
AgregarDato(llave, dato, hijoDerecho, false);
// Obtener los valores a subir
int mitad = (Orden / 2);
llavePorSubir = Llaves[mitad];
datoPorSubir = Datos[mitad];
Llaves[mitad] = "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%";
// Llenar las llaves y datos que pasan al nuevo nodo
int j = 0;
for (int i = mitad + 1; i < Llaves.Count; i++)
{
nuevoNodo.Llaves[j] = Llaves[i];
nuevoNodo.Datos[j] = Datos[i];
Llaves[i] = "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%";
j++;
}
// Llenar los hijos que pasan al nuevo nodo
j = 0;
for (int i = mitad + 1; i < Hijos.Count; i++)
{
nuevoNodo.Hijos[j] = Hijos[i];
Hijos[i] = Utilidades.ApuntadorVacio;
j++;
}
Llaves.RemoveAt(Llaves.Count - 1);
Datos.RemoveAt(Datos.Count - 1);
Hijos.RemoveAt(Hijos.Count - 1);
}
public override void GenerarHijos(bool EsTurnoPC)
{
char c = EsTurnoPC ? 'X' : 'O';
for (int i = 0; i < Estado.Length; i++)
{
if (Estado[i] == ' ')
{
if (Hijos == null)
{
Hijos = new List <Nodo>();
}
NodoDama n = new NodoDama();
n.Estado = (char[])Estado.Clone();
n.Estado[i] = c;
Hijos.Add(n);
}
}
}
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);
}
internal void SeparacionNodo(T _data, int derecho, Nodo <T> Nodo, T SubirData, ICreateFixedSizeText <T> createFixedSizeText)
{
int medio = 0;
if (Padre.Equals(MetodosNecesarios.NullPointer))
{
Data.Add(_data);
Hijos.Add(MetodosNecesarios.NullPointer);
InsertarDatos(_data, derecho, false);
medio = Data.Count / 2;
SubirData = Data[medio];
Data[medio] = createFixedSizeText.CreateNull();
int j = 0;
for (int i = medio + 1; i < Data.Count; i++)
{
Nodo.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
j = 0;
for (int i = medio + 1; i < Hijos.Count; i++)
{
Nodo.Hijos[j] = Hijos[i];
Hijos[j] = MetodosNecesarios.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Hijos.RemoveAt(Hijos.Count - 1);
}
else
{
Data.Add(_data);
Hijos.Add(MetodosNecesarios.NullPointer);
InsertarDatos(_data, derecho, false);
medio = Data.Count / 2;
SubirData = Data[medio];
Data[medio] = createFixedSizeText.CreateNull();
int j = 0;
for (int i = medio + 1; i < Hijos.Count; i++)
{
Nodo.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
j = 0;
for (int i = medio + 1; i < Hijos.Count; i++)
{
Nodo.Hijos[j] = Hijos[i];
Hijos[i] = MetodosNecesarios.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Hijos.RemoveAt(Hijos.Count - 1);
}
}