//método interno para realizar la operación
private Nodo insertar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
raizSub = new Nodo(dato);
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = insertar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzdo(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = insertar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDcho(dr);
}
else
{
// throw new Exception("Nodo duplicado");
Console.WriteLine($"duplicado!!!! {raizSub.valorNodo()}");
}
return(raizSub);
}
public void PrimeiroEhMaior(Comparador comparar)
{
Console.WriteLine("=========================================");
Console.WriteLine("Verificação da maior palavra:");
if (nomes[1].Primeironome.Length >= nomes[4].Primeironome.Length)
{
Console.ForegroundColor = ConsoleColor.Yellow;
ImprimeMensagem(nomes[1]);
Console.ForegroundColor = ConsoleColor.Cyan;
ImprimeMensagem(nomes[4]);
Console.ResetColor();
Console.WriteLine("A primeira palavra tem o maior número de caracteres.");
}
else
{
Console.ForegroundColor = ConsoleColor.Cyan;
ImprimeMensagem(nomes[1]);
Console.ForegroundColor = ConsoleColor.Yellow;
ImprimeMensagem(nomes[4]);
Console.ResetColor();
Console.WriteLine("Ambas as palavras tem o mesmo número de caracteres.");
}
}
static void Main(string[] args)
{
var datos = new List <Persona> {
new Persona {
Nombre = "Alejandro", Apellido = "Di Battista", Edad = 51
},
new Persona {
Nombre = "Mirta", Apellido = "Peroña", Edad = 72
},
new Persona {
Nombre = "Franco", Apellido = "Di Battista", Edad = 14
},
new Persona {
Nombre = "Mirta", Apellido = "Peroña", Edad = 50
},
new Persona {
Nombre = "Maira", Apellido = "Di Battista", Edad = 19
},
};
var c = new Comparador();
Ordenar(datos, c).ForEach(Console.WriteLine);
Console.WriteLine();
Ordenar(datos, c).ForEach(Console.WriteLine);
Console.WriteLine(Sumar(1, 2));
var s = new Sumador(1, 2);
Console.WriteLine(s.Sumar());
Console.ReadLine();
}
//método interno para realizar la operación
protected Nodo insertar(Nodo raizSub, Comparador dato) //COMO PARAMETROS RAIZ Y COMPARADOR
{
if (raizSub == null)
{
raizSub = new Nodo(dato); //Si es nulo no hay nada que comparar
//Si el dato es menor le decimos que lo inserte a la izquierda
}
else if (dato.menorQue(raizSub.valorNodo())) //SI ES MENOR QUE
{
Nodo iz; //Variable para nodo izquierdo
iz = insertar(raizSub.subarbolIzquierdo(), dato); //Insertando hacia la rama izquierda
raizSub.ramaIzdo(iz); //Tirandolo para la rama izquierda
//Si el dato es menor le decimos que lo inserte a la derecha
}
else if (dato.mayorQue(raizSub.valorNodo())) //SI ES MAYOR QUE
{
Nodo dr; //Variable para nodo derecho
dr = insertar(raizSub.subarbolDerecho(), dato); //Insertando hacia la rama derecha
raizSub.ramaDcho(dr); //Tirandolo para la rama derecha
}
else
{
// throw new Exception("Nodo duplicado");
Console.WriteLine($"duplicado!!!! {raizSub.valorNodo()}");
}
return(raizSub); //Retornando la raiz del subarbol
}
public static int CompararValores(object valor, object valor2)
{
IComparable Comparador;
Comparador = valor as IComparable;
return(Comparador.CompareTo(valor2));
}
public DoubleLinkedList(Comparador <T> Funcomparador)
{
start = null;
end = null;
count = 0;
eleminados = 0;
comparador = Funcomparador;
}
public void Eliminar(Object valor) //throws Exception
{
Comparador dato = (Comparador)valor;
Logical flag = new Logical(false);
Raiz = BorrarAvl(Raiz, dato, flag);
}
private NodoAvl BorrarAvl(NodoAvl r, Comparador clave, Logical cambiaAltura) //throws Exception
{
if (r == null)
{
throw new Exception(" Nodo no encontrado ");
}
else if (clave.MenorQue(r.Dato))
{
NodoAvl iz = BorrarAvl((NodoAvl)r.Izquierdo, clave, cambiaAltura);
r.Izquierdo = iz;
if (cambiaAltura.IsLogical)
{
r = Equilibrar1(r, cambiaAltura);
}
}
else if (clave.MayorQue(r.Dato))
{
NodoAvl dr = BorrarAvl((NodoAvl)r.Derecho, clave, cambiaAltura);
r.Derecho = dr;
if (cambiaAltura.IsLogical)
{
r = Equilibrar2(r, cambiaAltura);
}
}
else // Nodo encontrado
{
NodoAvl q = r; // nodo a quitar del árbol
if (q.Izquierdo == null)
{
r = (NodoAvl)q.Derecho;
cambiaAltura.IsLogical = true;
}
else if (q.Derecho == null)
{
r = (NodoAvl)q.Izquierdo;
cambiaAltura.IsLogical = true;
}
else
{ // tiene rama izquierda y derecha
NodoAvl iz = Reemplazar(r, (NodoAvl)r.Izquierdo, cambiaAltura);
r.Izquierdo = iz;
if (cambiaAltura.IsLogical)
{
r = Equilibrar1(r, cambiaAltura);
}
}
q = null;
}
return(r);
}
public TablaHash(int count, Comparador <V> Funcomparador) //se inicializa el diccionario con una cantidad fija de elementos
{
this.comparador = Funcomparador;
Diccionario = new DoubleLinkedList <LlaveValor <V> >();
largoTabla = count;
for (int i = 0; i < largoTabla; i++)
{
Diccionario.Add(new LlaveValor <V>(i));
}
}
public Buscar(frmPrincipal principal, List<AlbumControl> album_list)
{
InitializeComponent();
this.album_list = album_list; //TODO: pasando el principal no nocesite la lista de album
this.principal = principal;
_comparador = new Comparador(lvSearch);
lvSearch.ListViewItemSorter = _comparador;
lvSearch.Sorting = SortOrder.None;
}
public TablaHash(int count, Comparador <V> Funcomparador)
{
this.comparador = Funcomparador;
Diccionario = new DoubleLinkedList <LlaveValor <V> >();
largoTabla = count;
for (int i = 0; i < largoTabla; i++)
{
Diccionario.Add(new LlaveValor <V>(i));
}
}
private NodoAvl borrarAvl(NodoAvl r, Comparador clave,
Logical cambiaAltura) //throws Exception
{
if (r == null)
{
throw new Exception(" Nodo no encontrado ");
}
else if (clave.menorQue(r.valorNodo()))
{
NodoAvl iz;
iz = borrarAvl((NodoAvl)r.subarbolIzdo(), clave, cambiaAltura);
r.ramaIzdo(iz);
if (cambiaAltura.booleanValue())
{
r = equilibrar1(r, cambiaAltura);
}
}
else if (clave.mayorQue(r.valorNodo()))
{
NodoAvl dr;
dr = borrarAvl((NodoAvl)r.subarbolDcho(), clave, cambiaAltura);
r.ramaDcho(dr);
if (cambiaAltura.booleanValue())
{
r = equilibrar2(r, cambiaAltura);
}
}
else // Nodo encontrado
{
NodoAvl q;
q = r; // nodo a quitar del árbol
if (q.subarbolIzdo() == null)
{
r = (NodoAvl)q.subarbolDcho();
cambiaAltura.setLogical(true);
}
else if (q.subarbolDcho() == null)
{
r = (NodoAvl)q.subarbolIzdo();
cambiaAltura.setLogical(true);
}
else
{ // tiene rama izquierda y derecha
NodoAvl iz;
iz = reemplazar(r, (NodoAvl)r.subarbolIzdo(), cambiaAltura);
r.ramaIzdo(iz);
if (cambiaAltura.booleanValue())
{
r = equilibrar1(r, cambiaAltura);
}
}
q = null;
}
return(r);
}
public void ObtenerMenor()
{
//
var priemerE = 54;
var segundoE = 13;
var esperado = 13;
Comparador comparador = new Comparador();
int actual = comparador.ObtenerMenor(priemerE, segundoE);
Assert.AreEqual(esperado, actual);
}
private NodoAvl insertarAvl(NodoAvl raiz, Comparador dt, Logical h)
{
// NodoAvl n1;
if (raiz == null)
{
raiz = new NodoAvl(dt);
h.setLogical(true);
}
else if (dt.menorNumero(raiz.valorNodo()))
{
ramaDerecha(raiz, dt, h);
}
else if (dt.mayorNumero(raiz.valorNodo()))
{
ramaIzquierda(raiz, dt, h);
}
// raiz 1 Guatemala loclla
// derecho 1. zacapa lolo
// 1 zacapa papa
else if (dt.igualque(raiz.valorNodo()))
{
if (dt.departamentoMayor(raiz.valorNodo()))
{
raiz = ramaDerecha(raiz, dt, h);
}
else if (dt.departamentoMenor(raiz.valorNodo()))
{
raiz = ramaIzquierda(raiz, dt, h);
}
else if (dt.departamentoIgual(raiz.valorNodo()))
{
if (dt.nombreAlfabeticoDer(raiz.valorNodo()))
{
raiz = ramaDerecha(raiz, dt, h);
}
else if (dt.nombreAlfabeticoIzq(raiz.valorNodo()))
{
raiz = ramaIzquierda(raiz, dt, h);
}
}
}
else
{
throw new Exception("No puede haber claves repetidas ");
}
return(raiz);
}
void Iniciar()
{
sistemaMenus = GetComponent <SistemaMenus>();
sistemaDMG = GetComponent <SistemaDMG>();
sistemaGuardado = transform.Find("SaveManager").GetComponent <SistemaGuardado>();
inventario = GameObject.FindGameObjectWithTag("Inventario").GetComponent <Inventario>();
//Carga las opciones
sistemaGuardado.LoadOpciones();
accionActual = Accion.ESPERA;
enemigosCombate.AddRange(GameObject.FindGameObjectsWithTag("Enemigo"));
heroesCombate.AddRange(GameObject.FindGameObjectsWithTag("Player"));
//Carga datos de los heroes
if (!nuevaRun)
{
//Carga el sistema break
sistemaGuardado.LoadBreak(sistemaMenus.sistemaBreak);
//Carga los heroes
for (int i = 0; i < heroesCombate.Count; i++)
{
heroesCombate[i].GetComponent <HeroeStateMachine>().heroe = sistemaGuardado.LoadHeroe(heroesCombate[i].GetComponent <HeroeStateMachine>().heroe);
}
//sistemaDMG.statHandler.ActualizarInfo();
}
//Y los guarda
for (int i = 0; i < heroesCombate.Count; i++)
{
sistemaGuardado.SaveHeroe(heroesCombate[i].GetComponent <HeroeStateMachine>().heroe);
}
turnosPersonajes.AddRange(enemigosCombate);
turnosPersonajes.AddRange(heroesCombate);
cantEnemigosCombate = enemigosCombate.Count;
//Ordenar por velocidad
Comparador comparador = new Comparador();
turnosPersonajes.Sort(comparador);
//Crear Inventario si no esta hecho
if (inventario.Objetos.Count == 0)
{
inventario.CrearInventario();
}
}
/// <summary>
/// Devuelve la entrada correspondiente a un Key
/// </summary>
public bool Entrada(T entrada, out TVal ret)
{
foreach (var x in this)
{
if (Comparador.Equals(x.Key, entrada))
{
ret = x.Value;
return(true);
}
}
ret = default(TVal);
return(false);
}
public void ObtenerMenor()
{
//Organizar datos
var primerElemento = 33;
var segundoElemento = 15;
var esperado = 15;
// ejecute
Comparador comparador = new Comparador();
int actual = comparador.Obtenermenor(primerElemento, segundoElemento);
// Comprobar
Assert.AreEqual(esperado, actual);
}
public static void Main(string[] args)
{
Comparador comp = new Comparador(Aux.comparaDatos);
Comparador comp2 = new Comparador(Aux2.comparaDatos);
MainClass mc = new MainClass();
mc.imprimeAuxs("Antes de Ordenar", mc.auxs);
mc.ordena(comp, mc.auxs);
mc.imprimeAuxs("Después de Ordenar", mc.auxs);
mc.imprimeAuxs("Antes de Ordenar 2", mc.auxs2);
mc.ordena(comp2, mc.auxs2);
mc.imprimeAuxs("Después de Ordenar 2", mc.auxs2);
Console.ReadLine();
}
public virtual void Agregar(T valor)
{
Comparador c = (Comparador)valor;
NodoListaEnlazada <T> nuevo = new NodoListaEnlazada <T>(c);
if (Primero == null)
{
Primero = nuevo;
Ultimo = nuevo;
nuevo.Anterior = null;
nuevo.Siguiente = null;
}
else
{
NodoListaEnlazada <T> aux = Primero;
while (aux != null && c.MenorQue(aux.Dato)) //aux.Valor < valor
{
aux = aux.Siguiente;
}
if (aux == null)
{
nuevo.Anterior = Ultimo;
Ultimo.Siguiente = nuevo;
nuevo.Siguiente = null;
Ultimo = nuevo;
}
else
{
if (aux.Anterior == null)
{
Primero = nuevo;
}
else
{
aux.Anterior.Siguiente = nuevo;
}
nuevo.Anterior = aux.Anterior;
aux.Anterior = nuevo;
nuevo.Siguiente = aux;
}
}
Count++;
}
public void ObtenerMenor()
{
///Arange--Organizar datos
var primerElemento = 50;
var segundoElemento = 25;
var esperado = 25;
/// Act--Ejecutar
Comparador comparador = new Comparador();
int actual = comparador.Obtenermenor(primerElemento, segundoElemento);
/// Assert Comprobar
Assert.AreEqual(esperado, actual);
}
static public string rcPreorden(Nodo r, Comparador dato)
{
if (r != null)
{
if (dato.BusquedaAvanzada(r.valorNodo()) == false)
{
return(rcPreorden(r.subarbolIzq(), dato) + rcPreorden(r.subarbolDch(), dato));
}
else if (dato.BusquedaAvanzada(r.valorNodo()) == true)
{
return(r.visitarNodo());
}
}
return("");
}
internal void ordena(Comparador compara, object [] cosas)
{
Object temp;
for (int i = 0; i < cosas.Length; i++)
{
for (int j = 0; j < cosas.Length - 1; j++)
{
if (compara(cosas[j], cosas[j + 1]) > 0)
{
temp = cosas[j];
cosas[j] = cosas[j + 1];
cosas[j + 1] = (object)temp;
}
}
}
}
public void ObtenerMenor()
{
// AAA = Arrange Act Assert
// Organizar los datos -- Arrange
var primerElemento = 57;
var segundoElemento = 20;
var esperado = 20;
//Ejecutar -- Act
Comparador comparador = new Comparador();
int actual = comparador.ObtenerMenor(primerElemento, segundoElemento);
//Comprobar -- Assert
Assert.AreEqual(esperado, actual);
}
static void Main(string[] args)
{
var testeDelegate = new TesteDelegate();
// implementando delegate apontando para o método CompararNomes
var comparador = new Comparador(NomeCompleto.CompararNome);
// ordenaa lista de nomes em ordem crescente
testeDelegate.Ordenar(comparador);
// exibe a lista de nomes
testeDelegate.ImprimeNomes();
comparador = new Comparador(NomeCompleto.PrimeiroNomeEhMaior);
testeDelegate.PrimeiroEhMaior(comparador);
}
public void Ordenar(Comparador comparar)
{
object temp;
for (int i = 0; i < nomes.Length; i++)
{
for (int j = i; j < nomes.Length; j++)
{
if (comparar(nomes[i], nomes[j]) > 0)
{
temp = nomes[i];
nomes[i] = nomes[j];
nomes[j] = temp as NomeCompleto;
}
}
}
}
static List <Persona> Ordenar(IEnumerable <Persona> datos, Comparador c)
{
var lista = new List <Persona>(datos);
for (var i = 0; i < lista.Count - 1; i++)
{
for (var j = i + 1; j < lista.Count; j++)
{
if (c.Comparar(lista[j], lista[i]) < 0)
{
var tmp = lista[i];
lista[i] = lista[j];
lista[j] = tmp;
}
}
}
return(lista);
}
//método interno para realizar la operación
protected Nodo eliminar(Nodo raizSub, Comparador dato) //Enviamos como parametro raizSub y dato
{
if (raizSub == null)
{
throw new Exception("No encontrado el nodo con la clave"); //Si es nulo no hay nada que eliminar y lanzamos una excepcion
//Si el dato es menor que
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato); //Eliminamos la rama izquierda
raizSub.ramaIzdo(iz);
//Si el dato es mayor que
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato); //Eliminamos la rama derecha
raizSub.ramaDcho(dr);
}
else // Nodo encontrado
{
Nodo q;
q = raizSub; // nodo a quitar del árbol
if (q.subarbolIzquierdo() == null) //Si no tiene valor en la izquierda
{
raizSub = q.subarbolDerecho(); //Agarramos la derecha
}
else if (q.subarbolDerecho() == null) //Si no tiene valor en la derecha
{
raizSub = q.subarbolIzquierdo(); //Agarramos el izquierda
//Si ninguno es nulo
}
else // tiene rama izquierda y derecha
{
q = reemplazar(q); //Lo reemplazamos
}
q = null; //De lo contrario q es igual a nulo
}
return(raizSub);
}
protected Nodo buscar(Nodo raizSub, Comparador buscado)
{
if (raizSub == null)
{
return(null);
}
else if (buscado.igualQue(raizSub.valorNodo()))
{
return(raizSub);
}
else if (buscado.menorQue(raizSub.valorNodo()))
{
return(buscar(raizSub.subarbolIzdo(), buscado));
}
else
{
return(buscar(raizSub.subarbolDcho(), buscado));
}
}
protected Nodo buscar(Nodo raizSub, Comparador buscado)
{
if (raizSub == null)
{
return(null);
}
else if (buscado.nombreIgualDep(raizSub.valorNodo()))
{
return(raizSub);
}
else if (buscado.nombreDiferentDep(raizSub.valorNodo()))
{
return(buscar(raizSub.subarbolIzdo(), buscado));
}
else
{
return(buscar(raizSub.subarbolDcho(), buscado));
}
}
protected Nodo buscar(Nodo raizSub, Comparador buscado)
{
if (raizSub == null)
{
return(null);
}
else if (buscado.departamentoIgual(raizSub.valorNodo()))
{
return(raizSub);
}
else if (buscado.departamentoMenor(raizSub.valorNodo()))
{
return(buscar(raizSub.subarbolIzdo(), buscado));
}
else
{
return(buscar(raizSub.subarbolDcho(), buscado));
}
}
protected Nodo localizar(Nodo raizSub, Comparador buscado)
{
if (raizSub == null)
{
return(null);
}
else if (buscado.igualQue(raizSub.valorNodo()))
{
return(raiz);
}
else if (buscado.menorQue(raizSub.valorNodo()))
{
return(localizar(raizSub.subarbolIzquierdo(), buscado));
}
else
{
return(localizar(raizSub.subarbolDerecho(), buscado));
}
}
