public static void Main(string[] args)
{
ArbolBinario <int> arbolBinarioA = new ArbolBinario <int>(1);
ArbolBinario <int> hijoIzquierdo = new ArbolBinario <int>(2);
hijoIzquierdo.agregarHijoIzquierdo(new ArbolBinario <int>(3));
hijoIzquierdo.agregarHijoDerecho(new ArbolBinario <int>(4));
ArbolBinario <int> hijoDerecho = new ArbolBinario <int>(5);
hijoDerecho.agregarHijoIzquierdo(new ArbolBinario <int>(6));
hijoDerecho.agregarHijoDerecho(new ArbolBinario <int>(7));
arbolBinarioA.agregarHijoIzquierdo(hijoIzquierdo);
arbolBinarioA.agregarHijoDerecho(hijoDerecho);
arbolBinarioA.preorden();
arbolBinarioA.inorden();
arbolBinarioA.postorden();
arbolBinarioA.recorridoPorNiveles();
Console.WriteLine("prueba del commit");
Console.Write("Presione una tecla para concluir la ejecucion . . . ");
Console.ReadKey(true);
}
public IActionResult Index()//Menu del Programa
{
if (Singleton.Instance.VerificacionHospitales != 1)
{
//Creacion de todos los hospitales
var filename = System.IO.Path.Combine(_enviroment.ContentRootPath, "Upload", "Municipios.csv");
string ccc = System.IO.File.ReadAllText(filename);
foreach (string row in ccc.Split('\n'))
{
ColaPrioridad <DatosPaciente> NuevoHospital = new ColaPrioridad <DatosPaciente>();
ArbolBinario <DatosPaciente> NuevaBusquedadHospital = new ArbolBinario <DatosPaciente>();
EstructuraDeFechas <DatosPaciente> NuevoEstructuraFechas = new EstructuraDeFechas <DatosPaciente>();
if (!string.IsNullOrEmpty(row))
{
var result = Regex.Split(row, "(?:^|,)(\"(?:[^\"]+|\"\")*\"|[^,]*)");
string Muni = Convert.ToString(result[1].Replace('\r', ' ').ToUpper());
string Municipio = Regex.Replace(Muni, @"\s", "").ToUpper();
Singleton.Instance.HospitalesColas.Encolar(Singleton.Instance.HospitalesColas.CrearEstructura(Municipio, NuevoHospital));
Singleton.Instance.BusquedadHospitales.Encolar(Singleton.Instance.BusquedadHospitales.CrearEstructura(Municipio, NuevaBusquedadHospital));
Singleton.Instance.BusquedadHospitalApellido.Encolar(Singleton.Instance.BusquedadHospitalApellido.CrearEstructura(Municipio, NuevaBusquedadHospital));
Singleton.Instance.BusquedadHospitalDPI.Encolar(Singleton.Instance.BusquedadHospitalDPI.CrearEstructura(Municipio, NuevaBusquedadHospital));
Singleton.Instance.EstructuraParaCitas.Encolar(Singleton.Instance.EstructuraParaCitas.CrearEstructura(Municipio, NuevoEstructuraFechas));
}
}
//Negacion para que ya no lo vuelva a hacer
Singleton.Instance.VerificacionHospitales++;
}
Singleton.Instance.Listacamasvacunacion.Clear();
return(View());
}
public void Iniciar()
{
arbol = new ArbolBinario();
matriz = new Matriz(1);
jugador1 = "";
jugador2 = "";
}
static void Main(string[] args)
{
// prueba1
ArbolBinario <int> uno = new ArbolBinario <int>(5,
new ArbolBinario <int>(8,
new ArbolBinario <int>(13)),
new ArbolBinario <int>(9,
new ArbolBinario <int>(2),
new ArbolBinario <int>(6)));
ArbolBinario <int> dos = new ArbolBinario <int>(2,
new ArbolBinario <int>(1),
new ArbolBinario <int>(4));
Arborear(uno, dos, Suma);
PrintArbol(uno, 0);
Console.WriteLine();
// prueba2
ArbolBinario <string> primero = new ArbolBinario <string>("ti",
new ArbolBinario <string>("la"));
ArbolBinario <string> segundo = new ArbolBinario <string>("na",
new ArbolBinario <string>("ti", null,
new ArbolBinario <string>("nce")),
new ArbolBinario <string>("ss", null,
new ArbolBinario <string>("pri")));
Arborear(primero, segundo, Concatena);
PrintArbol(primero, 0);
}
public bool cargaUsuarios(string direccion, ArbolBinario arbol_usuarios)//codigo basico para leer un archivo
{
bool todo_bien;
System.IO.StreamReader archivo = new System.IO.StreamReader(direccion);
string entrada = "";
string[] split;
Objetos.Persona actual;
try
{
if (archivo.Peek() > -1)
{
entrada = archivo.ReadLine();//me como la primera linea porque por lo visto es una cabezera
}
while (archivo.Peek() > -1)
{
entrada = archivo.ReadLine();
if (!string.IsNullOrEmpty(entrada))
{
split = entrada.Split(',');
actual = new Objetos.Persona(split[1], split[2]);
actual.setConectado(split[3]);
arbol_usuarios.insertar(actual, split[0]);
}
}
todo_bien = true;
}
catch (Exception e)
{
todo_bien = false;
}
archivo.Close();
return(todo_bien);
}
public static void MenuPrincipal(ArbolBinario arbol)
{
Console.Clear();
Console.WriteLine("REPRESENTACIÓN VISUAL | Nodos = {0}", arbol.Cantidad());
Console.WriteLine("-----------------------------------------------------");
Console.WriteLine("Pre-Orden:");
arbol.ImprimirPreOrden();
Console.WriteLine("In-Orden:");
arbol.ImprimirInOrden();
Console.WriteLine("Post-Orden:");
arbol.ImprimirPostOrden();
Console.WriteLine("_____________________________________________________\n");
Console.WriteLine(".---. .---. .---. .---. .---.");
Console.WriteLine("| 1 | | 2 | | 3 | | 4 | | E |");
Console.WriteLine("'===' '===' '===' '===' '==='");
Console.WriteLine("Insertar Pr.O Nivel In.O Nivel Po.O Nivel Eliminar\n");
Console.WriteLine(".---. .---. .---. .---.");
Console.WriteLine("| 5 | | 6 | | 7 | | 8 |");
Console.WriteLine("'===' '===' '===' '==='");
Console.WriteLine("Elim. Men. Elim. May. +Info Limpiar\n");
Console.WriteLine("[ESC] para salir del programa!");
}
static void Main(string[] args)
{
try
{
ArbolBinario arbol;
Nodo a1, a2, a;
Stack pila = new Stack();
a1 = ArbolBinario.nuevoArbol(null, "Maria", null);
a2 = ArbolBinario.nuevoArbol(null, "Fabricio", null);
a = ArbolBinario.nuevoArbol(a1, "Gaby", a2);
pila.Push(a); //apilar
a1 = ArbolBinario.nuevoArbol(null, "Andrea", null);
a2 = ArbolBinario.nuevoArbol(null, "Abel", null);
a = ArbolBinario.nuevoArbol(a1, "Monica", a2);
pila.Push(a);//apilar
a1 = (Nodo)pila.Pop();
a2 = (Nodo)pila.Pop();
a = ArbolBinario.nuevoArbol(a1, "Hector", a2);
arbol = new ArbolBinario(a);
Console.WriteLine("preorden");
preorden(a);
}
catch (Exception ex)
{
Console.WriteLine("error" + ex.Message);
}
}
public static void Resuelve(ref int mejor, ArbolBinario primero, ArbolBinario segundo, int llamado, List <ArbolBinario> lista, int ultimoIndice)
{
if (ArbolesIguales(primero, segundo))
{
if (mejor > llamado)
{
mejor = llamado;
}
return;
}
else if (ultimoIndice < lista.Count && lista[ultimoIndice].EsHoja)
{
return;
}
for (int indice = ultimoIndice; indice < lista.Count; indice++)
{
ArbolBinario temp = lista[indice].Izquierdo;
lista[indice].Izquierdo = lista[indice].Derecho;
lista[indice].Derecho = temp;
Resuelve(ref mejor, primero, segundo, llamado + 1, lista, indice + 1);
temp = lista[indice].Izquierdo;
lista[indice].Izquierdo = lista[indice].Derecho;
lista[indice].Derecho = temp;
}
}
public void Imprimir_1()
{
ArbolBinario arbol = new ArbolBinario(); // crea un objeto arbol de BinaryTree
arbol.z = new Node("A");
arbol.z.Izquierda = new Node("B");
arbol.z.Medio = new Node("C");
arbol.z.Derecha = new Node("D");
arbol.z.Izquierda.Izquierda = new Node("E");
arbol.z.Izquierda.Medio = new Node("F");
arbol.z.Izquierda.Derecha = new Node("G");
arbol.z.Derecha.Izquierda = new Node("H");
arbol.z.Derecha.Medio = new Node("I");
arbol.z.Derecha.Derecha = new Node("J");
arbol.z.Izquierda.Izquierda.Izquierda = new Node("K");
arbol.z.Izquierda.Izquierda.Medio = new Node("L");
arbol.z.Izquierda.Izquierda.Derecha = new Node("M");
arbol.z.Izquierda.Derecha.Medio = new Node("N");
arbol.z.Derecha.Izquierda.Medio = new Node("O");
arbol.z.Derecha.Derecha.Izquierda = new Node("P");
arbol.z.Derecha.Derecha.Derecha = new Node("Q");
arbol.z.Izquierda.Derecha.Medio.Izquierda = new Node("R");
arbol.z.Izquierda.Derecha.Medio.Derecha = new Node("S");
Console.WriteLine("Arbol A");
Console.WriteLine("Recorrido preorden " + "del arbol es ");
arbol.PrintPreorder();
Console.WriteLine();
Console.WriteLine("\nRecorrido posorden " + "del arbol es ");
arbol.PrintPostorder();
Console.WriteLine();
Console.ReadKey();
}
public static int MinimoInserciones1(ArbolBinario arbol)
{
int cuantos = 0;
Resuelve1(arbol, arbol, ref cuantos);
return(cuantos);
}
private string codigoArbol(ArbolBinario mi_arbol)//funcion para generar el codigo del arbol binario de busqueda
{
string salida = "digraph g{\n";
Nodo aux = mi_arbol.raiz;
salida += codigoNodos(aux);
salida += "}";
return(salida);
}
public static int MinimoInserciones2(ArbolBinario arbol)
{
int altura = 0;
Altura(arbol, 0, ref altura);
List <ArbolBinario> nueva = new List <ArbolBinario>();
nueva.Add(arbol);
return(Resuelve2(nueva, altura, 0, 0));
}
public static void HazPreorden(ArbolBinario arbol, List <ArbolBinario> lista)
{
lista.Add(arbol);
if (arbol.Izquierdo != null)
{
HazPreorden(arbol.Izquierdo, lista);
}
if (arbol.Derecho != null)
{
HazPreorden(arbol.Derecho, lista);
}
}
public static int MinimoMutaciones(ArbolBinario uno, ArbolBinario dos)
{
int minimo = int.MaxValue;
List <ArbolBinario> myLista = new List <ArbolBinario>();
HazPreorden(uno, myLista);
Resuelve(ref minimo, uno, dos, -1, myLista, 0);
if (minimo == int.MaxValue)
{
return(-1);
}
return(minimo);
}
//Guarda árbol binario en la sesión del usuario
public static string GuardarArbol(ArbolBinario arbolBinario)
{
// Se almacena en la SESSION simulando el guardado en una base de datos
// se recomienta no utilizar la session en los servicios REST en modo "stateless" por
// efectos de rendimiento, para este caso se hace la excepcion ya que es un ejemplo, evitando asi la
// generación y almacenamiento de una base de datos local o remota
string id = Guid.NewGuid().ToString();
HttpContext.Current.Session[id] = arbolBinario;
// retorna identificador del arbol creado
return(id);
}
public static void Aplica <T5>(ArbolBinario <T5> primero, ArbolBinario <T5> segundo, Opera <T5> opera)
{
primero.Valor = opera(primero.Valor, segundo.Valor);
if (primero.Izquierdo != null && segundo.Izquierdo != null)
{
Aplica(primero.Izquierdo, segundo.Izquierdo, opera);
}
if (primero.Derecho != null && segundo.Derecho != null)
{
Aplica(primero.Derecho, segundo.Derecho, opera);
}
}
public bool graficarArbolBinario(ArbolBinario mi_arbol, string ruta_destino = "", string nombre_dot = "arbolBin.dot", string nombre_png = "arbolBin.png")
{
// string nombre_dot = "arbolBin.dot";//nombre del dot
// string nombre_png = "arbolBin.png";//nombre de la grafica
string ruta_dot = Path.Combine(path, nombre_dot);
string ruta_png = Path.Combine(path, nombre_png);
bool bandera;
//if (guardar(codigoArbol(mi_arbol), Path.Combine(ruta, nombre_dot)))//1.guardamos el codigo
if (guardar(codigoArbol(mi_arbol), nombre_dot))//1.guardamos el codigo
{
string comando;
if (!string.IsNullOrEmpty(ruta_destino))
{
comando = "dot " + "-Tpng \"" + ruta_dot + "\" -o \"" + Path.Combine(ruta_destino, nombre_png) + "\"";
}
else
{
comando = "dot " + "-Tpng \"" + ruta_dot + "\" -o \"" + ruta_png + "\"";
}
if (llamarCMD(comando))
{
bandera = true;
}
else
{
bandera = false;
}
}
else
{
bandera = false;
}
if (bandera)
{
if (!string.IsNullOrEmpty(ruta_destino))
{
string destino_final = Path.Combine(ruta_destino, nombre_png);
if (File.Exists(destino_final))//elimino la imagen anterior
{
File.Delete(destino_final);
}
if (File.Exists(ruta_png))
{
copiarImagen(ruta_png, destino_final);
}
}
}
return(bandera);
}
public static void MP_T6_EliminarMayor(ArbolBinario arbol)
{
if (!arbol.EstaVacio)
{
arbol.EliminarNodoMayor();
Console.Write("ÉXITO: Se eliminó el nodo mayor :)");
}
else
{
Console.Write("FRACASO: El árbol está vacío!");
}
Thread.Sleep(1500);
}
private bool BuscarMedicinas(ArbolBinario <Indice> indice, List <string> nombresMedicina)
{
var existen = true;
foreach (var item in nombresMedicina)
{
var medicina = new Indice(0, item);
if (indice.Buscar(indice.Raiz, medicina, Indice.OrdenarPorNombre) == false)
{
existen = false;
}
}
return(existen);
}
public static void HazEntreOrden <T3>(ArbolBinario <T3> arbolActual, List <ArbolBinario <T3> > lista)
{
if (arbolActual.HijoIzq != null)
{
HazEntreOrden(arbolActual.HijoIzq, lista);
}
lista.Add(arbolActual);
if (arbolActual.HijoDer != null)
{
HazEntreOrden(arbolActual.HijoDer, lista);
}
}
// MENUS Y CAPTURA DE TECLAS
//----------------------------------------------
public static void Menu(ArbolBinario arbol)
{
ConsoleKeyInfo tecla;
do
{
Vista.MenuPrincipal(arbol);
tecla = Console.ReadKey(true);
switch (tecla.Key.ToString())
{
case "D1":
MP_T1_Insertar(arbol);
break;
case "D2":
MP_T2_PreOrdNiv(arbol);
break;
case "D3":
MP_T3_InOrdNiv(arbol);
break;
case "D4":
MP_T4_PostOrdNiv(arbol);
break;
case "E":
MP_TE_Eliminar(arbol);
break;
case "D5":
MP_T5_EliminarMenor(arbol);
break;
case "D6":
MP_T6_EliminarMayor(arbol);
break;
case "D7":
MP_T7_MasInformacion(arbol);
break;
case "D8":
arbol.Limpiar();
break;
}
} while (tecla.Key != ConsoleKey.Escape);
}
public static void Altura(ArbolBinario arbolActual, int llamado, ref int mayor)
{
if (llamado > mayor)
{
mayor = llamado;
}
if (arbolActual.HijoIzq != null)
{
Altura(arbolActual.HijoIzq, llamado + 1, ref mayor);
}
if (arbolActual.HijoDer != null)
{
Altura(arbolActual.HijoDer, llamado + 1, ref mayor);
}
}
public static void PreOrdenPorNivel <T4>(ArbolBinario <T4> arbol, int llamado, int nivel, List <ArbolBinario <T4> > lista)
{
if (llamado == nivel)
{
lista.Add(arbol);
return;
}
if (arbol.Izquierdo != null)
{
PreOrdenPorNivel(arbol.Izquierdo, llamado + 1, nivel, lista);
}
if (arbol.Derecho != null)
{
PreOrdenPorNivel(arbol.Derecho, llamado + 1, nivel, lista);
}
}
// MANEJO DE ACCIÓN POR TECLA PRESIONADA
//--------------------------------------------------------------
public static void MP_T1_Insertar(ArbolBinario arbol)
{
bool leido = true;
Console.Write("Dame dato para insertar en árbol: ");
int dato = Helpers.LeerNumero(ref leido);
if (leido)
{
arbol.Insertar(dato);
}
if (!leido)
{
Thread.Sleep(1500);
}
}
public static bool ArbolesIguales(ArbolBinario primeroActual, ArbolBinario segundoActual)
{
if (primeroActual.EsHoja && segundoActual.EsHoja)
{
return(true);
}
if (((primeroActual.Izquierdo != null && segundoActual.Izquierdo != null && ArbolesIguales(primeroActual.Izquierdo, segundoActual.Izquierdo)) ||
(primeroActual.Izquierdo == null && segundoActual.Izquierdo == null)) && ((primeroActual.Derecho != null && segundoActual.Derecho != null &&
ArbolesIguales(primeroActual.Derecho, segundoActual.Derecho)) || (primeroActual.Derecho == null && segundoActual.Derecho == null)))
{
return(true);
}
return(false);
}
public static void PrintArbol(ArbolBinario arbolActual, int llamado)
{
for (int veces = 0; veces <= llamado; veces++)
{
Console.Write("-");
}
Console.Write(arbolActual.Valor);
Console.WriteLine();
if (arbolActual.HijoIzq != null)
{
PrintArbol(arbolActual.HijoIzq, llamado + 1);
}
if (arbolActual.HijoDer != null)
{
PrintArbol(arbolActual.HijoDer, llamado + 1);
}
}
public static ArbolBinario <T3> Arborear <T3>(ArbolBinario <T3> primero, ArbolBinario <T3> segundo, Opera <T3> operacion)
{
int altura = Altura(primero);
for (int nivel = 0; nivel <= altura; nivel++)
{
List <ArbolBinario <T3> > arbolesNivel = new List <ArbolBinario <T3> >();
PreOrdenPorNivel(primero, 0, nivel, arbolesNivel);
foreach (var arbol in arbolesNivel)
{
Aplica(arbol, segundo, operacion);
}
}
return(primero);
}
public static void PrintArbol <T7>(ArbolBinario <T7> arbolActual, int llamado)
{
for (int nivel = 0; nivel <= llamado; nivel++)
{
Console.Write("-");
}
Console.Write(arbolActual.Valor);
Console.WriteLine();
if (arbolActual.Izquierdo != null)
{
PrintArbol(arbolActual.Izquierdo, llamado + 1);
}
if (arbolActual.Derecho != null)
{
PrintArbol(arbolActual.Derecho, llamado + 1);
}
}
public IHttpActionResult Crear([FromBody] string[] nodosArbol)
{
// Instancia clase de arbol binario
ArbolBinario arbolBinario = new ArbolBinario();
// Itera e inserta cada nodo de arbol
for (int i = 0; i < nodosArbol.Length; i++)
{
arbolBinario.InsertarNodo(int.Parse(nodosArbol[i]));
}
// Almacena arbol en base de datos (simulación), retorna identificador
// único para posterior consulta
string id = Almacenamiento.GuardarArbol(arbolBinario);
// Retorna ID de arbol creado
return(Ok(id));
}
static void Main(string[] args)
{
ArbolBinario ggmen = new ArbolBinario();
int ob;
int a = 42, b = 53, c = 33, d = 53, e = 72, f = 6, g = 7;
Console.WriteLine(" Insertando valores manualmente en el árbol: ");
ggmen.Agregar(a);
ggmen.Agregar(b);
ggmen.Agregar(c);
ggmen.Agregar(d);
ggmen.Agregar(e);
ggmen.Agregar(f);
ggmen.Agregar(g);
Console.WriteLine(" " + " " + " " + "/" + "e");
Console.WriteLine(" " + " " + "/" + "b");
Console.WriteLine(" " + "/" + "a");
Console.WriteLine("|--" + "g");
Console.WriteLine("c");
Console.WriteLine("|_" + "f");
Console.WriteLine("|_" + "d");
Console.WriteLine("Valores insertados: " + a + " " + b + " " + c + " " + d + " " + e + " " + f + " " + g);
ggmen.PrintAlturaDeCadaNod();
do
{
Console.WriteLine("/////////////////////////////// ");
Console.WriteLine("1.-Cantidad de nodos del arbol.");
Console.WriteLine("2.-Altura del arbol.");
Console.WriteLine("0.-Salir");
ob = int.Parse(Console.ReadLine());
switch (ob)
{
case 1:
Console.WriteLine("Cantidad de nodos del árbol:" + ggmen.Cantidad());
break;
case 2:
Console.WriteLine("La altura del arbol es:" + ggmen.ReturnAltura());
break;
}
} while (ob != 0);
}